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 (at) veillard.com 9 */ 10 11 #include "libxml.h" 12 #include <stdio.h> 13 14 #include <stdlib.h> /* for putenv() */ 15 #include <string.h> 16 #include <libxml/xmlerror.h> 17 #include <libxml/relaxng.h> 18 19 20 static int testlibxml2(void); 21 static int test_module(const char *module); 22 23 static int generic_errors = 0; 24 static int call_tests = 0; 25 static int function_tests = 0; 26 27 static xmlChar chartab[1024]; 28 static int inttab[1024]; 29 static unsigned long longtab[1024]; 30 31 static xmlDocPtr api_doc = NULL; 32 static xmlDtdPtr api_dtd = NULL; 33 static xmlNodePtr api_root = NULL; 34 static xmlAttrPtr api_attr = NULL; 35 static xmlNsPtr api_ns = NULL; 36 37 static void 38 structured_errors(void *userData ATTRIBUTE_UNUSED, 39 xmlErrorPtr error ATTRIBUTE_UNUSED) { 40 generic_errors++; 41 } 42 43 static void 44 free_api_doc(void) { 45 xmlFreeDoc(api_doc); 46 api_doc = NULL; 47 api_dtd = NULL; 48 api_root = NULL; 49 api_attr = NULL; 50 api_ns = NULL; 51 } 52 53 static xmlDocPtr 54 get_api_doc(void) { 55 if (api_doc == NULL) { 56 api_doc = xmlReadMemory("<!DOCTYPE root [<!ELEMENT root EMPTY>]><root xmlns:h='http://example.com/' h:foo='bar'/>", 88, "root_test", NULL, 0); 57 api_root = NULL; 58 api_attr = NULL; 59 } 60 return(api_doc); 61 } 62 63 static xmlDtdPtr 64 get_api_dtd(void) { 65 if ((api_dtd == NULL) || (api_dtd->type != XML_DTD_NODE)) { 66 get_api_doc(); 67 if ((api_doc != NULL) && (api_doc->children != NULL) && 68 (api_doc->children->type == XML_DTD_NODE)) 69 api_dtd = (xmlDtdPtr) api_doc->children; 70 } 71 return(api_dtd); 72 } 73 74 static xmlNodePtr 75 get_api_root(void) { 76 if ((api_root == NULL) || (api_root->type != XML_ELEMENT_NODE)) { 77 get_api_doc(); 78 if ((api_doc != NULL) && (api_doc->children != NULL) && 79 (api_doc->children->next != NULL) && 80 (api_doc->children->next->type == XML_ELEMENT_NODE)) 81 api_root = api_doc->children->next; 82 } 83 return(api_root); 84 } 85 86 static xmlNsPtr 87 get_api_ns(void) { 88 get_api_root(); 89 if (api_root != NULL) 90 api_ns = api_root->nsDef; 91 return(api_ns); 92 } 93 94 static xmlAttrPtr 95 get_api_attr(void) { 96 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) 97 static int nr = 0; 98 xmlChar name[20]; 99 #endif 100 101 if ((api_root == NULL) || (api_root->type != XML_ELEMENT_NODE)) { 102 get_api_root(); 103 } 104 if (api_root == NULL) 105 return(NULL); 106 if (api_root->properties != NULL) { 107 api_attr = api_root->properties; 108 return(api_root->properties); 109 } 110 api_attr = NULL; 111 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) 112 snprintf((char *) name, 20, "foo%d", nr++); 113 api_attr = xmlSetProp(api_root, name, (const xmlChar *) "bar"); 114 #endif 115 return(api_attr); 116 } 117 118 static int quiet = 0; 119 120 int main(int argc, char **argv) { 121 int ret; 122 int blocks, mem; 123 124 #ifdef HAVE_PUTENV 125 /* access to the proxy can slow up regression tests a lot */ 126 putenv((char *) "http_proxy="); 127 #endif 128 129 memset(chartab, 0, sizeof(chartab)); 130 strncpy((char *) chartab, " chartab\n", 20); 131 memset(inttab, 0, sizeof(inttab)); 132 memset(longtab, 0, sizeof(longtab)); 133 134 xmlInitParser(); 135 #ifdef LIBXML_SCHEMAS_ENABLED 136 xmlRelaxNGInitTypes(); 137 #endif 138 139 LIBXML_TEST_VERSION 140 141 xmlSetStructuredErrorFunc(NULL, structured_errors); 142 143 if (argc >= 2) { 144 if (!strcmp(argv[1], "-q")) { 145 quiet = 1; 146 if (argc >= 3) 147 ret = test_module(argv[2]); 148 else 149 ret = testlibxml2(); 150 } else { 151 ret = test_module(argv[1]); 152 } 153 } else 154 ret = testlibxml2(); 155 156 xmlCleanupParser(); 157 blocks = xmlMemBlocks(); 158 mem = xmlMemUsed(); 159 if ((blocks != 0) || (mem != 0)) { 160 printf("testapi leaked %d bytes in %d blocks\n", mem, blocks); 161 } 162 xmlMemoryDump(); 163 164 return (ret != 0); 165 } 166 167 #include <libxml/HTMLparser.h> 168 #include <libxml/HTMLtree.h> 169 #include <libxml/catalog.h> 170 #include <libxml/chvalid.h> 171 #include <libxml/dict.h> 172 #include <libxml/encoding.h> 173 #include <libxml/entities.h> 174 #include <libxml/hash.h> 175 #include <libxml/list.h> 176 #include <libxml/nanoftp.h> 177 #include <libxml/nanohttp.h> 178 #include <libxml/parser.h> 179 #include <libxml/parserInternals.h> 180 #include <libxml/pattern.h> 181 #include <libxml/relaxng.h> 182 #include <libxml/schemasInternals.h> 183 #include <libxml/schematron.h> 184 #include <libxml/tree.h> 185 #include <libxml/uri.h> 186 #include <libxml/valid.h> 187 #include <libxml/xinclude.h> 188 #include <libxml/xmlIO.h> 189 #include <libxml/xmlerror.h> 190 #include <libxml/xmlreader.h> 191 #include <libxml/xmlsave.h> 192 #include <libxml/xmlschemas.h> 193 #include <libxml/xmlschemastypes.h> 194 #include <libxml/xmlstring.h> 195 #include <libxml/xmlwriter.h> 196 #include <libxml/xpath.h> 197 #include <libxml/xpointer.h> 198 #include <libxml/debugXML.h> 199 200 /* 201 We manually define xmlErrMemory because it's normal declaration 202 is "hidden" by #ifdef IN_LIBXML 203 */ 204 void xmlErrMemory(xmlParserCtxtPtr ctxt, const char *extra); 205 206 /* 207 We need some "remote" addresses, but want to avoid getting into 208 name resolution delays, so we use these 209 */ 210 #define REMOTE1GOOD "http://localhost/" 211 #define REMOTE1BAD "http:http://http" 212 #define REMOTE2GOOD "ftp://localhost/foo" 213 214 #define gen_nb_void_ptr 2 215 216 static void *gen_void_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 217 return(NULL); 218 } 219 static void des_void_ptr(int no ATTRIBUTE_UNUSED, void *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 220 } 221 222 #if 0 223 #define gen_nb_const_void_ptr 2 224 225 static const void *gen_const_void_ptr(int no, int nr ATTRIBUTE_UNUSED) { 226 if (no == 0) return((const void *) "immutable string"); 227 return(NULL); 228 } 229 static void des_const_void_ptr(int no ATTRIBUTE_UNUSED, const void *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 230 } 231 #endif 232 233 #define gen_nb_userdata 3 234 235 static void *gen_userdata(int no, int nr ATTRIBUTE_UNUSED) { 236 if (no == 0) return((void *) &call_tests); 237 if (no == 1) return((void *) -1); 238 return(NULL); 239 } 240 static void des_userdata(int no ATTRIBUTE_UNUSED, void *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 241 } 242 243 244 #define gen_nb_int 4 245 246 static int gen_int(int no, int nr ATTRIBUTE_UNUSED) { 247 if (no == 0) return(0); 248 if (no == 1) return(1); 249 if (no == 2) return(-1); 250 if (no == 3) return(122); 251 return(-1); 252 } 253 254 static void des_int(int no ATTRIBUTE_UNUSED, int val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 255 } 256 257 #define gen_nb_parseroptions 5 258 259 static int gen_parseroptions(int no, int nr ATTRIBUTE_UNUSED) { 260 if (no == 0) return(XML_PARSE_NOBLANKS | XML_PARSE_RECOVER); 261 if (no == 1) return(XML_PARSE_NOENT | XML_PARSE_DTDLOAD | XML_PARSE_DTDATTR | XML_PARSE_DTDVALID | XML_PARSE_NOCDATA); 262 if (no == 2) return(XML_PARSE_XINCLUDE | XML_PARSE_NOXINCNODE | XML_PARSE_NSCLEAN); 263 if (no == 3) return(XML_PARSE_XINCLUDE | XML_PARSE_NODICT); 264 return(XML_PARSE_SAX1); 265 } 266 267 static void des_parseroptions(int no ATTRIBUTE_UNUSED, int val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 268 } 269 270 #if 0 271 #define gen_nb_long 5 272 273 static long gen_long(int no, int nr ATTRIBUTE_UNUSED) { 274 if (no == 0) return(0); 275 if (no == 1) return(1); 276 if (no == 2) return(-1); 277 if (no == 3) return(122); 278 return(-1); 279 } 280 281 static void des_long(int no ATTRIBUTE_UNUSED, long val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 282 } 283 #endif 284 285 #define gen_nb_xmlChar 4 286 287 static xmlChar gen_xmlChar(int no, int nr ATTRIBUTE_UNUSED) { 288 if (no == 0) return('a'); 289 if (no == 1) return(' '); 290 if (no == 2) return((xmlChar) '\xf8'); 291 return(0); 292 } 293 294 static void des_xmlChar(int no ATTRIBUTE_UNUSED, xmlChar val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 295 } 296 297 #define gen_nb_unsigned_int 3 298 299 static unsigned int gen_unsigned_int(int no, int nr ATTRIBUTE_UNUSED) { 300 if (no == 0) return(0); 301 if (no == 1) return(1); 302 if (no == 2) return(122); 303 return((unsigned int) -1); 304 } 305 306 static void des_unsigned_int(int no ATTRIBUTE_UNUSED, unsigned int val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 307 } 308 309 #define gen_nb_unsigned_long 4 310 311 static unsigned long gen_unsigned_long(int no, int nr ATTRIBUTE_UNUSED) { 312 if (no == 0) return(0); 313 if (no == 1) return(1); 314 if (no == 2) return(122); 315 return((unsigned long) -1); 316 } 317 318 static void des_unsigned_long(int no ATTRIBUTE_UNUSED, unsigned long val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 319 } 320 321 #define gen_nb_double 4 322 323 static double gen_double(int no, int nr ATTRIBUTE_UNUSED) { 324 if (no == 0) return(0); 325 if (no == 1) return(-1.1); 326 #if defined(LIBXML_XPATH_ENABLED) 327 if (no == 2) return(xmlXPathNAN); 328 #endif 329 return(-1); 330 } 331 332 static void des_double(int no ATTRIBUTE_UNUSED, double val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 333 } 334 335 #define gen_nb_unsigned_long_ptr 2 336 337 static unsigned long *gen_unsigned_long_ptr(int no, int nr) { 338 if (no == 0) return(&longtab[nr]); 339 return(NULL); 340 } 341 342 static void des_unsigned_long_ptr(int no ATTRIBUTE_UNUSED, unsigned long *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 343 } 344 345 #define gen_nb_int_ptr 2 346 347 static int *gen_int_ptr(int no, int nr) { 348 if (no == 0) return(&inttab[nr]); 349 return(NULL); 350 } 351 352 static void des_int_ptr(int no ATTRIBUTE_UNUSED, int *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 353 } 354 355 #define gen_nb_const_char_ptr 4 356 357 static char *gen_const_char_ptr(int no, int nr ATTRIBUTE_UNUSED) { 358 if (no == 0) return((char *) "foo"); 359 if (no == 1) return((char *) "<foo/>"); 360 if (no == 2) return((char *) "test/ent2"); 361 return(NULL); 362 } 363 static void des_const_char_ptr(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 364 } 365 366 #define gen_nb_xmlChar_ptr 2 367 368 static xmlChar *gen_xmlChar_ptr(int no, int nr ATTRIBUTE_UNUSED) { 369 if (no == 0) return(&chartab[0]); 370 return(NULL); 371 } 372 static void des_xmlChar_ptr(int no ATTRIBUTE_UNUSED, xmlChar *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 373 } 374 375 #define gen_nb_FILE_ptr 2 376 377 static FILE *gen_FILE_ptr(int no, int nr ATTRIBUTE_UNUSED) { 378 if (no == 0) return(fopen("test.out", "a+")); 379 return(NULL); 380 } 381 static void des_FILE_ptr(int no ATTRIBUTE_UNUSED, FILE *val, int nr ATTRIBUTE_UNUSED) { 382 if (val != NULL) fclose(val); 383 } 384 385 #define gen_nb_debug_FILE_ptr 2 386 static FILE *gen_debug_FILE_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 387 return(fopen("test.out", "a+")); 388 } 389 static void des_debug_FILE_ptr(int no ATTRIBUTE_UNUSED, FILE *val, int nr ATTRIBUTE_UNUSED) { 390 if (val != NULL) fclose(val); 391 } 392 393 #define gen_nb_const_xmlChar_ptr 5 394 395 static xmlChar *gen_const_xmlChar_ptr(int no, int nr ATTRIBUTE_UNUSED) { 396 if (no == 0) return((xmlChar *) "foo"); 397 if (no == 1) return((xmlChar *) "<foo/>"); 398 if (no == 2) return((xmlChar *) "n" "\xf8" "ne"); 399 if (no == 3) return((xmlChar *) " 2ab "); 400 return(NULL); 401 } 402 static void des_const_xmlChar_ptr(int no ATTRIBUTE_UNUSED, const xmlChar *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 403 } 404 405 #define gen_nb_filepath 8 406 407 static const char *gen_filepath(int no, int nr ATTRIBUTE_UNUSED) { 408 if (no == 0) return("missing.xml"); 409 if (no == 1) return("<foo/>"); 410 if (no == 2) return("test/ent2"); 411 if (no == 3) return("test/valid/REC-xml-19980210.xml"); 412 if (no == 4) return("test/valid/dtds/xhtml1-strict.dtd"); 413 if (no == 5) return(REMOTE1GOOD); 414 if (no == 6) return(REMOTE1BAD); 415 return(NULL); 416 } 417 static void des_filepath(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 418 } 419 420 #define gen_nb_eaten_name 2 421 422 static xmlChar *gen_eaten_name(int no, int nr ATTRIBUTE_UNUSED) { 423 if (no == 0) return(xmlStrdup(BAD_CAST "eaten")); 424 return(NULL); 425 } 426 static void des_eaten_name(int no ATTRIBUTE_UNUSED, xmlChar *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 427 } 428 429 #define gen_nb_fileoutput 6 430 431 static const char *gen_fileoutput(int no, int nr ATTRIBUTE_UNUSED) { 432 if (no == 0) return("/missing.xml"); 433 if (no == 1) return("<foo/>"); 434 if (no == 2) return(REMOTE2GOOD); 435 if (no == 3) return(REMOTE1GOOD); 436 if (no == 4) return(REMOTE1BAD); 437 return(NULL); 438 } 439 static void des_fileoutput(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 440 } 441 442 #define gen_nb_xmlParserCtxtPtr 3 443 static xmlParserCtxtPtr gen_xmlParserCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) { 444 if (no == 0) return(xmlNewParserCtxt()); 445 if (no == 1) return(xmlCreateMemoryParserCtxt("<doc/>", 6)); 446 return(NULL); 447 } 448 static void des_xmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlParserCtxtPtr val, int nr ATTRIBUTE_UNUSED) { 449 if (val != NULL) 450 xmlFreeParserCtxt(val); 451 } 452 453 #define gen_nb_xmlSAXHandlerPtr 2 454 static xmlSAXHandlerPtr gen_xmlSAXHandlerPtr(int no, int nr ATTRIBUTE_UNUSED) { 455 #ifdef LIBXML_SAX1_ENABLED 456 if (no == 0) return((xmlSAXHandlerPtr) &xmlDefaultSAXHandler); 457 #endif 458 return(NULL); 459 } 460 static void des_xmlSAXHandlerPtr(int no ATTRIBUTE_UNUSED, xmlSAXHandlerPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 461 } 462 463 #define gen_nb_xmlValidCtxtPtr 2 464 static xmlValidCtxtPtr gen_xmlValidCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) { 465 #ifdef LIBXML_VALID_ENABLED 466 if (no == 0) return(xmlNewValidCtxt()); 467 #endif 468 return(NULL); 469 } 470 static void des_xmlValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlValidCtxtPtr val, int nr ATTRIBUTE_UNUSED) { 471 #ifdef LIBXML_VALID_ENABLED 472 if (val != NULL) 473 xmlFreeValidCtxt(val); 474 #endif 475 } 476 477 #define gen_nb_xmlParserInputBufferPtr 8 478 479 static xmlParserInputBufferPtr gen_xmlParserInputBufferPtr(int no, int nr ATTRIBUTE_UNUSED) { 480 if (no == 0) return(xmlParserInputBufferCreateFilename("missing.xml", XML_CHAR_ENCODING_NONE)); 481 if (no == 1) return(xmlParserInputBufferCreateFilename("<foo/>", XML_CHAR_ENCODING_NONE)); 482 if (no == 2) return(xmlParserInputBufferCreateFilename("test/ent2", XML_CHAR_ENCODING_NONE)); 483 if (no == 3) return(xmlParserInputBufferCreateFilename("test/valid/REC-xml-19980210.xml", XML_CHAR_ENCODING_NONE)); 484 if (no == 4) return(xmlParserInputBufferCreateFilename("test/valid/dtds/xhtml1-strict.dtd", XML_CHAR_ENCODING_NONE)); 485 if (no == 5) return(xmlParserInputBufferCreateFilename(REMOTE1GOOD, XML_CHAR_ENCODING_NONE)); 486 if (no == 6) return(xmlParserInputBufferCreateFilename(REMOTE1BAD, XML_CHAR_ENCODING_NONE)); 487 return(NULL); 488 } 489 static void des_xmlParserInputBufferPtr(int no ATTRIBUTE_UNUSED, xmlParserInputBufferPtr val, int nr ATTRIBUTE_UNUSED) { 490 xmlFreeParserInputBuffer(val); 491 } 492 493 #define gen_nb_xmlDocPtr 4 494 static xmlDocPtr gen_xmlDocPtr(int no, int nr ATTRIBUTE_UNUSED) { 495 if (no == 0) return(xmlNewDoc(BAD_CAST "1.0")); 496 if (no == 1) return(xmlReadMemory("<foo/>", 6, "test", NULL, 0)); 497 if (no == 2) return(xmlReadMemory("<!DOCTYPE foo []> <foo/>", 24, "test", NULL, 0)); 498 return(NULL); 499 } 500 static void des_xmlDocPtr(int no ATTRIBUTE_UNUSED, xmlDocPtr val, int nr ATTRIBUTE_UNUSED) { 501 if ((val != NULL) && (val != api_doc) && (val->doc != api_doc)) 502 xmlFreeDoc(val); 503 } 504 505 #define gen_nb_xmlAttrPtr 2 506 static xmlAttrPtr gen_xmlAttrPtr(int no, int nr ATTRIBUTE_UNUSED) { 507 if (no == 0) return(get_api_attr()); 508 return(NULL); 509 } 510 static void des_xmlAttrPtr(int no, xmlAttrPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 511 if (no == 0) free_api_doc(); 512 } 513 514 #define gen_nb_xmlDictPtr 2 515 static xmlDictPtr gen_xmlDictPtr(int no, int nr ATTRIBUTE_UNUSED) { 516 if (no == 0) return(xmlDictCreate()); 517 return(NULL); 518 } 519 static void des_xmlDictPtr(int no ATTRIBUTE_UNUSED, xmlDictPtr val, int nr ATTRIBUTE_UNUSED) { 520 if (val != NULL) 521 xmlDictFree(val); 522 } 523 524 #define gen_nb_xmlNodePtr 3 525 static xmlNodePtr gen_xmlNodePtr(int no, int nr ATTRIBUTE_UNUSED) { 526 if (no == 0) return(xmlNewPI(BAD_CAST "test", NULL)); 527 if (no == 1) return(get_api_root()); 528 return(NULL); 529 /* if (no == 2) return((xmlNodePtr) get_api_doc()); */ 530 } 531 static void des_xmlNodePtr(int no, xmlNodePtr val, int nr ATTRIBUTE_UNUSED) { 532 if (no == 1) { 533 free_api_doc(); 534 } else if (val != NULL) { 535 xmlUnlinkNode(val); 536 xmlFreeNode(val); 537 } 538 } 539 540 #define gen_nb_xmlDtdPtr 3 541 static xmlDtdPtr gen_xmlDtdPtr(int no, int nr ATTRIBUTE_UNUSED) { 542 if (no == 0) 543 return(xmlNewDtd(NULL, BAD_CAST "dtd", BAD_CAST"foo", BAD_CAST"bar")); 544 if (no == 1) return(get_api_dtd()); 545 return(NULL); 546 } 547 static void des_xmlDtdPtr(int no, xmlDtdPtr val, int nr ATTRIBUTE_UNUSED) { 548 if (no == 1) free_api_doc(); 549 else if (val != NULL) { 550 xmlUnlinkNode((xmlNodePtr) val); 551 xmlFreeNode((xmlNodePtr) val); 552 } 553 } 554 555 #define gen_nb_xmlNsPtr 2 556 static xmlNsPtr gen_xmlNsPtr(int no, int nr ATTRIBUTE_UNUSED) { 557 if (no == 0) return(get_api_ns()); 558 return(NULL); 559 } 560 static void des_xmlNsPtr(int no, xmlNsPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 561 if (no == 0) free_api_doc(); 562 } 563 564 #define gen_nb_xmlNodePtr_in 3 565 static xmlNodePtr gen_xmlNodePtr_in(int no, int nr ATTRIBUTE_UNUSED) { 566 if (no == 0) return(xmlNewPI(BAD_CAST "test", NULL)); 567 if (no == 0) return(xmlNewText(BAD_CAST "text")); 568 return(NULL); 569 } 570 static void des_xmlNodePtr_in(int no ATTRIBUTE_UNUSED, xmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 571 } 572 573 #ifdef LIBXML_WRITER_ENABLED 574 #define gen_nb_xmlTextWriterPtr 2 575 static xmlTextWriterPtr gen_xmlTextWriterPtr(int no, int nr ATTRIBUTE_UNUSED) { 576 if (no == 0) return(xmlNewTextWriterFilename("test.out", 0)); 577 return(NULL); 578 } 579 static void des_xmlTextWriterPtr(int no ATTRIBUTE_UNUSED, xmlTextWriterPtr val, int nr ATTRIBUTE_UNUSED) { 580 if (val != NULL) xmlFreeTextWriter(val); 581 } 582 #endif 583 584 #ifdef LIBXML_READER_ENABLED 585 #define gen_nb_xmlTextReaderPtr 4 586 static xmlTextReaderPtr gen_xmlTextReaderPtr(int no, int nr ATTRIBUTE_UNUSED) { 587 if (no == 0) return(xmlNewTextReaderFilename("test/ent2")); 588 if (no == 1) return(xmlNewTextReaderFilename("test/valid/REC-xml-19980210.xml")); 589 if (no == 2) return(xmlNewTextReaderFilename("test/valid/dtds/xhtml1-strict.dtd")); 590 return(NULL); 591 } 592 static void des_xmlTextReaderPtr(int no ATTRIBUTE_UNUSED, xmlTextReaderPtr val, int nr ATTRIBUTE_UNUSED) { 593 if (val != NULL) xmlFreeTextReader(val); 594 } 595 #endif 596 597 #define gen_nb_xmlBufferPtr 3 598 static const xmlChar *static_buf_content = (xmlChar *)"a static buffer"; 599 static xmlBufferPtr gen_xmlBufferPtr(int no, int nr ATTRIBUTE_UNUSED) { 600 if (no == 0) return(xmlBufferCreate()); 601 if (no == 1) return(xmlBufferCreateStatic((void *)static_buf_content, 13)); 602 return(NULL); 603 } 604 static void des_xmlBufferPtr(int no ATTRIBUTE_UNUSED, xmlBufferPtr val, int nr ATTRIBUTE_UNUSED) { 605 if (val != NULL) { 606 xmlBufferFree(val); 607 } 608 } 609 610 #define gen_nb_xmlListPtr 2 611 static xmlListPtr gen_xmlListPtr(int no, int nr ATTRIBUTE_UNUSED) { 612 if (no == 0) return(xmlListCreate(NULL, NULL)); 613 return(NULL); 614 } 615 static void des_xmlListPtr(int no ATTRIBUTE_UNUSED, xmlListPtr val, int nr ATTRIBUTE_UNUSED) { 616 if (val != NULL) { 617 xmlListDelete(val); 618 } 619 } 620 621 #define gen_nb_xmlHashTablePtr 2 622 static xmlHashTablePtr gen_xmlHashTablePtr(int no, int nr ATTRIBUTE_UNUSED) { 623 if (no == 0) return(xmlHashCreate(10)); 624 return(NULL); 625 } 626 static void des_xmlHashTablePtr(int no ATTRIBUTE_UNUSED, xmlHashTablePtr val, int nr ATTRIBUTE_UNUSED) { 627 if (val != NULL) { 628 xmlHashFree(val, NULL); 629 } 630 } 631 632 #include <libxml/xpathInternals.h> 633 634 #ifdef LIBXML_XPATH_ENABLED 635 #define gen_nb_xmlXPathObjectPtr 5 636 static xmlXPathObjectPtr gen_xmlXPathObjectPtr(int no, int nr ATTRIBUTE_UNUSED) { 637 if (no == 0) return(xmlXPathNewString(BAD_CAST "string object")); 638 if (no == 1) return(xmlXPathNewFloat(1.1)); 639 if (no == 2) return(xmlXPathNewBoolean(1)); 640 if (no == 3) return(xmlXPathNewNodeSet(NULL)); 641 return(NULL); 642 } 643 static void des_xmlXPathObjectPtr(int no ATTRIBUTE_UNUSED, xmlXPathObjectPtr val, int nr ATTRIBUTE_UNUSED) { 644 if (val != NULL) { 645 xmlXPathFreeObject(val); 646 } 647 } 648 #endif 649 650 #ifdef LIBXML_OUTPUT_ENABLED 651 #define gen_nb_xmlOutputBufferPtr 2 652 static xmlOutputBufferPtr gen_xmlOutputBufferPtr(int no, int nr ATTRIBUTE_UNUSED) { 653 if (no == 0) return(xmlOutputBufferCreateFilename("test.out", NULL, 0)); 654 return(NULL); 655 } 656 static void des_xmlOutputBufferPtr(int no ATTRIBUTE_UNUSED, xmlOutputBufferPtr val, int nr ATTRIBUTE_UNUSED) { 657 if (val != NULL) { 658 xmlOutputBufferClose(val); 659 } 660 } 661 #endif 662 663 #ifdef LIBXML_FTP_ENABLED 664 #define gen_nb_xmlNanoFTPCtxtPtr 4 665 static void *gen_xmlNanoFTPCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) { 666 if (no == 0) return(xmlNanoFTPNewCtxt(REMOTE2GOOD)); 667 if (no == 1) return(xmlNanoFTPNewCtxt(REMOTE1GOOD)); 668 if (no == 2) return(xmlNanoFTPNewCtxt("foo")); 669 return(NULL); 670 } 671 static void des_xmlNanoFTPCtxtPtr(int no ATTRIBUTE_UNUSED, void *val, int nr ATTRIBUTE_UNUSED) { 672 if (val != NULL) { 673 xmlNanoFTPFreeCtxt(val); 674 } 675 } 676 #endif 677 678 #ifdef LIBXML_HTTP_ENABLED 679 #define gen_nb_xmlNanoHTTPCtxtPtr 1 680 static void *gen_xmlNanoHTTPCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) { 681 if (no == 0) return(xmlNanoHTTPOpen(REMOTE1GOOD, NULL)); 682 if (no == 1) return(xmlNanoHTTPOpen(REMOTE2GOOD, NULL)); 683 if (no == 2) return(xmlNanoHTTPOpen(REMOTE1BAD, NULL)); 684 return(NULL); 685 } 686 static void des_xmlNanoHTTPCtxtPtr(int no ATTRIBUTE_UNUSED, void *val, int nr ATTRIBUTE_UNUSED) { 687 if (val != NULL) { 688 xmlNanoHTTPClose(val); 689 } 690 } 691 #endif 692 693 #define gen_nb_xmlCharEncoding 4 694 static xmlCharEncoding gen_xmlCharEncoding(int no, int nr ATTRIBUTE_UNUSED) { 695 if (no == 0) return(XML_CHAR_ENCODING_UTF8); 696 if (no == 1) return(XML_CHAR_ENCODING_NONE); 697 if (no == 2) return(XML_CHAR_ENCODING_8859_1); 698 return(XML_CHAR_ENCODING_ERROR); 699 } 700 static void des_xmlCharEncoding(int no ATTRIBUTE_UNUSED, xmlCharEncoding val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 701 } 702 703 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED) 704 705 #define gen_nb_xmlExpCtxtPtr 1 706 static xmlExpCtxtPtr gen_xmlExpCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 707 return(NULL); 708 } 709 static void des_xmlExpCtxtPtr(int no ATTRIBUTE_UNUSED, xmlExpCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 710 } 711 712 #define gen_nb_xmlExpNodePtr 1 713 static xmlExpNodePtr gen_xmlExpNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 714 return(NULL); 715 } 716 static void des_xmlExpNodePtr(int no ATTRIBUTE_UNUSED, xmlExpNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 717 } 718 719 #endif 720 721 #if defined(LIBXML_SCHEMAS_ENABLED) 722 #define gen_nb_xmlSchemaPtr 1 723 static xmlSchemaPtr gen_xmlSchemaPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 724 return(NULL); 725 } 726 static void des_xmlSchemaPtr(int no ATTRIBUTE_UNUSED, xmlSchemaPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 727 } 728 729 #define gen_nb_xmlSchemaValidCtxtPtr 1 730 static xmlSchemaValidCtxtPtr gen_xmlSchemaValidCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 731 return(NULL); 732 } 733 static void des_xmlSchemaValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchemaValidCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 734 } 735 736 #endif /* LIBXML_SCHEMAS_ENABLED */ 737 738 #define gen_nb_xmlHashDeallocator 2 739 static void 740 test_xmlHashDeallocator(void *payload ATTRIBUTE_UNUSED, xmlChar *name ATTRIBUTE_UNUSED) { 741 } 742 743 static xmlHashDeallocator gen_xmlHashDeallocator(int no, int nr ATTRIBUTE_UNUSED) { 744 if (no == 0) return(test_xmlHashDeallocator); 745 return(NULL); 746 } 747 static void des_xmlHashDeallocator(int no ATTRIBUTE_UNUSED, xmlHashDeallocator val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 748 } 749 750 751 static void desret_int(int val ATTRIBUTE_UNUSED) { 752 } 753 static void desret_xmlChar(xmlChar val ATTRIBUTE_UNUSED) { 754 } 755 static void desret_long(long val ATTRIBUTE_UNUSED) { 756 } 757 static void desret_unsigned_long(unsigned long val ATTRIBUTE_UNUSED) { 758 } 759 static void desret_double(double val ATTRIBUTE_UNUSED) { 760 } 761 static void desret_xmlCharEncoding(xmlCharEncoding val ATTRIBUTE_UNUSED) { 762 } 763 #if 0 764 static void desret_const_void_ptr(void *val ATTRIBUTE_UNUSED) { 765 } 766 #endif 767 static void desret_void_ptr(void *val ATTRIBUTE_UNUSED) { 768 } 769 static void desret_const_char_ptr(const char *val ATTRIBUTE_UNUSED) { 770 } 771 static void desret_const_xmlChar_ptr(const xmlChar *val ATTRIBUTE_UNUSED) { 772 } 773 static void desret_xmlChar_ptr(xmlChar *val) { 774 if (val != NULL) 775 xmlFree(val); 776 } 777 static void desret_xmlDocPtr(xmlDocPtr val) { 778 if (val != api_doc) 779 xmlFreeDoc(val); 780 } 781 static void desret_xmlDictPtr(xmlDictPtr val) { 782 xmlDictFree(val); 783 } 784 #ifdef LIBXML_OUTPUT_ENABLED 785 static void desret_xmlOutputBufferPtr(xmlOutputBufferPtr val) { 786 xmlOutputBufferClose(val); 787 } 788 #endif 789 #ifdef LIBXML_READER_ENABLED 790 static void desret_xmlTextReaderPtr(xmlTextReaderPtr val) { 791 xmlFreeTextReader(val); 792 } 793 #endif 794 static void desret_xmlNodePtr(xmlNodePtr val) { 795 if ((val != NULL) && (val != api_root) && (val != (xmlNodePtr) api_doc)) { 796 xmlUnlinkNode(val); 797 xmlFreeNode(val); 798 } 799 } 800 static void desret_xmlAttrPtr(xmlAttrPtr val) { 801 if (val != NULL) { 802 xmlUnlinkNode((xmlNodePtr) val); 803 xmlFreeNode((xmlNodePtr) val); 804 } 805 } 806 static void desret_xmlEntityPtr(xmlEntityPtr val) { 807 if (val != NULL) { 808 xmlUnlinkNode((xmlNodePtr) val); 809 xmlFreeNode((xmlNodePtr) val); 810 } 811 } 812 static void desret_xmlElementPtr(xmlElementPtr val) { 813 if (val != NULL) { 814 xmlUnlinkNode((xmlNodePtr) val); 815 } 816 } 817 static void desret_xmlAttributePtr(xmlAttributePtr val) { 818 if (val != NULL) { 819 xmlUnlinkNode((xmlNodePtr) val); 820 } 821 } 822 static void desret_xmlNsPtr(xmlNsPtr val ATTRIBUTE_UNUSED) { 823 } 824 static void desret_xmlDtdPtr(xmlDtdPtr val) { 825 desret_xmlNodePtr((xmlNodePtr)val); 826 } 827 #ifdef LIBXML_XPATH_ENABLED 828 static void desret_xmlXPathObjectPtr(xmlXPathObjectPtr val) { 829 xmlXPathFreeObject(val); 830 } 831 static void desret_xmlNodeSetPtr(xmlNodeSetPtr val) { 832 xmlXPathFreeNodeSet(val); 833 } 834 #endif 835 static void desret_xmlParserCtxtPtr(xmlParserCtxtPtr val) { 836 xmlFreeParserCtxt(val); 837 } 838 static void desret_xmlParserInputBufferPtr(xmlParserInputBufferPtr val) { 839 xmlFreeParserInputBuffer(val); 840 } 841 static void desret_xmlParserInputPtr(xmlParserInputPtr val) { 842 xmlFreeInputStream(val); 843 } 844 #ifdef LIBXML_WRITER_ENABLED 845 static void desret_xmlTextWriterPtr(xmlTextWriterPtr val) { 846 xmlFreeTextWriter(val); 847 } 848 #endif 849 static void desret_xmlBufferPtr(xmlBufferPtr val) { 850 xmlBufferFree(val); 851 } 852 #ifdef LIBXML_SCHEMAS_ENABLED 853 static void desret_xmlSchemaParserCtxtPtr(xmlSchemaParserCtxtPtr val) { 854 xmlSchemaFreeParserCtxt(val); 855 } 856 static void desret_xmlSchemaTypePtr(xmlSchemaTypePtr val ATTRIBUTE_UNUSED) { 857 } 858 static void desret_xmlRelaxNGParserCtxtPtr(xmlRelaxNGParserCtxtPtr val) { 859 xmlRelaxNGFreeParserCtxt(val); 860 } 861 #endif 862 #ifdef LIBXML_HTML_ENABLED 863 static void desret_const_htmlEntityDesc_ptr(const htmlEntityDesc * val ATTRIBUTE_UNUSED) { 864 } 865 #endif 866 #ifdef LIBXML_HTTP_ENABLED 867 static void desret_xmlNanoHTTPCtxtPtr(void *val) { 868 xmlNanoHTTPClose(val); 869 } 870 #endif 871 #ifdef LIBXML_FTP_ENABLED 872 static void desret_xmlNanoFTPCtxtPtr(void *val) { 873 xmlNanoFTPClose(val); 874 } 875 #endif 876 /* cut and pasted from autogenerated to avoid troubles */ 877 #define gen_nb_const_xmlChar_ptr_ptr 1 878 static xmlChar ** gen_const_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 879 return(NULL); 880 } 881 static void des_const_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, const xmlChar ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 882 } 883 884 #define gen_nb_unsigned_char_ptr 1 885 static unsigned char * gen_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 886 return(NULL); 887 } 888 static void des_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, unsigned char * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 889 } 890 891 #define gen_nb_const_unsigned_char_ptr 1 892 static unsigned char * gen_const_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 893 return(NULL); 894 } 895 static void des_const_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, const unsigned char * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 896 } 897 898 #ifdef LIBXML_HTML_ENABLED 899 #define gen_nb_const_htmlNodePtr 1 900 static htmlNodePtr gen_const_htmlNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 901 return(NULL); 902 } 903 static void des_const_htmlNodePtr(int no ATTRIBUTE_UNUSED, const htmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 904 } 905 #endif 906 907 #ifdef LIBXML_HTML_ENABLED 908 #define gen_nb_htmlDocPtr 3 909 static htmlDocPtr gen_htmlDocPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 910 if (no == 0) return(htmlNewDoc(NULL, NULL)); 911 if (no == 1) return(htmlReadMemory("<html/>", 7, "test", NULL, 0)); 912 return(NULL); 913 } 914 static void des_htmlDocPtr(int no ATTRIBUTE_UNUSED, htmlDocPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 915 if ((val != NULL) && (val != api_doc) && (val->doc != api_doc)) 916 xmlFreeDoc(val); 917 } 918 static void desret_htmlDocPtr(htmlDocPtr val) { 919 if ((val != NULL) && (val != api_doc) && (val->doc != api_doc)) 920 xmlFreeDoc(val); 921 } 922 #define gen_nb_htmlParserCtxtPtr 3 923 static htmlParserCtxtPtr gen_htmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 924 if (no == 0) return(xmlNewParserCtxt()); 925 if (no == 1) return(htmlCreateMemoryParserCtxt("<html/>", 7)); 926 return(NULL); 927 } 928 static void des_htmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, htmlParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 929 if (val != NULL) 930 htmlFreeParserCtxt(val); 931 } 932 static void desret_htmlParserCtxtPtr(htmlParserCtxtPtr val) { 933 if (val != NULL) 934 htmlFreeParserCtxt(val); 935 } 936 #endif 937 938 #ifdef LIBXML_XPATH_ENABLED 939 #define gen_nb_xmlNodeSetPtr 1 940 static xmlNodeSetPtr gen_xmlNodeSetPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 941 return(NULL); 942 } 943 static void des_xmlNodeSetPtr(int no ATTRIBUTE_UNUSED, xmlNodeSetPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 944 } 945 #endif 946 947 #ifdef LIBXML_DEBUG_ENABLED 948 #ifdef LIBXML_XPATH_ENABLED 949 #define gen_nb_xmlShellCtxtPtr 1 950 static xmlShellCtxtPtr gen_xmlShellCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 951 return(NULL); 952 } 953 static void des_xmlShellCtxtPtr(int no ATTRIBUTE_UNUSED, xmlShellCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 954 } 955 #endif 956 #endif 957 958 #ifdef LIBXML_PATTERN_ENABLED 959 #define gen_nb_xmlPatternPtr 1 960 static xmlPatternPtr gen_xmlPatternPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 961 return(NULL); 962 } 963 static void des_xmlPatternPtr(int no ATTRIBUTE_UNUSED, xmlPatternPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 964 } 965 #endif 966 967 #define gen_nb_xmlElementContentPtr 1 968 static xmlElementContentPtr gen_xmlElementContentPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 969 return(NULL); 970 } 971 static void des_xmlElementContentPtr(int no ATTRIBUTE_UNUSED, xmlElementContentPtr val, int nr ATTRIBUTE_UNUSED) { 972 if (val != NULL) 973 xmlFreeElementContent(val); 974 } 975 static void desret_xmlElementContentPtr(xmlElementContentPtr val) { 976 if (val != NULL) 977 xmlFreeElementContent(val); 978 } 979 980 #define gen_nb_xmlParserNodeInfoSeqPtr 1 981 static xmlParserNodeInfoSeqPtr gen_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 982 return(NULL); 983 } 984 static void des_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, xmlParserNodeInfoSeqPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 985 } 986 987 static void desret_const_xmlParserNodeInfo_ptr(const xmlParserNodeInfo *val ATTRIBUTE_UNUSED) { 988 } 989 990 #define gen_nb_void_ptr_ptr 1 991 static void ** gen_void_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 992 return(NULL); 993 } 994 static void des_void_ptr_ptr(int no ATTRIBUTE_UNUSED, void ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 995 } 996 997 /************************************************************************ 998 * * 999 * WARNING: end of the manually maintained part of the test code * 1000 * do not remove or alter the CUT HERE line * 1001 * * 1002 ************************************************************************/ 1003 1004 /* CUT HERE: everything below that line is generated */ 1005 #ifdef LIBXML_HTML_ENABLED 1006 static void desret_htmlStatus(htmlStatus val ATTRIBUTE_UNUSED) { 1007 } 1008 1009 #endif 1010 1011 #define gen_nb_xmlAttributeDefault 4 1012 static xmlAttributeDefault gen_xmlAttributeDefault(int no, int nr ATTRIBUTE_UNUSED) { 1013 if (no == 1) return(XML_ATTRIBUTE_FIXED); 1014 if (no == 2) return(XML_ATTRIBUTE_IMPLIED); 1015 if (no == 3) return(XML_ATTRIBUTE_NONE); 1016 if (no == 4) return(XML_ATTRIBUTE_REQUIRED); 1017 return(0); 1018 } 1019 1020 static void des_xmlAttributeDefault(int no ATTRIBUTE_UNUSED, xmlAttributeDefault val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 1021 } 1022 1023 #define gen_nb_xmlAttributeType 4 1024 static xmlAttributeType gen_xmlAttributeType(int no, int nr ATTRIBUTE_UNUSED) { 1025 if (no == 1) return(XML_ATTRIBUTE_CDATA); 1026 if (no == 2) return(XML_ATTRIBUTE_ENTITIES); 1027 if (no == 3) return(XML_ATTRIBUTE_ENTITY); 1028 if (no == 4) return(XML_ATTRIBUTE_ENUMERATION); 1029 return(0); 1030 } 1031 1032 static void des_xmlAttributeType(int no ATTRIBUTE_UNUSED, xmlAttributeType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 1033 } 1034 1035 #define gen_nb_xmlBufferAllocationScheme 4 1036 static xmlBufferAllocationScheme gen_xmlBufferAllocationScheme(int no, int nr ATTRIBUTE_UNUSED) { 1037 if (no == 1) return(XML_BUFFER_ALLOC_BOUNDED); 1038 if (no == 2) return(XML_BUFFER_ALLOC_DOUBLEIT); 1039 if (no == 3) return(XML_BUFFER_ALLOC_EXACT); 1040 if (no == 4) return(XML_BUFFER_ALLOC_HYBRID); 1041 return(0); 1042 } 1043 1044 static void des_xmlBufferAllocationScheme(int no ATTRIBUTE_UNUSED, xmlBufferAllocationScheme val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 1045 } 1046 1047 static void desret_xmlBufferAllocationScheme(xmlBufferAllocationScheme val ATTRIBUTE_UNUSED) { 1048 } 1049 1050 #ifdef LIBXML_CATALOG_ENABLED 1051 #define gen_nb_xmlCatalogAllow 4 1052 static xmlCatalogAllow gen_xmlCatalogAllow(int no, int nr ATTRIBUTE_UNUSED) { 1053 if (no == 1) return(XML_CATA_ALLOW_ALL); 1054 if (no == 2) return(XML_CATA_ALLOW_DOCUMENT); 1055 if (no == 3) return(XML_CATA_ALLOW_GLOBAL); 1056 if (no == 4) return(XML_CATA_ALLOW_NONE); 1057 return(0); 1058 } 1059 1060 static void des_xmlCatalogAllow(int no ATTRIBUTE_UNUSED, xmlCatalogAllow val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 1061 } 1062 1063 static void desret_xmlCatalogAllow(xmlCatalogAllow val ATTRIBUTE_UNUSED) { 1064 } 1065 1066 #endif 1067 1068 #ifdef LIBXML_CATALOG_ENABLED 1069 #define gen_nb_xmlCatalogPrefer 3 1070 static xmlCatalogPrefer gen_xmlCatalogPrefer(int no, int nr ATTRIBUTE_UNUSED) { 1071 if (no == 1) return(XML_CATA_PREFER_NONE); 1072 if (no == 2) return(XML_CATA_PREFER_PUBLIC); 1073 if (no == 3) return(XML_CATA_PREFER_SYSTEM); 1074 return(0); 1075 } 1076 1077 static void des_xmlCatalogPrefer(int no ATTRIBUTE_UNUSED, xmlCatalogPrefer val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 1078 } 1079 1080 static void desret_xmlCatalogPrefer(xmlCatalogPrefer val ATTRIBUTE_UNUSED) { 1081 } 1082 1083 #endif 1084 1085 #define gen_nb_xmlElementContentType 4 1086 static xmlElementContentType gen_xmlElementContentType(int no, int nr ATTRIBUTE_UNUSED) { 1087 if (no == 1) return(XML_ELEMENT_CONTENT_ELEMENT); 1088 if (no == 2) return(XML_ELEMENT_CONTENT_OR); 1089 if (no == 3) return(XML_ELEMENT_CONTENT_PCDATA); 1090 if (no == 4) return(XML_ELEMENT_CONTENT_SEQ); 1091 return(0); 1092 } 1093 1094 static void des_xmlElementContentType(int no ATTRIBUTE_UNUSED, xmlElementContentType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 1095 } 1096 1097 #define gen_nb_xmlElementTypeVal 4 1098 static xmlElementTypeVal gen_xmlElementTypeVal(int no, int nr ATTRIBUTE_UNUSED) { 1099 if (no == 1) return(XML_ELEMENT_TYPE_ANY); 1100 if (no == 2) return(XML_ELEMENT_TYPE_ELEMENT); 1101 if (no == 3) return(XML_ELEMENT_TYPE_EMPTY); 1102 if (no == 4) return(XML_ELEMENT_TYPE_MIXED); 1103 return(0); 1104 } 1105 1106 static void des_xmlElementTypeVal(int no ATTRIBUTE_UNUSED, xmlElementTypeVal val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 1107 } 1108 1109 #define gen_nb_xmlFeature 4 1110 static xmlFeature gen_xmlFeature(int no, int nr ATTRIBUTE_UNUSED) { 1111 if (no == 1) return(XML_WITH_AUTOMATA); 1112 if (no == 2) return(XML_WITH_C14N); 1113 if (no == 3) return(XML_WITH_CATALOG); 1114 if (no == 4) return(XML_WITH_DEBUG); 1115 return(0); 1116 } 1117 1118 static void des_xmlFeature(int no ATTRIBUTE_UNUSED, xmlFeature val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 1119 } 1120 1121 static void desret_xmlParserErrors(xmlParserErrors val ATTRIBUTE_UNUSED) { 1122 } 1123 1124 #ifdef LIBXML_SCHEMAS_ENABLED 1125 #define gen_nb_xmlSchemaValType 4 1126 static xmlSchemaValType gen_xmlSchemaValType(int no, int nr ATTRIBUTE_UNUSED) { 1127 if (no == 1) return(XML_SCHEMAS_ANYSIMPLETYPE); 1128 if (no == 2) return(XML_SCHEMAS_ANYTYPE); 1129 if (no == 3) return(XML_SCHEMAS_ANYURI); 1130 if (no == 4) return(XML_SCHEMAS_BASE64BINARY); 1131 return(0); 1132 } 1133 1134 static void des_xmlSchemaValType(int no ATTRIBUTE_UNUSED, xmlSchemaValType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 1135 } 1136 1137 static void desret_xmlSchemaValType(xmlSchemaValType val ATTRIBUTE_UNUSED) { 1138 } 1139 1140 #endif 1141 1142 #ifdef LIBXML_SCHEMAS_ENABLED 1143 #define gen_nb_xmlSchemaWhitespaceValueType 4 1144 static xmlSchemaWhitespaceValueType gen_xmlSchemaWhitespaceValueType(int no, int nr ATTRIBUTE_UNUSED) { 1145 if (no == 1) return(XML_SCHEMA_WHITESPACE_COLLAPSE); 1146 if (no == 2) return(XML_SCHEMA_WHITESPACE_PRESERVE); 1147 if (no == 3) return(XML_SCHEMA_WHITESPACE_REPLACE); 1148 if (no == 4) return(XML_SCHEMA_WHITESPACE_UNKNOWN); 1149 return(0); 1150 } 1151 1152 static void des_xmlSchemaWhitespaceValueType(int no ATTRIBUTE_UNUSED, xmlSchemaWhitespaceValueType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 1153 } 1154 1155 #endif 1156 1157 #include <libxml/HTMLparser.h> 1158 #include <libxml/HTMLtree.h> 1159 #include <libxml/SAX2.h> 1160 #include <libxml/c14n.h> 1161 #include <libxml/catalog.h> 1162 #include <libxml/chvalid.h> 1163 #include <libxml/debugXML.h> 1164 #include <libxml/dict.h> 1165 #include <libxml/encoding.h> 1166 #include <libxml/entities.h> 1167 #include <libxml/hash.h> 1168 #include <libxml/list.h> 1169 #include <libxml/nanoftp.h> 1170 #include <libxml/nanohttp.h> 1171 #include <libxml/parser.h> 1172 #include <libxml/parserInternals.h> 1173 #include <libxml/pattern.h> 1174 #include <libxml/relaxng.h> 1175 #include <libxml/schemasInternals.h> 1176 #include <libxml/schematron.h> 1177 #include <libxml/tree.h> 1178 #include <libxml/uri.h> 1179 #include <libxml/valid.h> 1180 #include <libxml/xinclude.h> 1181 #include <libxml/xmlIO.h> 1182 #include <libxml/xmlautomata.h> 1183 #include <libxml/xmlerror.h> 1184 #include <libxml/xmlmodule.h> 1185 #include <libxml/xmlreader.h> 1186 #include <libxml/xmlregexp.h> 1187 #include <libxml/xmlsave.h> 1188 #include <libxml/xmlschemas.h> 1189 #include <libxml/xmlschemastypes.h> 1190 #include <libxml/xmlstring.h> 1191 #include <libxml/xmlunicode.h> 1192 #include <libxml/xmlwriter.h> 1193 #include <libxml/xpath.h> 1194 #include <libxml/xpathInternals.h> 1195 #include <libxml/xpointer.h> 1196 static int test_HTMLparser(void); 1197 static int test_HTMLtree(void); 1198 static int test_SAX2(void); 1199 static int test_c14n(void); 1200 static int test_catalog(void); 1201 static int test_chvalid(void); 1202 static int test_debugXML(void); 1203 static int test_dict(void); 1204 static int test_encoding(void); 1205 static int test_entities(void); 1206 static int test_hash(void); 1207 static int test_list(void); 1208 static int test_nanoftp(void); 1209 static int test_nanohttp(void); 1210 static int test_parser(void); 1211 static int test_parserInternals(void); 1212 static int test_pattern(void); 1213 static int test_relaxng(void); 1214 static int test_schemasInternals(void); 1215 static int test_schematron(void); 1216 static int test_tree(void); 1217 static int test_uri(void); 1218 static int test_valid(void); 1219 static int test_xinclude(void); 1220 static int test_xmlIO(void); 1221 static int test_xmlautomata(void); 1222 static int test_xmlerror(void); 1223 static int test_xmlmodule(void); 1224 static int test_xmlreader(void); 1225 static int test_xmlregexp(void); 1226 static int test_xmlsave(void); 1227 static int test_xmlschemas(void); 1228 static int test_xmlschemastypes(void); 1229 static int test_xmlstring(void); 1230 static int test_xmlunicode(void); 1231 static int test_xmlwriter(void); 1232 static int test_xpath(void); 1233 static int test_xpathInternals(void); 1234 static int test_xpointer(void); 1235 1236 /** 1237 * testlibxml2: 1238 * 1239 * Main entry point of the tester for the full libxml2 module, 1240 * it calls all the tester entry point for each module. 1241 * 1242 * Returns the number of error found 1243 */ 1244 static int 1245 testlibxml2(void) 1246 { 1247 int test_ret = 0; 1248 1249 test_ret += test_HTMLparser(); 1250 test_ret += test_HTMLtree(); 1251 test_ret += test_SAX2(); 1252 test_ret += test_c14n(); 1253 test_ret += test_catalog(); 1254 test_ret += test_chvalid(); 1255 test_ret += test_debugXML(); 1256 test_ret += test_dict(); 1257 test_ret += test_encoding(); 1258 test_ret += test_entities(); 1259 test_ret += test_hash(); 1260 test_ret += test_list(); 1261 test_ret += test_nanoftp(); 1262 test_ret += test_nanohttp(); 1263 test_ret += test_parser(); 1264 test_ret += test_parserInternals(); 1265 test_ret += test_pattern(); 1266 test_ret += test_relaxng(); 1267 test_ret += test_schemasInternals(); 1268 test_ret += test_schematron(); 1269 test_ret += test_tree(); 1270 test_ret += test_uri(); 1271 test_ret += test_valid(); 1272 test_ret += test_xinclude(); 1273 test_ret += test_xmlIO(); 1274 test_ret += test_xmlautomata(); 1275 test_ret += test_xmlerror(); 1276 test_ret += test_xmlmodule(); 1277 test_ret += test_xmlreader(); 1278 test_ret += test_xmlregexp(); 1279 test_ret += test_xmlsave(); 1280 test_ret += test_xmlschemas(); 1281 test_ret += test_xmlschemastypes(); 1282 test_ret += test_xmlstring(); 1283 test_ret += test_xmlunicode(); 1284 test_ret += test_xmlwriter(); 1285 test_ret += test_xpath(); 1286 test_ret += test_xpathInternals(); 1287 test_ret += test_xpointer(); 1288 1289 printf("Total: %d functions, %d tests, %d errors\n", 1290 function_tests, call_tests, test_ret); 1291 return(test_ret); 1292 } 1293 1294 1295 static int 1296 test_UTF8ToHtml(void) { 1297 int test_ret = 0; 1298 1299 #if defined(LIBXML_HTML_ENABLED) 1300 int mem_base; 1301 int ret_val; 1302 unsigned char * out; /* a pointer to an array of bytes to store the result */ 1303 int n_out; 1304 int * outlen; /* the length of @out */ 1305 int n_outlen; 1306 unsigned char * in; /* a pointer to an array of UTF-8 chars */ 1307 int n_in; 1308 int * inlen; /* the length of @in */ 1309 int n_inlen; 1310 1311 for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) { 1312 for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) { 1313 for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) { 1314 for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) { 1315 mem_base = xmlMemBlocks(); 1316 out = gen_unsigned_char_ptr(n_out, 0); 1317 outlen = gen_int_ptr(n_outlen, 1); 1318 in = gen_const_unsigned_char_ptr(n_in, 2); 1319 inlen = gen_int_ptr(n_inlen, 3); 1320 1321 ret_val = UTF8ToHtml(out, outlen, (const unsigned char *)in, inlen); 1322 desret_int(ret_val); 1323 call_tests++; 1324 des_unsigned_char_ptr(n_out, out, 0); 1325 des_int_ptr(n_outlen, outlen, 1); 1326 des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2); 1327 des_int_ptr(n_inlen, inlen, 3); 1328 xmlResetLastError(); 1329 if (mem_base != xmlMemBlocks()) { 1330 printf("Leak of %d blocks found in UTF8ToHtml", 1331 xmlMemBlocks() - mem_base); 1332 test_ret++; 1333 printf(" %d", n_out); 1334 printf(" %d", n_outlen); 1335 printf(" %d", n_in); 1336 printf(" %d", n_inlen); 1337 printf("\n"); 1338 } 1339 } 1340 } 1341 } 1342 } 1343 function_tests++; 1344 #endif 1345 1346 return(test_ret); 1347 } 1348 1349 #ifdef LIBXML_HTML_ENABLED 1350 1351 #define gen_nb_const_htmlElemDesc_ptr 1 1352 static htmlElemDesc * gen_const_htmlElemDesc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 1353 return(NULL); 1354 } 1355 static void des_const_htmlElemDesc_ptr(int no ATTRIBUTE_UNUSED, const htmlElemDesc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 1356 } 1357 #endif 1358 1359 1360 static int 1361 test_htmlAttrAllowed(void) { 1362 int test_ret = 0; 1363 1364 #if defined(LIBXML_HTML_ENABLED) 1365 int mem_base; 1366 htmlStatus ret_val; 1367 htmlElemDesc * elt; /* HTML element */ 1368 int n_elt; 1369 xmlChar * attr; /* HTML attribute */ 1370 int n_attr; 1371 int legacy; /* whether to allow deprecated attributes */ 1372 int n_legacy; 1373 1374 for (n_elt = 0;n_elt < gen_nb_const_htmlElemDesc_ptr;n_elt++) { 1375 for (n_attr = 0;n_attr < gen_nb_const_xmlChar_ptr;n_attr++) { 1376 for (n_legacy = 0;n_legacy < gen_nb_int;n_legacy++) { 1377 mem_base = xmlMemBlocks(); 1378 elt = gen_const_htmlElemDesc_ptr(n_elt, 0); 1379 attr = gen_const_xmlChar_ptr(n_attr, 1); 1380 legacy = gen_int(n_legacy, 2); 1381 1382 ret_val = htmlAttrAllowed((const htmlElemDesc *)elt, (const xmlChar *)attr, legacy); 1383 desret_htmlStatus(ret_val); 1384 call_tests++; 1385 des_const_htmlElemDesc_ptr(n_elt, (const htmlElemDesc *)elt, 0); 1386 des_const_xmlChar_ptr(n_attr, (const xmlChar *)attr, 1); 1387 des_int(n_legacy, legacy, 2); 1388 xmlResetLastError(); 1389 if (mem_base != xmlMemBlocks()) { 1390 printf("Leak of %d blocks found in htmlAttrAllowed", 1391 xmlMemBlocks() - mem_base); 1392 test_ret++; 1393 printf(" %d", n_elt); 1394 printf(" %d", n_attr); 1395 printf(" %d", n_legacy); 1396 printf("\n"); 1397 } 1398 } 1399 } 1400 } 1401 function_tests++; 1402 #endif 1403 1404 return(test_ret); 1405 } 1406 1407 #ifdef LIBXML_HTML_ENABLED 1408 1409 #define gen_nb_htmlNodePtr 1 1410 static htmlNodePtr gen_htmlNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 1411 return(NULL); 1412 } 1413 static void des_htmlNodePtr(int no ATTRIBUTE_UNUSED, htmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 1414 } 1415 #endif 1416 1417 1418 static int 1419 test_htmlAutoCloseTag(void) { 1420 int test_ret = 0; 1421 1422 #if defined(LIBXML_HTML_ENABLED) 1423 int mem_base; 1424 int ret_val; 1425 htmlDocPtr doc; /* the HTML document */ 1426 int n_doc; 1427 xmlChar * name; /* The tag name */ 1428 int n_name; 1429 htmlNodePtr elem; /* the HTML element */ 1430 int n_elem; 1431 1432 for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) { 1433 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 1434 for (n_elem = 0;n_elem < gen_nb_htmlNodePtr;n_elem++) { 1435 mem_base = xmlMemBlocks(); 1436 doc = gen_htmlDocPtr(n_doc, 0); 1437 name = gen_const_xmlChar_ptr(n_name, 1); 1438 elem = gen_htmlNodePtr(n_elem, 2); 1439 1440 ret_val = htmlAutoCloseTag(doc, (const xmlChar *)name, elem); 1441 desret_int(ret_val); 1442 call_tests++; 1443 des_htmlDocPtr(n_doc, doc, 0); 1444 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 1445 des_htmlNodePtr(n_elem, elem, 2); 1446 xmlResetLastError(); 1447 if (mem_base != xmlMemBlocks()) { 1448 printf("Leak of %d blocks found in htmlAutoCloseTag", 1449 xmlMemBlocks() - mem_base); 1450 test_ret++; 1451 printf(" %d", n_doc); 1452 printf(" %d", n_name); 1453 printf(" %d", n_elem); 1454 printf("\n"); 1455 } 1456 } 1457 } 1458 } 1459 function_tests++; 1460 #endif 1461 1462 return(test_ret); 1463 } 1464 1465 1466 static int 1467 test_htmlCreateMemoryParserCtxt(void) { 1468 int test_ret = 0; 1469 1470 #if defined(LIBXML_HTML_ENABLED) 1471 int mem_base; 1472 htmlParserCtxtPtr ret_val; 1473 char * buffer; /* a pointer to a char array */ 1474 int n_buffer; 1475 int size; /* the size of the array */ 1476 int n_size; 1477 1478 for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) { 1479 for (n_size = 0;n_size < gen_nb_int;n_size++) { 1480 mem_base = xmlMemBlocks(); 1481 buffer = gen_const_char_ptr(n_buffer, 0); 1482 size = gen_int(n_size, 1); 1483 1484 ret_val = htmlCreateMemoryParserCtxt((const char *)buffer, size); 1485 desret_htmlParserCtxtPtr(ret_val); 1486 call_tests++; 1487 des_const_char_ptr(n_buffer, (const char *)buffer, 0); 1488 des_int(n_size, size, 1); 1489 xmlResetLastError(); 1490 if (mem_base != xmlMemBlocks()) { 1491 printf("Leak of %d blocks found in htmlCreateMemoryParserCtxt", 1492 xmlMemBlocks() - mem_base); 1493 test_ret++; 1494 printf(" %d", n_buffer); 1495 printf(" %d", n_size); 1496 printf("\n"); 1497 } 1498 } 1499 } 1500 function_tests++; 1501 #endif 1502 1503 return(test_ret); 1504 } 1505 1506 #ifdef LIBXML_HTML_ENABLED 1507 1508 #define gen_nb_htmlSAXHandlerPtr 1 1509 static htmlSAXHandlerPtr gen_htmlSAXHandlerPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 1510 return(NULL); 1511 } 1512 static void des_htmlSAXHandlerPtr(int no ATTRIBUTE_UNUSED, htmlSAXHandlerPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 1513 } 1514 #endif 1515 1516 1517 static int 1518 test_htmlCreatePushParserCtxt(void) { 1519 int test_ret = 0; 1520 1521 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_PUSH_ENABLED) 1522 int mem_base; 1523 htmlParserCtxtPtr ret_val; 1524 htmlSAXHandlerPtr sax; /* a SAX handler */ 1525 int n_sax; 1526 void * user_data; /* The user data returned on SAX callbacks */ 1527 int n_user_data; 1528 char * chunk; /* a pointer to an array of chars */ 1529 int n_chunk; 1530 int size; /* number of chars in the array */ 1531 int n_size; 1532 const char * filename; /* an optional file name or URI */ 1533 int n_filename; 1534 xmlCharEncoding enc; /* an optional encoding */ 1535 int n_enc; 1536 1537 for (n_sax = 0;n_sax < gen_nb_htmlSAXHandlerPtr;n_sax++) { 1538 for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) { 1539 for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) { 1540 for (n_size = 0;n_size < gen_nb_int;n_size++) { 1541 for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) { 1542 for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) { 1543 mem_base = xmlMemBlocks(); 1544 sax = gen_htmlSAXHandlerPtr(n_sax, 0); 1545 user_data = gen_userdata(n_user_data, 1); 1546 chunk = gen_const_char_ptr(n_chunk, 2); 1547 size = gen_int(n_size, 3); 1548 filename = gen_fileoutput(n_filename, 4); 1549 enc = gen_xmlCharEncoding(n_enc, 5); 1550 1551 ret_val = htmlCreatePushParserCtxt(sax, user_data, (const char *)chunk, size, filename, enc); 1552 desret_htmlParserCtxtPtr(ret_val); 1553 call_tests++; 1554 des_htmlSAXHandlerPtr(n_sax, sax, 0); 1555 des_userdata(n_user_data, user_data, 1); 1556 des_const_char_ptr(n_chunk, (const char *)chunk, 2); 1557 des_int(n_size, size, 3); 1558 des_fileoutput(n_filename, filename, 4); 1559 des_xmlCharEncoding(n_enc, enc, 5); 1560 xmlResetLastError(); 1561 if (mem_base != xmlMemBlocks()) { 1562 printf("Leak of %d blocks found in htmlCreatePushParserCtxt", 1563 xmlMemBlocks() - mem_base); 1564 test_ret++; 1565 printf(" %d", n_sax); 1566 printf(" %d", n_user_data); 1567 printf(" %d", n_chunk); 1568 printf(" %d", n_size); 1569 printf(" %d", n_filename); 1570 printf(" %d", n_enc); 1571 printf("\n"); 1572 } 1573 } 1574 } 1575 } 1576 } 1577 } 1578 } 1579 function_tests++; 1580 #endif 1581 1582 return(test_ret); 1583 } 1584 1585 1586 static int 1587 test_htmlCtxtReadDoc(void) { 1588 int test_ret = 0; 1589 1590 #if defined(LIBXML_HTML_ENABLED) 1591 int mem_base; 1592 htmlDocPtr ret_val; 1593 htmlParserCtxtPtr ctxt; /* an HTML parser context */ 1594 int n_ctxt; 1595 xmlChar * cur; /* a pointer to a zero terminated string */ 1596 int n_cur; 1597 const char * URL; /* the base URL to use for the document */ 1598 int n_URL; 1599 char * encoding; /* the document encoding, or NULL */ 1600 int n_encoding; 1601 int options; /* a combination of htmlParserOption(s) */ 1602 int n_options; 1603 1604 for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) { 1605 for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) { 1606 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 1607 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 1608 for (n_options = 0;n_options < gen_nb_int;n_options++) { 1609 mem_base = xmlMemBlocks(); 1610 ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0); 1611 cur = gen_const_xmlChar_ptr(n_cur, 1); 1612 URL = gen_filepath(n_URL, 2); 1613 encoding = gen_const_char_ptr(n_encoding, 3); 1614 options = gen_int(n_options, 4); 1615 1616 ret_val = htmlCtxtReadDoc(ctxt, (const xmlChar *)cur, URL, (const char *)encoding, options); 1617 desret_htmlDocPtr(ret_val); 1618 call_tests++; 1619 des_htmlParserCtxtPtr(n_ctxt, ctxt, 0); 1620 des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1); 1621 des_filepath(n_URL, URL, 2); 1622 des_const_char_ptr(n_encoding, (const char *)encoding, 3); 1623 des_int(n_options, options, 4); 1624 xmlResetLastError(); 1625 if (mem_base != xmlMemBlocks()) { 1626 printf("Leak of %d blocks found in htmlCtxtReadDoc", 1627 xmlMemBlocks() - mem_base); 1628 test_ret++; 1629 printf(" %d", n_ctxt); 1630 printf(" %d", n_cur); 1631 printf(" %d", n_URL); 1632 printf(" %d", n_encoding); 1633 printf(" %d", n_options); 1634 printf("\n"); 1635 } 1636 } 1637 } 1638 } 1639 } 1640 } 1641 function_tests++; 1642 #endif 1643 1644 return(test_ret); 1645 } 1646 1647 1648 static int 1649 test_htmlCtxtReadFile(void) { 1650 int test_ret = 0; 1651 1652 #if defined(LIBXML_HTML_ENABLED) 1653 htmlDocPtr ret_val; 1654 htmlParserCtxtPtr ctxt; /* an HTML parser context */ 1655 int n_ctxt; 1656 const char * filename; /* a file or URL */ 1657 int n_filename; 1658 char * encoding; /* the document encoding, or NULL */ 1659 int n_encoding; 1660 int options; /* a combination of htmlParserOption(s) */ 1661 int n_options; 1662 1663 for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) { 1664 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 1665 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 1666 for (n_options = 0;n_options < gen_nb_int;n_options++) { 1667 ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0); 1668 filename = gen_filepath(n_filename, 1); 1669 encoding = gen_const_char_ptr(n_encoding, 2); 1670 options = gen_int(n_options, 3); 1671 1672 ret_val = htmlCtxtReadFile(ctxt, filename, (const char *)encoding, options); 1673 desret_htmlDocPtr(ret_val); 1674 call_tests++; 1675 des_htmlParserCtxtPtr(n_ctxt, ctxt, 0); 1676 des_filepath(n_filename, filename, 1); 1677 des_const_char_ptr(n_encoding, (const char *)encoding, 2); 1678 des_int(n_options, options, 3); 1679 xmlResetLastError(); 1680 } 1681 } 1682 } 1683 } 1684 function_tests++; 1685 #endif 1686 1687 return(test_ret); 1688 } 1689 1690 1691 static int 1692 test_htmlCtxtReadMemory(void) { 1693 int test_ret = 0; 1694 1695 #if defined(LIBXML_HTML_ENABLED) 1696 int mem_base; 1697 htmlDocPtr ret_val; 1698 htmlParserCtxtPtr ctxt; /* an HTML parser context */ 1699 int n_ctxt; 1700 char * buffer; /* a pointer to a char array */ 1701 int n_buffer; 1702 int size; /* the size of the array */ 1703 int n_size; 1704 const char * URL; /* the base URL to use for the document */ 1705 int n_URL; 1706 char * encoding; /* the document encoding, or NULL */ 1707 int n_encoding; 1708 int options; /* a combination of htmlParserOption(s) */ 1709 int n_options; 1710 1711 for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) { 1712 for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) { 1713 for (n_size = 0;n_size < gen_nb_int;n_size++) { 1714 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 1715 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 1716 for (n_options = 0;n_options < gen_nb_int;n_options++) { 1717 mem_base = xmlMemBlocks(); 1718 ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0); 1719 buffer = gen_const_char_ptr(n_buffer, 1); 1720 size = gen_int(n_size, 2); 1721 URL = gen_filepath(n_URL, 3); 1722 encoding = gen_const_char_ptr(n_encoding, 4); 1723 options = gen_int(n_options, 5); 1724 1725 ret_val = htmlCtxtReadMemory(ctxt, (const char *)buffer, size, URL, (const char *)encoding, options); 1726 desret_htmlDocPtr(ret_val); 1727 call_tests++; 1728 des_htmlParserCtxtPtr(n_ctxt, ctxt, 0); 1729 des_const_char_ptr(n_buffer, (const char *)buffer, 1); 1730 des_int(n_size, size, 2); 1731 des_filepath(n_URL, URL, 3); 1732 des_const_char_ptr(n_encoding, (const char *)encoding, 4); 1733 des_int(n_options, options, 5); 1734 xmlResetLastError(); 1735 if (mem_base != xmlMemBlocks()) { 1736 printf("Leak of %d blocks found in htmlCtxtReadMemory", 1737 xmlMemBlocks() - mem_base); 1738 test_ret++; 1739 printf(" %d", n_ctxt); 1740 printf(" %d", n_buffer); 1741 printf(" %d", n_size); 1742 printf(" %d", n_URL); 1743 printf(" %d", n_encoding); 1744 printf(" %d", n_options); 1745 printf("\n"); 1746 } 1747 } 1748 } 1749 } 1750 } 1751 } 1752 } 1753 function_tests++; 1754 #endif 1755 1756 return(test_ret); 1757 } 1758 1759 1760 static int 1761 test_htmlCtxtReset(void) { 1762 int test_ret = 0; 1763 1764 #if defined(LIBXML_HTML_ENABLED) 1765 int mem_base; 1766 htmlParserCtxtPtr ctxt; /* an HTML parser context */ 1767 int n_ctxt; 1768 1769 for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) { 1770 mem_base = xmlMemBlocks(); 1771 ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0); 1772 1773 htmlCtxtReset(ctxt); 1774 call_tests++; 1775 des_htmlParserCtxtPtr(n_ctxt, ctxt, 0); 1776 xmlResetLastError(); 1777 if (mem_base != xmlMemBlocks()) { 1778 printf("Leak of %d blocks found in htmlCtxtReset", 1779 xmlMemBlocks() - mem_base); 1780 test_ret++; 1781 printf(" %d", n_ctxt); 1782 printf("\n"); 1783 } 1784 } 1785 function_tests++; 1786 #endif 1787 1788 return(test_ret); 1789 } 1790 1791 1792 static int 1793 test_htmlCtxtUseOptions(void) { 1794 int test_ret = 0; 1795 1796 #if defined(LIBXML_HTML_ENABLED) 1797 int mem_base; 1798 int ret_val; 1799 htmlParserCtxtPtr ctxt; /* an HTML parser context */ 1800 int n_ctxt; 1801 int options; /* a combination of htmlParserOption(s) */ 1802 int n_options; 1803 1804 for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) { 1805 for (n_options = 0;n_options < gen_nb_int;n_options++) { 1806 mem_base = xmlMemBlocks(); 1807 ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0); 1808 options = gen_int(n_options, 1); 1809 1810 ret_val = htmlCtxtUseOptions(ctxt, options); 1811 desret_int(ret_val); 1812 call_tests++; 1813 des_htmlParserCtxtPtr(n_ctxt, ctxt, 0); 1814 des_int(n_options, options, 1); 1815 xmlResetLastError(); 1816 if (mem_base != xmlMemBlocks()) { 1817 printf("Leak of %d blocks found in htmlCtxtUseOptions", 1818 xmlMemBlocks() - mem_base); 1819 test_ret++; 1820 printf(" %d", n_ctxt); 1821 printf(" %d", n_options); 1822 printf("\n"); 1823 } 1824 } 1825 } 1826 function_tests++; 1827 #endif 1828 1829 return(test_ret); 1830 } 1831 1832 1833 static int 1834 test_htmlElementAllowedHere(void) { 1835 int test_ret = 0; 1836 1837 #if defined(LIBXML_HTML_ENABLED) 1838 int mem_base; 1839 int ret_val; 1840 htmlElemDesc * parent; /* HTML parent element */ 1841 int n_parent; 1842 xmlChar * elt; /* HTML element */ 1843 int n_elt; 1844 1845 for (n_parent = 0;n_parent < gen_nb_const_htmlElemDesc_ptr;n_parent++) { 1846 for (n_elt = 0;n_elt < gen_nb_const_xmlChar_ptr;n_elt++) { 1847 mem_base = xmlMemBlocks(); 1848 parent = gen_const_htmlElemDesc_ptr(n_parent, 0); 1849 elt = gen_const_xmlChar_ptr(n_elt, 1); 1850 1851 ret_val = htmlElementAllowedHere((const htmlElemDesc *)parent, (const xmlChar *)elt); 1852 desret_int(ret_val); 1853 call_tests++; 1854 des_const_htmlElemDesc_ptr(n_parent, (const htmlElemDesc *)parent, 0); 1855 des_const_xmlChar_ptr(n_elt, (const xmlChar *)elt, 1); 1856 xmlResetLastError(); 1857 if (mem_base != xmlMemBlocks()) { 1858 printf("Leak of %d blocks found in htmlElementAllowedHere", 1859 xmlMemBlocks() - mem_base); 1860 test_ret++; 1861 printf(" %d", n_parent); 1862 printf(" %d", n_elt); 1863 printf("\n"); 1864 } 1865 } 1866 } 1867 function_tests++; 1868 #endif 1869 1870 return(test_ret); 1871 } 1872 1873 1874 static int 1875 test_htmlElementStatusHere(void) { 1876 int test_ret = 0; 1877 1878 #if defined(LIBXML_HTML_ENABLED) 1879 int mem_base; 1880 htmlStatus ret_val; 1881 htmlElemDesc * parent; /* HTML parent element */ 1882 int n_parent; 1883 htmlElemDesc * elt; /* HTML element */ 1884 int n_elt; 1885 1886 for (n_parent = 0;n_parent < gen_nb_const_htmlElemDesc_ptr;n_parent++) { 1887 for (n_elt = 0;n_elt < gen_nb_const_htmlElemDesc_ptr;n_elt++) { 1888 mem_base = xmlMemBlocks(); 1889 parent = gen_const_htmlElemDesc_ptr(n_parent, 0); 1890 elt = gen_const_htmlElemDesc_ptr(n_elt, 1); 1891 1892 ret_val = htmlElementStatusHere((const htmlElemDesc *)parent, (const htmlElemDesc *)elt); 1893 desret_htmlStatus(ret_val); 1894 call_tests++; 1895 des_const_htmlElemDesc_ptr(n_parent, (const htmlElemDesc *)parent, 0); 1896 des_const_htmlElemDesc_ptr(n_elt, (const htmlElemDesc *)elt, 1); 1897 xmlResetLastError(); 1898 if (mem_base != xmlMemBlocks()) { 1899 printf("Leak of %d blocks found in htmlElementStatusHere", 1900 xmlMemBlocks() - mem_base); 1901 test_ret++; 1902 printf(" %d", n_parent); 1903 printf(" %d", n_elt); 1904 printf("\n"); 1905 } 1906 } 1907 } 1908 function_tests++; 1909 #endif 1910 1911 return(test_ret); 1912 } 1913 1914 1915 static int 1916 test_htmlEncodeEntities(void) { 1917 int test_ret = 0; 1918 1919 #if defined(LIBXML_HTML_ENABLED) 1920 int mem_base; 1921 int ret_val; 1922 unsigned char * out; /* a pointer to an array of bytes to store the result */ 1923 int n_out; 1924 int * outlen; /* the length of @out */ 1925 int n_outlen; 1926 unsigned char * in; /* a pointer to an array of UTF-8 chars */ 1927 int n_in; 1928 int * inlen; /* the length of @in */ 1929 int n_inlen; 1930 int quoteChar; /* the quote character to escape (' or ") or zero. */ 1931 int n_quoteChar; 1932 1933 for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) { 1934 for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) { 1935 for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) { 1936 for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) { 1937 for (n_quoteChar = 0;n_quoteChar < gen_nb_int;n_quoteChar++) { 1938 mem_base = xmlMemBlocks(); 1939 out = gen_unsigned_char_ptr(n_out, 0); 1940 outlen = gen_int_ptr(n_outlen, 1); 1941 in = gen_const_unsigned_char_ptr(n_in, 2); 1942 inlen = gen_int_ptr(n_inlen, 3); 1943 quoteChar = gen_int(n_quoteChar, 4); 1944 1945 ret_val = htmlEncodeEntities(out, outlen, (const unsigned char *)in, inlen, quoteChar); 1946 desret_int(ret_val); 1947 call_tests++; 1948 des_unsigned_char_ptr(n_out, out, 0); 1949 des_int_ptr(n_outlen, outlen, 1); 1950 des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2); 1951 des_int_ptr(n_inlen, inlen, 3); 1952 des_int(n_quoteChar, quoteChar, 4); 1953 xmlResetLastError(); 1954 if (mem_base != xmlMemBlocks()) { 1955 printf("Leak of %d blocks found in htmlEncodeEntities", 1956 xmlMemBlocks() - mem_base); 1957 test_ret++; 1958 printf(" %d", n_out); 1959 printf(" %d", n_outlen); 1960 printf(" %d", n_in); 1961 printf(" %d", n_inlen); 1962 printf(" %d", n_quoteChar); 1963 printf("\n"); 1964 } 1965 } 1966 } 1967 } 1968 } 1969 } 1970 function_tests++; 1971 #endif 1972 1973 return(test_ret); 1974 } 1975 1976 1977 static int 1978 test_htmlEntityLookup(void) { 1979 int test_ret = 0; 1980 1981 #if defined(LIBXML_HTML_ENABLED) 1982 int mem_base; 1983 const htmlEntityDesc * ret_val; 1984 xmlChar * name; /* the entity name */ 1985 int n_name; 1986 1987 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 1988 mem_base = xmlMemBlocks(); 1989 name = gen_const_xmlChar_ptr(n_name, 0); 1990 1991 ret_val = htmlEntityLookup((const xmlChar *)name); 1992 desret_const_htmlEntityDesc_ptr(ret_val); 1993 call_tests++; 1994 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0); 1995 xmlResetLastError(); 1996 if (mem_base != xmlMemBlocks()) { 1997 printf("Leak of %d blocks found in htmlEntityLookup", 1998 xmlMemBlocks() - mem_base); 1999 test_ret++; 2000 printf(" %d", n_name); 2001 printf("\n"); 2002 } 2003 } 2004 function_tests++; 2005 #endif 2006 2007 return(test_ret); 2008 } 2009 2010 2011 static int 2012 test_htmlEntityValueLookup(void) { 2013 int test_ret = 0; 2014 2015 #if defined(LIBXML_HTML_ENABLED) 2016 int mem_base; 2017 const htmlEntityDesc * ret_val; 2018 unsigned int value; /* the entity's unicode value */ 2019 int n_value; 2020 2021 for (n_value = 0;n_value < gen_nb_unsigned_int;n_value++) { 2022 mem_base = xmlMemBlocks(); 2023 value = gen_unsigned_int(n_value, 0); 2024 2025 ret_val = htmlEntityValueLookup(value); 2026 desret_const_htmlEntityDesc_ptr(ret_val); 2027 call_tests++; 2028 des_unsigned_int(n_value, value, 0); 2029 xmlResetLastError(); 2030 if (mem_base != xmlMemBlocks()) { 2031 printf("Leak of %d blocks found in htmlEntityValueLookup", 2032 xmlMemBlocks() - mem_base); 2033 test_ret++; 2034 printf(" %d", n_value); 2035 printf("\n"); 2036 } 2037 } 2038 function_tests++; 2039 #endif 2040 2041 return(test_ret); 2042 } 2043 2044 2045 static int 2046 test_htmlHandleOmittedElem(void) { 2047 int test_ret = 0; 2048 2049 #if defined(LIBXML_HTML_ENABLED) 2050 int mem_base; 2051 int ret_val; 2052 int val; /* int 0 or 1 */ 2053 int n_val; 2054 2055 for (n_val = 0;n_val < gen_nb_int;n_val++) { 2056 mem_base = xmlMemBlocks(); 2057 val = gen_int(n_val, 0); 2058 2059 ret_val = htmlHandleOmittedElem(val); 2060 desret_int(ret_val); 2061 call_tests++; 2062 des_int(n_val, val, 0); 2063 xmlResetLastError(); 2064 if (mem_base != xmlMemBlocks()) { 2065 printf("Leak of %d blocks found in htmlHandleOmittedElem", 2066 xmlMemBlocks() - mem_base); 2067 test_ret++; 2068 printf(" %d", n_val); 2069 printf("\n"); 2070 } 2071 } 2072 function_tests++; 2073 #endif 2074 2075 return(test_ret); 2076 } 2077 2078 2079 static int 2080 test_htmlIsAutoClosed(void) { 2081 int test_ret = 0; 2082 2083 #if defined(LIBXML_HTML_ENABLED) 2084 int mem_base; 2085 int ret_val; 2086 htmlDocPtr doc; /* the HTML document */ 2087 int n_doc; 2088 htmlNodePtr elem; /* the HTML element */ 2089 int n_elem; 2090 2091 for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) { 2092 for (n_elem = 0;n_elem < gen_nb_htmlNodePtr;n_elem++) { 2093 mem_base = xmlMemBlocks(); 2094 doc = gen_htmlDocPtr(n_doc, 0); 2095 elem = gen_htmlNodePtr(n_elem, 1); 2096 2097 ret_val = htmlIsAutoClosed(doc, elem); 2098 desret_int(ret_val); 2099 call_tests++; 2100 des_htmlDocPtr(n_doc, doc, 0); 2101 des_htmlNodePtr(n_elem, elem, 1); 2102 xmlResetLastError(); 2103 if (mem_base != xmlMemBlocks()) { 2104 printf("Leak of %d blocks found in htmlIsAutoClosed", 2105 xmlMemBlocks() - mem_base); 2106 test_ret++; 2107 printf(" %d", n_doc); 2108 printf(" %d", n_elem); 2109 printf("\n"); 2110 } 2111 } 2112 } 2113 function_tests++; 2114 #endif 2115 2116 return(test_ret); 2117 } 2118 2119 2120 static int 2121 test_htmlIsScriptAttribute(void) { 2122 int test_ret = 0; 2123 2124 #if defined(LIBXML_HTML_ENABLED) 2125 int mem_base; 2126 int ret_val; 2127 xmlChar * name; /* an attribute name */ 2128 int n_name; 2129 2130 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 2131 mem_base = xmlMemBlocks(); 2132 name = gen_const_xmlChar_ptr(n_name, 0); 2133 2134 ret_val = htmlIsScriptAttribute((const xmlChar *)name); 2135 desret_int(ret_val); 2136 call_tests++; 2137 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0); 2138 xmlResetLastError(); 2139 if (mem_base != xmlMemBlocks()) { 2140 printf("Leak of %d blocks found in htmlIsScriptAttribute", 2141 xmlMemBlocks() - mem_base); 2142 test_ret++; 2143 printf(" %d", n_name); 2144 printf("\n"); 2145 } 2146 } 2147 function_tests++; 2148 #endif 2149 2150 return(test_ret); 2151 } 2152 2153 2154 static int 2155 test_htmlNewParserCtxt(void) { 2156 int test_ret = 0; 2157 2158 #if defined(LIBXML_HTML_ENABLED) 2159 int mem_base; 2160 htmlParserCtxtPtr ret_val; 2161 2162 mem_base = xmlMemBlocks(); 2163 2164 ret_val = htmlNewParserCtxt(); 2165 desret_htmlParserCtxtPtr(ret_val); 2166 call_tests++; 2167 xmlResetLastError(); 2168 if (mem_base != xmlMemBlocks()) { 2169 printf("Leak of %d blocks found in htmlNewParserCtxt", 2170 xmlMemBlocks() - mem_base); 2171 test_ret++; 2172 printf("\n"); 2173 } 2174 function_tests++; 2175 #endif 2176 2177 return(test_ret); 2178 } 2179 2180 2181 static int 2182 test_htmlNodeStatus(void) { 2183 int test_ret = 0; 2184 2185 #if defined(LIBXML_HTML_ENABLED) 2186 int mem_base; 2187 htmlStatus ret_val; 2188 htmlNodePtr node; /* an htmlNodePtr in a tree */ 2189 int n_node; 2190 int legacy; /* whether to allow deprecated elements (YES is faster here for Element nodes) */ 2191 int n_legacy; 2192 2193 for (n_node = 0;n_node < gen_nb_const_htmlNodePtr;n_node++) { 2194 for (n_legacy = 0;n_legacy < gen_nb_int;n_legacy++) { 2195 mem_base = xmlMemBlocks(); 2196 node = gen_const_htmlNodePtr(n_node, 0); 2197 legacy = gen_int(n_legacy, 1); 2198 2199 ret_val = htmlNodeStatus((const htmlNodePtr)node, legacy); 2200 desret_htmlStatus(ret_val); 2201 call_tests++; 2202 des_const_htmlNodePtr(n_node, (const htmlNodePtr)node, 0); 2203 des_int(n_legacy, legacy, 1); 2204 xmlResetLastError(); 2205 if (mem_base != xmlMemBlocks()) { 2206 printf("Leak of %d blocks found in htmlNodeStatus", 2207 xmlMemBlocks() - mem_base); 2208 test_ret++; 2209 printf(" %d", n_node); 2210 printf(" %d", n_legacy); 2211 printf("\n"); 2212 } 2213 } 2214 } 2215 function_tests++; 2216 #endif 2217 2218 return(test_ret); 2219 } 2220 2221 2222 static int 2223 test_htmlParseCharRef(void) { 2224 int test_ret = 0; 2225 2226 #if defined(LIBXML_HTML_ENABLED) 2227 int mem_base; 2228 int ret_val; 2229 htmlParserCtxtPtr ctxt; /* an HTML parser context */ 2230 int n_ctxt; 2231 2232 for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) { 2233 mem_base = xmlMemBlocks(); 2234 ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0); 2235 2236 ret_val = htmlParseCharRef(ctxt); 2237 desret_int(ret_val); 2238 call_tests++; 2239 des_htmlParserCtxtPtr(n_ctxt, ctxt, 0); 2240 xmlResetLastError(); 2241 if (mem_base != xmlMemBlocks()) { 2242 printf("Leak of %d blocks found in htmlParseCharRef", 2243 xmlMemBlocks() - mem_base); 2244 test_ret++; 2245 printf(" %d", n_ctxt); 2246 printf("\n"); 2247 } 2248 } 2249 function_tests++; 2250 #endif 2251 2252 return(test_ret); 2253 } 2254 2255 2256 static int 2257 test_htmlParseChunk(void) { 2258 int test_ret = 0; 2259 2260 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_PUSH_ENABLED) 2261 int mem_base; 2262 int ret_val; 2263 htmlParserCtxtPtr ctxt; /* an HTML parser context */ 2264 int n_ctxt; 2265 char * chunk; /* an char array */ 2266 int n_chunk; 2267 int size; /* the size in byte of the chunk */ 2268 int n_size; 2269 int terminate; /* last chunk indicator */ 2270 int n_terminate; 2271 2272 for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) { 2273 for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) { 2274 for (n_size = 0;n_size < gen_nb_int;n_size++) { 2275 for (n_terminate = 0;n_terminate < gen_nb_int;n_terminate++) { 2276 mem_base = xmlMemBlocks(); 2277 ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0); 2278 chunk = gen_const_char_ptr(n_chunk, 1); 2279 size = gen_int(n_size, 2); 2280 terminate = gen_int(n_terminate, 3); 2281 2282 ret_val = htmlParseChunk(ctxt, (const char *)chunk, size, terminate); 2283 if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;} 2284 desret_int(ret_val); 2285 call_tests++; 2286 des_htmlParserCtxtPtr(n_ctxt, ctxt, 0); 2287 des_const_char_ptr(n_chunk, (const char *)chunk, 1); 2288 des_int(n_size, size, 2); 2289 des_int(n_terminate, terminate, 3); 2290 xmlResetLastError(); 2291 if (mem_base != xmlMemBlocks()) { 2292 printf("Leak of %d blocks found in htmlParseChunk", 2293 xmlMemBlocks() - mem_base); 2294 test_ret++; 2295 printf(" %d", n_ctxt); 2296 printf(" %d", n_chunk); 2297 printf(" %d", n_size); 2298 printf(" %d", n_terminate); 2299 printf("\n"); 2300 } 2301 } 2302 } 2303 } 2304 } 2305 function_tests++; 2306 #endif 2307 2308 return(test_ret); 2309 } 2310 2311 2312 static int 2313 test_htmlParseDoc(void) { 2314 int test_ret = 0; 2315 2316 #if defined(LIBXML_HTML_ENABLED) 2317 int mem_base; 2318 htmlDocPtr ret_val; 2319 xmlChar * cur; /* a pointer to an array of xmlChar */ 2320 int n_cur; 2321 char * encoding; /* a free form C string describing the HTML document encoding, or NULL */ 2322 int n_encoding; 2323 2324 for (n_cur = 0;n_cur < gen_nb_xmlChar_ptr;n_cur++) { 2325 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 2326 mem_base = xmlMemBlocks(); 2327 cur = gen_xmlChar_ptr(n_cur, 0); 2328 encoding = gen_const_char_ptr(n_encoding, 1); 2329 2330 ret_val = htmlParseDoc(cur, (const char *)encoding); 2331 desret_htmlDocPtr(ret_val); 2332 call_tests++; 2333 des_xmlChar_ptr(n_cur, cur, 0); 2334 des_const_char_ptr(n_encoding, (const char *)encoding, 1); 2335 xmlResetLastError(); 2336 if (mem_base != xmlMemBlocks()) { 2337 printf("Leak of %d blocks found in htmlParseDoc", 2338 xmlMemBlocks() - mem_base); 2339 test_ret++; 2340 printf(" %d", n_cur); 2341 printf(" %d", n_encoding); 2342 printf("\n"); 2343 } 2344 } 2345 } 2346 function_tests++; 2347 #endif 2348 2349 return(test_ret); 2350 } 2351 2352 2353 static int 2354 test_htmlParseDocument(void) { 2355 int test_ret = 0; 2356 2357 #if defined(LIBXML_HTML_ENABLED) 2358 int mem_base; 2359 int ret_val; 2360 htmlParserCtxtPtr ctxt; /* an HTML parser context */ 2361 int n_ctxt; 2362 2363 for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) { 2364 mem_base = xmlMemBlocks(); 2365 ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0); 2366 2367 ret_val = htmlParseDocument(ctxt); 2368 if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;} 2369 desret_int(ret_val); 2370 call_tests++; 2371 des_htmlParserCtxtPtr(n_ctxt, ctxt, 0); 2372 xmlResetLastError(); 2373 if (mem_base != xmlMemBlocks()) { 2374 printf("Leak of %d blocks found in htmlParseDocument", 2375 xmlMemBlocks() - mem_base); 2376 test_ret++; 2377 printf(" %d", n_ctxt); 2378 printf("\n"); 2379 } 2380 } 2381 function_tests++; 2382 #endif 2383 2384 return(test_ret); 2385 } 2386 2387 2388 static int 2389 test_htmlParseElement(void) { 2390 int test_ret = 0; 2391 2392 #if defined(LIBXML_HTML_ENABLED) 2393 int mem_base; 2394 htmlParserCtxtPtr ctxt; /* an HTML parser context */ 2395 int n_ctxt; 2396 2397 for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) { 2398 mem_base = xmlMemBlocks(); 2399 ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0); 2400 2401 htmlParseElement(ctxt); 2402 call_tests++; 2403 des_htmlParserCtxtPtr(n_ctxt, ctxt, 0); 2404 xmlResetLastError(); 2405 if (mem_base != xmlMemBlocks()) { 2406 printf("Leak of %d blocks found in htmlParseElement", 2407 xmlMemBlocks() - mem_base); 2408 test_ret++; 2409 printf(" %d", n_ctxt); 2410 printf("\n"); 2411 } 2412 } 2413 function_tests++; 2414 #endif 2415 2416 return(test_ret); 2417 } 2418 2419 2420 static int 2421 test_htmlParseEntityRef(void) { 2422 int test_ret = 0; 2423 2424 #if defined(LIBXML_HTML_ENABLED) 2425 int mem_base; 2426 const htmlEntityDesc * ret_val; 2427 htmlParserCtxtPtr ctxt; /* an HTML parser context */ 2428 int n_ctxt; 2429 xmlChar ** str; /* location to store the entity name */ 2430 int n_str; 2431 2432 for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) { 2433 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr_ptr;n_str++) { 2434 mem_base = xmlMemBlocks(); 2435 ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0); 2436 str = gen_const_xmlChar_ptr_ptr(n_str, 1); 2437 2438 ret_val = htmlParseEntityRef(ctxt, (const xmlChar **)str); 2439 desret_const_htmlEntityDesc_ptr(ret_val); 2440 call_tests++; 2441 des_htmlParserCtxtPtr(n_ctxt, ctxt, 0); 2442 des_const_xmlChar_ptr_ptr(n_str, (const xmlChar **)str, 1); 2443 xmlResetLastError(); 2444 if (mem_base != xmlMemBlocks()) { 2445 printf("Leak of %d blocks found in htmlParseEntityRef", 2446 xmlMemBlocks() - mem_base); 2447 test_ret++; 2448 printf(" %d", n_ctxt); 2449 printf(" %d", n_str); 2450 printf("\n"); 2451 } 2452 } 2453 } 2454 function_tests++; 2455 #endif 2456 2457 return(test_ret); 2458 } 2459 2460 2461 static int 2462 test_htmlParseFile(void) { 2463 int test_ret = 0; 2464 2465 #if defined(LIBXML_HTML_ENABLED) 2466 htmlDocPtr ret_val; 2467 const char * filename; /* the filename */ 2468 int n_filename; 2469 char * encoding; /* a free form C string describing the HTML document encoding, or NULL */ 2470 int n_encoding; 2471 2472 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 2473 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 2474 filename = gen_filepath(n_filename, 0); 2475 encoding = gen_const_char_ptr(n_encoding, 1); 2476 2477 ret_val = htmlParseFile(filename, (const char *)encoding); 2478 desret_htmlDocPtr(ret_val); 2479 call_tests++; 2480 des_filepath(n_filename, filename, 0); 2481 des_const_char_ptr(n_encoding, (const char *)encoding, 1); 2482 xmlResetLastError(); 2483 } 2484 } 2485 function_tests++; 2486 #endif 2487 2488 return(test_ret); 2489 } 2490 2491 2492 static int 2493 test_htmlReadDoc(void) { 2494 int test_ret = 0; 2495 2496 #if defined(LIBXML_HTML_ENABLED) 2497 int mem_base; 2498 htmlDocPtr ret_val; 2499 xmlChar * cur; /* a pointer to a zero terminated string */ 2500 int n_cur; 2501 const char * URL; /* the base URL to use for the document */ 2502 int n_URL; 2503 char * encoding; /* the document encoding, or NULL */ 2504 int n_encoding; 2505 int options; /* a combination of htmlParserOption(s) */ 2506 int n_options; 2507 2508 for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) { 2509 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 2510 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 2511 for (n_options = 0;n_options < gen_nb_int;n_options++) { 2512 mem_base = xmlMemBlocks(); 2513 cur = gen_const_xmlChar_ptr(n_cur, 0); 2514 URL = gen_filepath(n_URL, 1); 2515 encoding = gen_const_char_ptr(n_encoding, 2); 2516 options = gen_int(n_options, 3); 2517 2518 ret_val = htmlReadDoc((const xmlChar *)cur, URL, (const char *)encoding, options); 2519 desret_htmlDocPtr(ret_val); 2520 call_tests++; 2521 des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0); 2522 des_filepath(n_URL, URL, 1); 2523 des_const_char_ptr(n_encoding, (const char *)encoding, 2); 2524 des_int(n_options, options, 3); 2525 xmlResetLastError(); 2526 if (mem_base != xmlMemBlocks()) { 2527 printf("Leak of %d blocks found in htmlReadDoc", 2528 xmlMemBlocks() - mem_base); 2529 test_ret++; 2530 printf(" %d", n_cur); 2531 printf(" %d", n_URL); 2532 printf(" %d", n_encoding); 2533 printf(" %d", n_options); 2534 printf("\n"); 2535 } 2536 } 2537 } 2538 } 2539 } 2540 function_tests++; 2541 #endif 2542 2543 return(test_ret); 2544 } 2545 2546 2547 static int 2548 test_htmlReadFile(void) { 2549 int test_ret = 0; 2550 2551 #if defined(LIBXML_HTML_ENABLED) 2552 int mem_base; 2553 htmlDocPtr ret_val; 2554 const char * filename; /* a file or URL */ 2555 int n_filename; 2556 char * encoding; /* the document encoding, or NULL */ 2557 int n_encoding; 2558 int options; /* a combination of htmlParserOption(s) */ 2559 int n_options; 2560 2561 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 2562 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 2563 for (n_options = 0;n_options < gen_nb_int;n_options++) { 2564 mem_base = xmlMemBlocks(); 2565 filename = gen_filepath(n_filename, 0); 2566 encoding = gen_const_char_ptr(n_encoding, 1); 2567 options = gen_int(n_options, 2); 2568 2569 ret_val = htmlReadFile(filename, (const char *)encoding, options); 2570 desret_htmlDocPtr(ret_val); 2571 call_tests++; 2572 des_filepath(n_filename, filename, 0); 2573 des_const_char_ptr(n_encoding, (const char *)encoding, 1); 2574 des_int(n_options, options, 2); 2575 xmlResetLastError(); 2576 if (mem_base != xmlMemBlocks()) { 2577 printf("Leak of %d blocks found in htmlReadFile", 2578 xmlMemBlocks() - mem_base); 2579 test_ret++; 2580 printf(" %d", n_filename); 2581 printf(" %d", n_encoding); 2582 printf(" %d", n_options); 2583 printf("\n"); 2584 } 2585 } 2586 } 2587 } 2588 function_tests++; 2589 #endif 2590 2591 return(test_ret); 2592 } 2593 2594 2595 static int 2596 test_htmlReadMemory(void) { 2597 int test_ret = 0; 2598 2599 #if defined(LIBXML_HTML_ENABLED) 2600 int mem_base; 2601 htmlDocPtr ret_val; 2602 char * buffer; /* a pointer to a char array */ 2603 int n_buffer; 2604 int size; /* the size of the array */ 2605 int n_size; 2606 const char * URL; /* the base URL to use for the document */ 2607 int n_URL; 2608 char * encoding; /* the document encoding, or NULL */ 2609 int n_encoding; 2610 int options; /* a combination of htmlParserOption(s) */ 2611 int n_options; 2612 2613 for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) { 2614 for (n_size = 0;n_size < gen_nb_int;n_size++) { 2615 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 2616 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 2617 for (n_options = 0;n_options < gen_nb_int;n_options++) { 2618 mem_base = xmlMemBlocks(); 2619 buffer = gen_const_char_ptr(n_buffer, 0); 2620 size = gen_int(n_size, 1); 2621 URL = gen_filepath(n_URL, 2); 2622 encoding = gen_const_char_ptr(n_encoding, 3); 2623 options = gen_int(n_options, 4); 2624 2625 ret_val = htmlReadMemory((const char *)buffer, size, URL, (const char *)encoding, options); 2626 desret_htmlDocPtr(ret_val); 2627 call_tests++; 2628 des_const_char_ptr(n_buffer, (const char *)buffer, 0); 2629 des_int(n_size, size, 1); 2630 des_filepath(n_URL, URL, 2); 2631 des_const_char_ptr(n_encoding, (const char *)encoding, 3); 2632 des_int(n_options, options, 4); 2633 xmlResetLastError(); 2634 if (mem_base != xmlMemBlocks()) { 2635 printf("Leak of %d blocks found in htmlReadMemory", 2636 xmlMemBlocks() - mem_base); 2637 test_ret++; 2638 printf(" %d", n_buffer); 2639 printf(" %d", n_size); 2640 printf(" %d", n_URL); 2641 printf(" %d", n_encoding); 2642 printf(" %d", n_options); 2643 printf("\n"); 2644 } 2645 } 2646 } 2647 } 2648 } 2649 } 2650 function_tests++; 2651 #endif 2652 2653 return(test_ret); 2654 } 2655 2656 2657 static int 2658 test_htmlSAXParseDoc(void) { 2659 int test_ret = 0; 2660 2661 #if defined(LIBXML_HTML_ENABLED) 2662 int mem_base; 2663 htmlDocPtr ret_val; 2664 xmlChar * cur; /* a pointer to an array of xmlChar */ 2665 int n_cur; 2666 char * encoding; /* a free form C string describing the HTML document encoding, or NULL */ 2667 int n_encoding; 2668 htmlSAXHandlerPtr sax; /* the SAX handler block */ 2669 int n_sax; 2670 void * userData; /* if using SAX, this pointer will be provided on callbacks. */ 2671 int n_userData; 2672 2673 for (n_cur = 0;n_cur < gen_nb_xmlChar_ptr;n_cur++) { 2674 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 2675 for (n_sax = 0;n_sax < gen_nb_htmlSAXHandlerPtr;n_sax++) { 2676 for (n_userData = 0;n_userData < gen_nb_userdata;n_userData++) { 2677 mem_base = xmlMemBlocks(); 2678 cur = gen_xmlChar_ptr(n_cur, 0); 2679 encoding = gen_const_char_ptr(n_encoding, 1); 2680 sax = gen_htmlSAXHandlerPtr(n_sax, 2); 2681 userData = gen_userdata(n_userData, 3); 2682 2683 ret_val = htmlSAXParseDoc(cur, (const char *)encoding, sax, userData); 2684 desret_htmlDocPtr(ret_val); 2685 call_tests++; 2686 des_xmlChar_ptr(n_cur, cur, 0); 2687 des_const_char_ptr(n_encoding, (const char *)encoding, 1); 2688 des_htmlSAXHandlerPtr(n_sax, sax, 2); 2689 des_userdata(n_userData, userData, 3); 2690 xmlResetLastError(); 2691 if (mem_base != xmlMemBlocks()) { 2692 printf("Leak of %d blocks found in htmlSAXParseDoc", 2693 xmlMemBlocks() - mem_base); 2694 test_ret++; 2695 printf(" %d", n_cur); 2696 printf(" %d", n_encoding); 2697 printf(" %d", n_sax); 2698 printf(" %d", n_userData); 2699 printf("\n"); 2700 } 2701 } 2702 } 2703 } 2704 } 2705 function_tests++; 2706 #endif 2707 2708 return(test_ret); 2709 } 2710 2711 2712 static int 2713 test_htmlSAXParseFile(void) { 2714 int test_ret = 0; 2715 2716 #if defined(LIBXML_HTML_ENABLED) 2717 int mem_base; 2718 htmlDocPtr ret_val; 2719 const char * filename; /* the filename */ 2720 int n_filename; 2721 char * encoding; /* a free form C string describing the HTML document encoding, or NULL */ 2722 int n_encoding; 2723 htmlSAXHandlerPtr sax; /* the SAX handler block */ 2724 int n_sax; 2725 void * userData; /* if using SAX, this pointer will be provided on callbacks. */ 2726 int n_userData; 2727 2728 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 2729 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 2730 for (n_sax = 0;n_sax < gen_nb_htmlSAXHandlerPtr;n_sax++) { 2731 for (n_userData = 0;n_userData < gen_nb_userdata;n_userData++) { 2732 mem_base = xmlMemBlocks(); 2733 filename = gen_filepath(n_filename, 0); 2734 encoding = gen_const_char_ptr(n_encoding, 1); 2735 sax = gen_htmlSAXHandlerPtr(n_sax, 2); 2736 userData = gen_userdata(n_userData, 3); 2737 2738 ret_val = htmlSAXParseFile(filename, (const char *)encoding, sax, userData); 2739 desret_htmlDocPtr(ret_val); 2740 call_tests++; 2741 des_filepath(n_filename, filename, 0); 2742 des_const_char_ptr(n_encoding, (const char *)encoding, 1); 2743 des_htmlSAXHandlerPtr(n_sax, sax, 2); 2744 des_userdata(n_userData, userData, 3); 2745 xmlResetLastError(); 2746 if (mem_base != xmlMemBlocks()) { 2747 printf("Leak of %d blocks found in htmlSAXParseFile", 2748 xmlMemBlocks() - mem_base); 2749 test_ret++; 2750 printf(" %d", n_filename); 2751 printf(" %d", n_encoding); 2752 printf(" %d", n_sax); 2753 printf(" %d", n_userData); 2754 printf("\n"); 2755 } 2756 } 2757 } 2758 } 2759 } 2760 function_tests++; 2761 #endif 2762 2763 return(test_ret); 2764 } 2765 2766 2767 static int 2768 test_htmlTagLookup(void) { 2769 int test_ret = 0; 2770 2771 2772 /* missing type support */ 2773 return(test_ret); 2774 } 2775 2776 static int 2777 test_HTMLparser(void) { 2778 int test_ret = 0; 2779 2780 if (quiet == 0) printf("Testing HTMLparser : 32 of 38 functions ...\n"); 2781 test_ret += test_UTF8ToHtml(); 2782 test_ret += test_htmlAttrAllowed(); 2783 test_ret += test_htmlAutoCloseTag(); 2784 test_ret += test_htmlCreateMemoryParserCtxt(); 2785 test_ret += test_htmlCreatePushParserCtxt(); 2786 test_ret += test_htmlCtxtReadDoc(); 2787 test_ret += test_htmlCtxtReadFile(); 2788 test_ret += test_htmlCtxtReadMemory(); 2789 test_ret += test_htmlCtxtReset(); 2790 test_ret += test_htmlCtxtUseOptions(); 2791 test_ret += test_htmlElementAllowedHere(); 2792 test_ret += test_htmlElementStatusHere(); 2793 test_ret += test_htmlEncodeEntities(); 2794 test_ret += test_htmlEntityLookup(); 2795 test_ret += test_htmlEntityValueLookup(); 2796 test_ret += test_htmlHandleOmittedElem(); 2797 test_ret += test_htmlIsAutoClosed(); 2798 test_ret += test_htmlIsScriptAttribute(); 2799 test_ret += test_htmlNewParserCtxt(); 2800 test_ret += test_htmlNodeStatus(); 2801 test_ret += test_htmlParseCharRef(); 2802 test_ret += test_htmlParseChunk(); 2803 test_ret += test_htmlParseDoc(); 2804 test_ret += test_htmlParseDocument(); 2805 test_ret += test_htmlParseElement(); 2806 test_ret += test_htmlParseEntityRef(); 2807 test_ret += test_htmlParseFile(); 2808 test_ret += test_htmlReadDoc(); 2809 test_ret += test_htmlReadFile(); 2810 test_ret += test_htmlReadMemory(); 2811 test_ret += test_htmlSAXParseDoc(); 2812 test_ret += test_htmlSAXParseFile(); 2813 test_ret += test_htmlTagLookup(); 2814 2815 if (test_ret != 0) 2816 printf("Module HTMLparser: %d errors\n", test_ret); 2817 return(test_ret); 2818 } 2819 2820 static int 2821 test_htmlDocContentDumpFormatOutput(void) { 2822 int test_ret = 0; 2823 2824 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 2825 int mem_base; 2826 xmlOutputBufferPtr buf; /* the HTML buffer output */ 2827 int n_buf; 2828 xmlDocPtr cur; /* the document */ 2829 int n_cur; 2830 char * encoding; /* the encoding string */ 2831 int n_encoding; 2832 int format; /* should formatting spaces been added */ 2833 int n_format; 2834 2835 for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) { 2836 for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) { 2837 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 2838 for (n_format = 0;n_format < gen_nb_int;n_format++) { 2839 mem_base = xmlMemBlocks(); 2840 buf = gen_xmlOutputBufferPtr(n_buf, 0); 2841 cur = gen_xmlDocPtr(n_cur, 1); 2842 encoding = gen_const_char_ptr(n_encoding, 2); 2843 format = gen_int(n_format, 3); 2844 2845 htmlDocContentDumpFormatOutput(buf, cur, (const char *)encoding, format); 2846 call_tests++; 2847 des_xmlOutputBufferPtr(n_buf, buf, 0); 2848 des_xmlDocPtr(n_cur, cur, 1); 2849 des_const_char_ptr(n_encoding, (const char *)encoding, 2); 2850 des_int(n_format, format, 3); 2851 xmlResetLastError(); 2852 if (mem_base != xmlMemBlocks()) { 2853 printf("Leak of %d blocks found in htmlDocContentDumpFormatOutput", 2854 xmlMemBlocks() - mem_base); 2855 test_ret++; 2856 printf(" %d", n_buf); 2857 printf(" %d", n_cur); 2858 printf(" %d", n_encoding); 2859 printf(" %d", n_format); 2860 printf("\n"); 2861 } 2862 } 2863 } 2864 } 2865 } 2866 function_tests++; 2867 #endif 2868 2869 return(test_ret); 2870 } 2871 2872 2873 static int 2874 test_htmlDocContentDumpOutput(void) { 2875 int test_ret = 0; 2876 2877 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 2878 int mem_base; 2879 xmlOutputBufferPtr buf; /* the HTML buffer output */ 2880 int n_buf; 2881 xmlDocPtr cur; /* the document */ 2882 int n_cur; 2883 char * encoding; /* the encoding string */ 2884 int n_encoding; 2885 2886 for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) { 2887 for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) { 2888 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 2889 mem_base = xmlMemBlocks(); 2890 buf = gen_xmlOutputBufferPtr(n_buf, 0); 2891 cur = gen_xmlDocPtr(n_cur, 1); 2892 encoding = gen_const_char_ptr(n_encoding, 2); 2893 2894 htmlDocContentDumpOutput(buf, cur, (const char *)encoding); 2895 call_tests++; 2896 des_xmlOutputBufferPtr(n_buf, buf, 0); 2897 des_xmlDocPtr(n_cur, cur, 1); 2898 des_const_char_ptr(n_encoding, (const char *)encoding, 2); 2899 xmlResetLastError(); 2900 if (mem_base != xmlMemBlocks()) { 2901 printf("Leak of %d blocks found in htmlDocContentDumpOutput", 2902 xmlMemBlocks() - mem_base); 2903 test_ret++; 2904 printf(" %d", n_buf); 2905 printf(" %d", n_cur); 2906 printf(" %d", n_encoding); 2907 printf("\n"); 2908 } 2909 } 2910 } 2911 } 2912 function_tests++; 2913 #endif 2914 2915 return(test_ret); 2916 } 2917 2918 2919 static int 2920 test_htmlDocDump(void) { 2921 int test_ret = 0; 2922 2923 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 2924 int mem_base; 2925 int ret_val; 2926 FILE * f; /* the FILE* */ 2927 int n_f; 2928 xmlDocPtr cur; /* the document */ 2929 int n_cur; 2930 2931 for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) { 2932 for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) { 2933 mem_base = xmlMemBlocks(); 2934 f = gen_FILE_ptr(n_f, 0); 2935 cur = gen_xmlDocPtr(n_cur, 1); 2936 2937 ret_val = htmlDocDump(f, cur); 2938 desret_int(ret_val); 2939 call_tests++; 2940 des_FILE_ptr(n_f, f, 0); 2941 des_xmlDocPtr(n_cur, cur, 1); 2942 xmlResetLastError(); 2943 if (mem_base != xmlMemBlocks()) { 2944 printf("Leak of %d blocks found in htmlDocDump", 2945 xmlMemBlocks() - mem_base); 2946 test_ret++; 2947 printf(" %d", n_f); 2948 printf(" %d", n_cur); 2949 printf("\n"); 2950 } 2951 } 2952 } 2953 function_tests++; 2954 #endif 2955 2956 return(test_ret); 2957 } 2958 2959 2960 #define gen_nb_xmlChar_ptr_ptr 1 2961 static xmlChar ** gen_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 2962 return(NULL); 2963 } 2964 static void des_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, xmlChar ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 2965 } 2966 2967 static int 2968 test_htmlDocDumpMemory(void) { 2969 int test_ret = 0; 2970 2971 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 2972 int mem_base; 2973 xmlDocPtr cur; /* the document */ 2974 int n_cur; 2975 xmlChar ** mem; /* OUT: the memory pointer */ 2976 int n_mem; 2977 int * size; /* OUT: the memory length */ 2978 int n_size; 2979 2980 for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) { 2981 for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) { 2982 for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) { 2983 mem_base = xmlMemBlocks(); 2984 cur = gen_xmlDocPtr(n_cur, 0); 2985 mem = gen_xmlChar_ptr_ptr(n_mem, 1); 2986 size = gen_int_ptr(n_size, 2); 2987 2988 htmlDocDumpMemory(cur, mem, size); 2989 call_tests++; 2990 des_xmlDocPtr(n_cur, cur, 0); 2991 des_xmlChar_ptr_ptr(n_mem, mem, 1); 2992 des_int_ptr(n_size, size, 2); 2993 xmlResetLastError(); 2994 if (mem_base != xmlMemBlocks()) { 2995 printf("Leak of %d blocks found in htmlDocDumpMemory", 2996 xmlMemBlocks() - mem_base); 2997 test_ret++; 2998 printf(" %d", n_cur); 2999 printf(" %d", n_mem); 3000 printf(" %d", n_size); 3001 printf("\n"); 3002 } 3003 } 3004 } 3005 } 3006 function_tests++; 3007 #endif 3008 3009 return(test_ret); 3010 } 3011 3012 3013 static int 3014 test_htmlDocDumpMemoryFormat(void) { 3015 int test_ret = 0; 3016 3017 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 3018 int mem_base; 3019 xmlDocPtr cur; /* the document */ 3020 int n_cur; 3021 xmlChar ** mem; /* OUT: the memory pointer */ 3022 int n_mem; 3023 int * size; /* OUT: the memory length */ 3024 int n_size; 3025 int format; /* should formatting spaces been added */ 3026 int n_format; 3027 3028 for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) { 3029 for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) { 3030 for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) { 3031 for (n_format = 0;n_format < gen_nb_int;n_format++) { 3032 mem_base = xmlMemBlocks(); 3033 cur = gen_xmlDocPtr(n_cur, 0); 3034 mem = gen_xmlChar_ptr_ptr(n_mem, 1); 3035 size = gen_int_ptr(n_size, 2); 3036 format = gen_int(n_format, 3); 3037 3038 htmlDocDumpMemoryFormat(cur, mem, size, format); 3039 call_tests++; 3040 des_xmlDocPtr(n_cur, cur, 0); 3041 des_xmlChar_ptr_ptr(n_mem, mem, 1); 3042 des_int_ptr(n_size, size, 2); 3043 des_int(n_format, format, 3); 3044 xmlResetLastError(); 3045 if (mem_base != xmlMemBlocks()) { 3046 printf("Leak of %d blocks found in htmlDocDumpMemoryFormat", 3047 xmlMemBlocks() - mem_base); 3048 test_ret++; 3049 printf(" %d", n_cur); 3050 printf(" %d", n_mem); 3051 printf(" %d", n_size); 3052 printf(" %d", n_format); 3053 printf("\n"); 3054 } 3055 } 3056 } 3057 } 3058 } 3059 function_tests++; 3060 #endif 3061 3062 return(test_ret); 3063 } 3064 3065 3066 static int 3067 test_htmlGetMetaEncoding(void) { 3068 int test_ret = 0; 3069 3070 #if defined(LIBXML_HTML_ENABLED) 3071 int mem_base; 3072 const xmlChar * ret_val; 3073 htmlDocPtr doc; /* the document */ 3074 int n_doc; 3075 3076 for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) { 3077 mem_base = xmlMemBlocks(); 3078 doc = gen_htmlDocPtr(n_doc, 0); 3079 3080 ret_val = htmlGetMetaEncoding(doc); 3081 desret_const_xmlChar_ptr(ret_val); 3082 call_tests++; 3083 des_htmlDocPtr(n_doc, doc, 0); 3084 xmlResetLastError(); 3085 if (mem_base != xmlMemBlocks()) { 3086 printf("Leak of %d blocks found in htmlGetMetaEncoding", 3087 xmlMemBlocks() - mem_base); 3088 test_ret++; 3089 printf(" %d", n_doc); 3090 printf("\n"); 3091 } 3092 } 3093 function_tests++; 3094 #endif 3095 3096 return(test_ret); 3097 } 3098 3099 3100 static int 3101 test_htmlIsBooleanAttr(void) { 3102 int test_ret = 0; 3103 3104 #if defined(LIBXML_HTML_ENABLED) 3105 int mem_base; 3106 int ret_val; 3107 xmlChar * name; /* the name of the attribute to check */ 3108 int n_name; 3109 3110 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 3111 mem_base = xmlMemBlocks(); 3112 name = gen_const_xmlChar_ptr(n_name, 0); 3113 3114 ret_val = htmlIsBooleanAttr((const xmlChar *)name); 3115 desret_int(ret_val); 3116 call_tests++; 3117 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0); 3118 xmlResetLastError(); 3119 if (mem_base != xmlMemBlocks()) { 3120 printf("Leak of %d blocks found in htmlIsBooleanAttr", 3121 xmlMemBlocks() - mem_base); 3122 test_ret++; 3123 printf(" %d", n_name); 3124 printf("\n"); 3125 } 3126 } 3127 function_tests++; 3128 #endif 3129 3130 return(test_ret); 3131 } 3132 3133 3134 static int 3135 test_htmlNewDoc(void) { 3136 int test_ret = 0; 3137 3138 #if defined(LIBXML_HTML_ENABLED) 3139 int mem_base; 3140 htmlDocPtr ret_val; 3141 xmlChar * URI; /* URI for the dtd, or NULL */ 3142 int n_URI; 3143 xmlChar * ExternalID; /* the external ID of the DTD, or NULL */ 3144 int n_ExternalID; 3145 3146 for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) { 3147 for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) { 3148 mem_base = xmlMemBlocks(); 3149 URI = gen_const_xmlChar_ptr(n_URI, 0); 3150 ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 1); 3151 3152 ret_val = htmlNewDoc((const xmlChar *)URI, (const xmlChar *)ExternalID); 3153 desret_htmlDocPtr(ret_val); 3154 call_tests++; 3155 des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0); 3156 des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 1); 3157 xmlResetLastError(); 3158 if (mem_base != xmlMemBlocks()) { 3159 printf("Leak of %d blocks found in htmlNewDoc", 3160 xmlMemBlocks() - mem_base); 3161 test_ret++; 3162 printf(" %d", n_URI); 3163 printf(" %d", n_ExternalID); 3164 printf("\n"); 3165 } 3166 } 3167 } 3168 function_tests++; 3169 #endif 3170 3171 return(test_ret); 3172 } 3173 3174 3175 static int 3176 test_htmlNewDocNoDtD(void) { 3177 int test_ret = 0; 3178 3179 #if defined(LIBXML_HTML_ENABLED) 3180 int mem_base; 3181 htmlDocPtr ret_val; 3182 xmlChar * URI; /* URI for the dtd, or NULL */ 3183 int n_URI; 3184 xmlChar * ExternalID; /* the external ID of the DTD, or NULL */ 3185 int n_ExternalID; 3186 3187 for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) { 3188 for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) { 3189 mem_base = xmlMemBlocks(); 3190 URI = gen_const_xmlChar_ptr(n_URI, 0); 3191 ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 1); 3192 3193 ret_val = htmlNewDocNoDtD((const xmlChar *)URI, (const xmlChar *)ExternalID); 3194 desret_htmlDocPtr(ret_val); 3195 call_tests++; 3196 des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0); 3197 des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 1); 3198 xmlResetLastError(); 3199 if (mem_base != xmlMemBlocks()) { 3200 printf("Leak of %d blocks found in htmlNewDocNoDtD", 3201 xmlMemBlocks() - mem_base); 3202 test_ret++; 3203 printf(" %d", n_URI); 3204 printf(" %d", n_ExternalID); 3205 printf("\n"); 3206 } 3207 } 3208 } 3209 function_tests++; 3210 #endif 3211 3212 return(test_ret); 3213 } 3214 3215 3216 static int 3217 test_htmlNodeDump(void) { 3218 int test_ret = 0; 3219 3220 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 3221 int mem_base; 3222 int ret_val; 3223 xmlBufferPtr buf; /* the HTML buffer output */ 3224 int n_buf; 3225 xmlDocPtr doc; /* the document */ 3226 int n_doc; 3227 xmlNodePtr cur; /* the current node */ 3228 int n_cur; 3229 3230 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 3231 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 3232 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 3233 mem_base = xmlMemBlocks(); 3234 buf = gen_xmlBufferPtr(n_buf, 0); 3235 doc = gen_xmlDocPtr(n_doc, 1); 3236 cur = gen_xmlNodePtr(n_cur, 2); 3237 3238 ret_val = htmlNodeDump(buf, doc, cur); 3239 desret_int(ret_val); 3240 call_tests++; 3241 des_xmlBufferPtr(n_buf, buf, 0); 3242 des_xmlDocPtr(n_doc, doc, 1); 3243 des_xmlNodePtr(n_cur, cur, 2); 3244 xmlResetLastError(); 3245 if (mem_base != xmlMemBlocks()) { 3246 printf("Leak of %d blocks found in htmlNodeDump", 3247 xmlMemBlocks() - mem_base); 3248 test_ret++; 3249 printf(" %d", n_buf); 3250 printf(" %d", n_doc); 3251 printf(" %d", n_cur); 3252 printf("\n"); 3253 } 3254 } 3255 } 3256 } 3257 function_tests++; 3258 #endif 3259 3260 return(test_ret); 3261 } 3262 3263 3264 static int 3265 test_htmlNodeDumpFile(void) { 3266 int test_ret = 0; 3267 3268 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 3269 int mem_base; 3270 FILE * out; /* the FILE pointer */ 3271 int n_out; 3272 xmlDocPtr doc; /* the document */ 3273 int n_doc; 3274 xmlNodePtr cur; /* the current node */ 3275 int n_cur; 3276 3277 for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) { 3278 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 3279 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 3280 mem_base = xmlMemBlocks(); 3281 out = gen_FILE_ptr(n_out, 0); 3282 doc = gen_xmlDocPtr(n_doc, 1); 3283 cur = gen_xmlNodePtr(n_cur, 2); 3284 3285 htmlNodeDumpFile(out, doc, cur); 3286 call_tests++; 3287 des_FILE_ptr(n_out, out, 0); 3288 des_xmlDocPtr(n_doc, doc, 1); 3289 des_xmlNodePtr(n_cur, cur, 2); 3290 xmlResetLastError(); 3291 if (mem_base != xmlMemBlocks()) { 3292 printf("Leak of %d blocks found in htmlNodeDumpFile", 3293 xmlMemBlocks() - mem_base); 3294 test_ret++; 3295 printf(" %d", n_out); 3296 printf(" %d", n_doc); 3297 printf(" %d", n_cur); 3298 printf("\n"); 3299 } 3300 } 3301 } 3302 } 3303 function_tests++; 3304 #endif 3305 3306 return(test_ret); 3307 } 3308 3309 3310 static int 3311 test_htmlNodeDumpFileFormat(void) { 3312 int test_ret = 0; 3313 3314 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 3315 int mem_base; 3316 int ret_val; 3317 FILE * out; /* the FILE pointer */ 3318 int n_out; 3319 xmlDocPtr doc; /* the document */ 3320 int n_doc; 3321 xmlNodePtr cur; /* the current node */ 3322 int n_cur; 3323 char * encoding; /* the document encoding */ 3324 int n_encoding; 3325 int format; /* should formatting spaces been added */ 3326 int n_format; 3327 3328 for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) { 3329 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 3330 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 3331 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 3332 for (n_format = 0;n_format < gen_nb_int;n_format++) { 3333 mem_base = xmlMemBlocks(); 3334 out = gen_FILE_ptr(n_out, 0); 3335 doc = gen_xmlDocPtr(n_doc, 1); 3336 cur = gen_xmlNodePtr(n_cur, 2); 3337 encoding = gen_const_char_ptr(n_encoding, 3); 3338 format = gen_int(n_format, 4); 3339 3340 ret_val = htmlNodeDumpFileFormat(out, doc, cur, (const char *)encoding, format); 3341 desret_int(ret_val); 3342 call_tests++; 3343 des_FILE_ptr(n_out, out, 0); 3344 des_xmlDocPtr(n_doc, doc, 1); 3345 des_xmlNodePtr(n_cur, cur, 2); 3346 des_const_char_ptr(n_encoding, (const char *)encoding, 3); 3347 des_int(n_format, format, 4); 3348 xmlResetLastError(); 3349 if (mem_base != xmlMemBlocks()) { 3350 printf("Leak of %d blocks found in htmlNodeDumpFileFormat", 3351 xmlMemBlocks() - mem_base); 3352 test_ret++; 3353 printf(" %d", n_out); 3354 printf(" %d", n_doc); 3355 printf(" %d", n_cur); 3356 printf(" %d", n_encoding); 3357 printf(" %d", n_format); 3358 printf("\n"); 3359 } 3360 } 3361 } 3362 } 3363 } 3364 } 3365 function_tests++; 3366 #endif 3367 3368 return(test_ret); 3369 } 3370 3371 3372 static int 3373 test_htmlNodeDumpFormatOutput(void) { 3374 int test_ret = 0; 3375 3376 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 3377 int mem_base; 3378 xmlOutputBufferPtr buf; /* the HTML buffer output */ 3379 int n_buf; 3380 xmlDocPtr doc; /* the document */ 3381 int n_doc; 3382 xmlNodePtr cur; /* the current node */ 3383 int n_cur; 3384 char * encoding; /* the encoding string */ 3385 int n_encoding; 3386 int format; /* should formatting spaces been added */ 3387 int n_format; 3388 3389 for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) { 3390 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 3391 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 3392 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 3393 for (n_format = 0;n_format < gen_nb_int;n_format++) { 3394 mem_base = xmlMemBlocks(); 3395 buf = gen_xmlOutputBufferPtr(n_buf, 0); 3396 doc = gen_xmlDocPtr(n_doc, 1); 3397 cur = gen_xmlNodePtr(n_cur, 2); 3398 encoding = gen_const_char_ptr(n_encoding, 3); 3399 format = gen_int(n_format, 4); 3400 3401 htmlNodeDumpFormatOutput(buf, doc, cur, (const char *)encoding, format); 3402 call_tests++; 3403 des_xmlOutputBufferPtr(n_buf, buf, 0); 3404 des_xmlDocPtr(n_doc, doc, 1); 3405 des_xmlNodePtr(n_cur, cur, 2); 3406 des_const_char_ptr(n_encoding, (const char *)encoding, 3); 3407 des_int(n_format, format, 4); 3408 xmlResetLastError(); 3409 if (mem_base != xmlMemBlocks()) { 3410 printf("Leak of %d blocks found in htmlNodeDumpFormatOutput", 3411 xmlMemBlocks() - mem_base); 3412 test_ret++; 3413 printf(" %d", n_buf); 3414 printf(" %d", n_doc); 3415 printf(" %d", n_cur); 3416 printf(" %d", n_encoding); 3417 printf(" %d", n_format); 3418 printf("\n"); 3419 } 3420 } 3421 } 3422 } 3423 } 3424 } 3425 function_tests++; 3426 #endif 3427 3428 return(test_ret); 3429 } 3430 3431 3432 static int 3433 test_htmlNodeDumpOutput(void) { 3434 int test_ret = 0; 3435 3436 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 3437 int mem_base; 3438 xmlOutputBufferPtr buf; /* the HTML buffer output */ 3439 int n_buf; 3440 xmlDocPtr doc; /* the document */ 3441 int n_doc; 3442 xmlNodePtr cur; /* the current node */ 3443 int n_cur; 3444 char * encoding; /* the encoding string */ 3445 int n_encoding; 3446 3447 for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) { 3448 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 3449 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 3450 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 3451 mem_base = xmlMemBlocks(); 3452 buf = gen_xmlOutputBufferPtr(n_buf, 0); 3453 doc = gen_xmlDocPtr(n_doc, 1); 3454 cur = gen_xmlNodePtr(n_cur, 2); 3455 encoding = gen_const_char_ptr(n_encoding, 3); 3456 3457 htmlNodeDumpOutput(buf, doc, cur, (const char *)encoding); 3458 call_tests++; 3459 des_xmlOutputBufferPtr(n_buf, buf, 0); 3460 des_xmlDocPtr(n_doc, doc, 1); 3461 des_xmlNodePtr(n_cur, cur, 2); 3462 des_const_char_ptr(n_encoding, (const char *)encoding, 3); 3463 xmlResetLastError(); 3464 if (mem_base != xmlMemBlocks()) { 3465 printf("Leak of %d blocks found in htmlNodeDumpOutput", 3466 xmlMemBlocks() - mem_base); 3467 test_ret++; 3468 printf(" %d", n_buf); 3469 printf(" %d", n_doc); 3470 printf(" %d", n_cur); 3471 printf(" %d", n_encoding); 3472 printf("\n"); 3473 } 3474 } 3475 } 3476 } 3477 } 3478 function_tests++; 3479 #endif 3480 3481 return(test_ret); 3482 } 3483 3484 3485 static int 3486 test_htmlSaveFile(void) { 3487 int test_ret = 0; 3488 3489 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 3490 int mem_base; 3491 int ret_val; 3492 const char * filename; /* the filename (or URL) */ 3493 int n_filename; 3494 xmlDocPtr cur; /* the document */ 3495 int n_cur; 3496 3497 for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) { 3498 for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) { 3499 mem_base = xmlMemBlocks(); 3500 filename = gen_fileoutput(n_filename, 0); 3501 cur = gen_xmlDocPtr(n_cur, 1); 3502 3503 ret_val = htmlSaveFile(filename, cur); 3504 desret_int(ret_val); 3505 call_tests++; 3506 des_fileoutput(n_filename, filename, 0); 3507 des_xmlDocPtr(n_cur, cur, 1); 3508 xmlResetLastError(); 3509 if (mem_base != xmlMemBlocks()) { 3510 printf("Leak of %d blocks found in htmlSaveFile", 3511 xmlMemBlocks() - mem_base); 3512 test_ret++; 3513 printf(" %d", n_filename); 3514 printf(" %d", n_cur); 3515 printf("\n"); 3516 } 3517 } 3518 } 3519 function_tests++; 3520 #endif 3521 3522 return(test_ret); 3523 } 3524 3525 3526 static int 3527 test_htmlSaveFileEnc(void) { 3528 int test_ret = 0; 3529 3530 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 3531 int mem_base; 3532 int ret_val; 3533 const char * filename; /* the filename */ 3534 int n_filename; 3535 xmlDocPtr cur; /* the document */ 3536 int n_cur; 3537 char * encoding; /* the document encoding */ 3538 int n_encoding; 3539 3540 for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) { 3541 for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) { 3542 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 3543 mem_base = xmlMemBlocks(); 3544 filename = gen_fileoutput(n_filename, 0); 3545 cur = gen_xmlDocPtr(n_cur, 1); 3546 encoding = gen_const_char_ptr(n_encoding, 2); 3547 3548 ret_val = htmlSaveFileEnc(filename, cur, (const char *)encoding); 3549 desret_int(ret_val); 3550 call_tests++; 3551 des_fileoutput(n_filename, filename, 0); 3552 des_xmlDocPtr(n_cur, cur, 1); 3553 des_const_char_ptr(n_encoding, (const char *)encoding, 2); 3554 xmlResetLastError(); 3555 if (mem_base != xmlMemBlocks()) { 3556 printf("Leak of %d blocks found in htmlSaveFileEnc", 3557 xmlMemBlocks() - mem_base); 3558 test_ret++; 3559 printf(" %d", n_filename); 3560 printf(" %d", n_cur); 3561 printf(" %d", n_encoding); 3562 printf("\n"); 3563 } 3564 } 3565 } 3566 } 3567 function_tests++; 3568 #endif 3569 3570 return(test_ret); 3571 } 3572 3573 3574 static int 3575 test_htmlSaveFileFormat(void) { 3576 int test_ret = 0; 3577 3578 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 3579 int mem_base; 3580 int ret_val; 3581 const char * filename; /* the filename */ 3582 int n_filename; 3583 xmlDocPtr cur; /* the document */ 3584 int n_cur; 3585 char * encoding; /* the document encoding */ 3586 int n_encoding; 3587 int format; /* should formatting spaces been added */ 3588 int n_format; 3589 3590 for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) { 3591 for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) { 3592 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 3593 for (n_format = 0;n_format < gen_nb_int;n_format++) { 3594 mem_base = xmlMemBlocks(); 3595 filename = gen_fileoutput(n_filename, 0); 3596 cur = gen_xmlDocPtr(n_cur, 1); 3597 encoding = gen_const_char_ptr(n_encoding, 2); 3598 format = gen_int(n_format, 3); 3599 3600 ret_val = htmlSaveFileFormat(filename, cur, (const char *)encoding, format); 3601 desret_int(ret_val); 3602 call_tests++; 3603 des_fileoutput(n_filename, filename, 0); 3604 des_xmlDocPtr(n_cur, cur, 1); 3605 des_const_char_ptr(n_encoding, (const char *)encoding, 2); 3606 des_int(n_format, format, 3); 3607 xmlResetLastError(); 3608 if (mem_base != xmlMemBlocks()) { 3609 printf("Leak of %d blocks found in htmlSaveFileFormat", 3610 xmlMemBlocks() - mem_base); 3611 test_ret++; 3612 printf(" %d", n_filename); 3613 printf(" %d", n_cur); 3614 printf(" %d", n_encoding); 3615 printf(" %d", n_format); 3616 printf("\n"); 3617 } 3618 } 3619 } 3620 } 3621 } 3622 function_tests++; 3623 #endif 3624 3625 return(test_ret); 3626 } 3627 3628 3629 static int 3630 test_htmlSetMetaEncoding(void) { 3631 int test_ret = 0; 3632 3633 #if defined(LIBXML_HTML_ENABLED) 3634 int mem_base; 3635 int ret_val; 3636 htmlDocPtr doc; /* the document */ 3637 int n_doc; 3638 xmlChar * encoding; /* the encoding string */ 3639 int n_encoding; 3640 3641 for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) { 3642 for (n_encoding = 0;n_encoding < gen_nb_const_xmlChar_ptr;n_encoding++) { 3643 mem_base = xmlMemBlocks(); 3644 doc = gen_htmlDocPtr(n_doc, 0); 3645 encoding = gen_const_xmlChar_ptr(n_encoding, 1); 3646 3647 ret_val = htmlSetMetaEncoding(doc, (const xmlChar *)encoding); 3648 desret_int(ret_val); 3649 call_tests++; 3650 des_htmlDocPtr(n_doc, doc, 0); 3651 des_const_xmlChar_ptr(n_encoding, (const xmlChar *)encoding, 1); 3652 xmlResetLastError(); 3653 if (mem_base != xmlMemBlocks()) { 3654 printf("Leak of %d blocks found in htmlSetMetaEncoding", 3655 xmlMemBlocks() - mem_base); 3656 test_ret++; 3657 printf(" %d", n_doc); 3658 printf(" %d", n_encoding); 3659 printf("\n"); 3660 } 3661 } 3662 } 3663 function_tests++; 3664 #endif 3665 3666 return(test_ret); 3667 } 3668 3669 static int 3670 test_HTMLtree(void) { 3671 int test_ret = 0; 3672 3673 if (quiet == 0) printf("Testing HTMLtree : 18 of 18 functions ...\n"); 3674 test_ret += test_htmlDocContentDumpFormatOutput(); 3675 test_ret += test_htmlDocContentDumpOutput(); 3676 test_ret += test_htmlDocDump(); 3677 test_ret += test_htmlDocDumpMemory(); 3678 test_ret += test_htmlDocDumpMemoryFormat(); 3679 test_ret += test_htmlGetMetaEncoding(); 3680 test_ret += test_htmlIsBooleanAttr(); 3681 test_ret += test_htmlNewDoc(); 3682 test_ret += test_htmlNewDocNoDtD(); 3683 test_ret += test_htmlNodeDump(); 3684 test_ret += test_htmlNodeDumpFile(); 3685 test_ret += test_htmlNodeDumpFileFormat(); 3686 test_ret += test_htmlNodeDumpFormatOutput(); 3687 test_ret += test_htmlNodeDumpOutput(); 3688 test_ret += test_htmlSaveFile(); 3689 test_ret += test_htmlSaveFileEnc(); 3690 test_ret += test_htmlSaveFileFormat(); 3691 test_ret += test_htmlSetMetaEncoding(); 3692 3693 if (test_ret != 0) 3694 printf("Module HTMLtree: %d errors\n", test_ret); 3695 return(test_ret); 3696 } 3697 3698 static int 3699 test_docbDefaultSAXHandlerInit(void) { 3700 int test_ret = 0; 3701 3702 #if defined(LIBXML_DOCB_ENABLED) 3703 #ifdef LIBXML_DOCB_ENABLED 3704 int mem_base; 3705 3706 mem_base = xmlMemBlocks(); 3707 3708 docbDefaultSAXHandlerInit(); 3709 call_tests++; 3710 xmlResetLastError(); 3711 if (mem_base != xmlMemBlocks()) { 3712 printf("Leak of %d blocks found in docbDefaultSAXHandlerInit", 3713 xmlMemBlocks() - mem_base); 3714 test_ret++; 3715 printf("\n"); 3716 } 3717 function_tests++; 3718 #endif 3719 #endif 3720 3721 return(test_ret); 3722 } 3723 3724 3725 static int 3726 test_htmlDefaultSAXHandlerInit(void) { 3727 int test_ret = 0; 3728 3729 #if defined(LIBXML_HTML_ENABLED) 3730 #ifdef LIBXML_HTML_ENABLED 3731 int mem_base; 3732 3733 mem_base = xmlMemBlocks(); 3734 3735 htmlDefaultSAXHandlerInit(); 3736 call_tests++; 3737 xmlResetLastError(); 3738 if (mem_base != xmlMemBlocks()) { 3739 printf("Leak of %d blocks found in htmlDefaultSAXHandlerInit", 3740 xmlMemBlocks() - mem_base); 3741 test_ret++; 3742 printf("\n"); 3743 } 3744 function_tests++; 3745 #endif 3746 #endif 3747 3748 return(test_ret); 3749 } 3750 3751 3752 static int 3753 test_xmlDefaultSAXHandlerInit(void) { 3754 int test_ret = 0; 3755 3756 int mem_base; 3757 3758 mem_base = xmlMemBlocks(); 3759 3760 xmlDefaultSAXHandlerInit(); 3761 call_tests++; 3762 xmlResetLastError(); 3763 if (mem_base != xmlMemBlocks()) { 3764 printf("Leak of %d blocks found in xmlDefaultSAXHandlerInit", 3765 xmlMemBlocks() - mem_base); 3766 test_ret++; 3767 printf("\n"); 3768 } 3769 function_tests++; 3770 3771 return(test_ret); 3772 } 3773 3774 3775 #define gen_nb_xmlEnumerationPtr 1 3776 static xmlEnumerationPtr gen_xmlEnumerationPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 3777 return(NULL); 3778 } 3779 static void des_xmlEnumerationPtr(int no ATTRIBUTE_UNUSED, xmlEnumerationPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 3780 } 3781 3782 static int 3783 test_xmlSAX2AttributeDecl(void) { 3784 int test_ret = 0; 3785 3786 int mem_base; 3787 void * ctx; /* the user data (XML parser context) */ 3788 int n_ctx; 3789 xmlChar * elem; /* the name of the element */ 3790 int n_elem; 3791 xmlChar * fullname; /* the attribute name */ 3792 int n_fullname; 3793 int type; /* the attribute type */ 3794 int n_type; 3795 int def; /* the type of default value */ 3796 int n_def; 3797 xmlChar * defaultValue; /* the attribute default value */ 3798 int n_defaultValue; 3799 xmlEnumerationPtr tree; /* the tree of enumerated value set */ 3800 int n_tree; 3801 3802 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 3803 for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) { 3804 for (n_fullname = 0;n_fullname < gen_nb_const_xmlChar_ptr;n_fullname++) { 3805 for (n_type = 0;n_type < gen_nb_int;n_type++) { 3806 for (n_def = 0;n_def < gen_nb_int;n_def++) { 3807 for (n_defaultValue = 0;n_defaultValue < gen_nb_const_xmlChar_ptr;n_defaultValue++) { 3808 for (n_tree = 0;n_tree < gen_nb_xmlEnumerationPtr;n_tree++) { 3809 mem_base = xmlMemBlocks(); 3810 ctx = gen_void_ptr(n_ctx, 0); 3811 elem = gen_const_xmlChar_ptr(n_elem, 1); 3812 fullname = gen_const_xmlChar_ptr(n_fullname, 2); 3813 type = gen_int(n_type, 3); 3814 def = gen_int(n_def, 4); 3815 defaultValue = gen_const_xmlChar_ptr(n_defaultValue, 5); 3816 tree = gen_xmlEnumerationPtr(n_tree, 6); 3817 3818 xmlSAX2AttributeDecl(ctx, (const xmlChar *)elem, (const xmlChar *)fullname, type, def, (const xmlChar *)defaultValue, tree); 3819 call_tests++; 3820 des_void_ptr(n_ctx, ctx, 0); 3821 des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 1); 3822 des_const_xmlChar_ptr(n_fullname, (const xmlChar *)fullname, 2); 3823 des_int(n_type, type, 3); 3824 des_int(n_def, def, 4); 3825 des_const_xmlChar_ptr(n_defaultValue, (const xmlChar *)defaultValue, 5); 3826 des_xmlEnumerationPtr(n_tree, tree, 6); 3827 xmlResetLastError(); 3828 if (mem_base != xmlMemBlocks()) { 3829 printf("Leak of %d blocks found in xmlSAX2AttributeDecl", 3830 xmlMemBlocks() - mem_base); 3831 test_ret++; 3832 printf(" %d", n_ctx); 3833 printf(" %d", n_elem); 3834 printf(" %d", n_fullname); 3835 printf(" %d", n_type); 3836 printf(" %d", n_def); 3837 printf(" %d", n_defaultValue); 3838 printf(" %d", n_tree); 3839 printf("\n"); 3840 } 3841 } 3842 } 3843 } 3844 } 3845 } 3846 } 3847 } 3848 function_tests++; 3849 3850 return(test_ret); 3851 } 3852 3853 3854 static int 3855 test_xmlSAX2CDataBlock(void) { 3856 int test_ret = 0; 3857 3858 int mem_base; 3859 void * ctx; /* the user data (XML parser context) */ 3860 int n_ctx; 3861 xmlChar * value; /* The pcdata content */ 3862 int n_value; 3863 int len; /* the block length */ 3864 int n_len; 3865 3866 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 3867 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 3868 for (n_len = 0;n_len < gen_nb_int;n_len++) { 3869 mem_base = xmlMemBlocks(); 3870 ctx = gen_void_ptr(n_ctx, 0); 3871 value = gen_const_xmlChar_ptr(n_value, 1); 3872 len = gen_int(n_len, 2); 3873 3874 xmlSAX2CDataBlock(ctx, (const xmlChar *)value, len); 3875 call_tests++; 3876 des_void_ptr(n_ctx, ctx, 0); 3877 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1); 3878 des_int(n_len, len, 2); 3879 xmlResetLastError(); 3880 if (mem_base != xmlMemBlocks()) { 3881 printf("Leak of %d blocks found in xmlSAX2CDataBlock", 3882 xmlMemBlocks() - mem_base); 3883 test_ret++; 3884 printf(" %d", n_ctx); 3885 printf(" %d", n_value); 3886 printf(" %d", n_len); 3887 printf("\n"); 3888 } 3889 } 3890 } 3891 } 3892 function_tests++; 3893 3894 return(test_ret); 3895 } 3896 3897 3898 static int 3899 test_xmlSAX2Characters(void) { 3900 int test_ret = 0; 3901 3902 int mem_base; 3903 void * ctx; /* the user data (XML parser context) */ 3904 int n_ctx; 3905 xmlChar * ch; /* a xmlChar string */ 3906 int n_ch; 3907 int len; /* the number of xmlChar */ 3908 int n_len; 3909 3910 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 3911 for (n_ch = 0;n_ch < gen_nb_const_xmlChar_ptr;n_ch++) { 3912 for (n_len = 0;n_len < gen_nb_int;n_len++) { 3913 mem_base = xmlMemBlocks(); 3914 ctx = gen_void_ptr(n_ctx, 0); 3915 ch = gen_const_xmlChar_ptr(n_ch, 1); 3916 len = gen_int(n_len, 2); 3917 3918 xmlSAX2Characters(ctx, (const xmlChar *)ch, len); 3919 call_tests++; 3920 des_void_ptr(n_ctx, ctx, 0); 3921 des_const_xmlChar_ptr(n_ch, (const xmlChar *)ch, 1); 3922 des_int(n_len, len, 2); 3923 xmlResetLastError(); 3924 if (mem_base != xmlMemBlocks()) { 3925 printf("Leak of %d blocks found in xmlSAX2Characters", 3926 xmlMemBlocks() - mem_base); 3927 test_ret++; 3928 printf(" %d", n_ctx); 3929 printf(" %d", n_ch); 3930 printf(" %d", n_len); 3931 printf("\n"); 3932 } 3933 } 3934 } 3935 } 3936 function_tests++; 3937 3938 return(test_ret); 3939 } 3940 3941 3942 static int 3943 test_xmlSAX2Comment(void) { 3944 int test_ret = 0; 3945 3946 int mem_base; 3947 void * ctx; /* the user data (XML parser context) */ 3948 int n_ctx; 3949 xmlChar * value; /* the xmlSAX2Comment content */ 3950 int n_value; 3951 3952 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 3953 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 3954 mem_base = xmlMemBlocks(); 3955 ctx = gen_void_ptr(n_ctx, 0); 3956 value = gen_const_xmlChar_ptr(n_value, 1); 3957 3958 xmlSAX2Comment(ctx, (const xmlChar *)value); 3959 call_tests++; 3960 des_void_ptr(n_ctx, ctx, 0); 3961 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1); 3962 xmlResetLastError(); 3963 if (mem_base != xmlMemBlocks()) { 3964 printf("Leak of %d blocks found in xmlSAX2Comment", 3965 xmlMemBlocks() - mem_base); 3966 test_ret++; 3967 printf(" %d", n_ctx); 3968 printf(" %d", n_value); 3969 printf("\n"); 3970 } 3971 } 3972 } 3973 function_tests++; 3974 3975 return(test_ret); 3976 } 3977 3978 3979 static int 3980 test_xmlSAX2ElementDecl(void) { 3981 int test_ret = 0; 3982 3983 int mem_base; 3984 void * ctx; /* the user data (XML parser context) */ 3985 int n_ctx; 3986 xmlChar * name; /* the element name */ 3987 int n_name; 3988 int type; /* the element type */ 3989 int n_type; 3990 xmlElementContentPtr content; /* the element value tree */ 3991 int n_content; 3992 3993 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 3994 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 3995 for (n_type = 0;n_type < gen_nb_int;n_type++) { 3996 for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) { 3997 mem_base = xmlMemBlocks(); 3998 ctx = gen_void_ptr(n_ctx, 0); 3999 name = gen_const_xmlChar_ptr(n_name, 1); 4000 type = gen_int(n_type, 2); 4001 content = gen_xmlElementContentPtr(n_content, 3); 4002 4003 xmlSAX2ElementDecl(ctx, (const xmlChar *)name, type, content); 4004 call_tests++; 4005 des_void_ptr(n_ctx, ctx, 0); 4006 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 4007 des_int(n_type, type, 2); 4008 des_xmlElementContentPtr(n_content, content, 3); 4009 xmlResetLastError(); 4010 if (mem_base != xmlMemBlocks()) { 4011 printf("Leak of %d blocks found in xmlSAX2ElementDecl", 4012 xmlMemBlocks() - mem_base); 4013 test_ret++; 4014 printf(" %d", n_ctx); 4015 printf(" %d", n_name); 4016 printf(" %d", n_type); 4017 printf(" %d", n_content); 4018 printf("\n"); 4019 } 4020 } 4021 } 4022 } 4023 } 4024 function_tests++; 4025 4026 return(test_ret); 4027 } 4028 4029 4030 static int 4031 test_xmlSAX2EndDocument(void) { 4032 int test_ret = 0; 4033 4034 int mem_base; 4035 void * ctx; /* the user data (XML parser context) */ 4036 int n_ctx; 4037 4038 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4039 mem_base = xmlMemBlocks(); 4040 ctx = gen_void_ptr(n_ctx, 0); 4041 4042 xmlSAX2EndDocument(ctx); 4043 call_tests++; 4044 des_void_ptr(n_ctx, ctx, 0); 4045 xmlResetLastError(); 4046 if (mem_base != xmlMemBlocks()) { 4047 printf("Leak of %d blocks found in xmlSAX2EndDocument", 4048 xmlMemBlocks() - mem_base); 4049 test_ret++; 4050 printf(" %d", n_ctx); 4051 printf("\n"); 4052 } 4053 } 4054 function_tests++; 4055 4056 return(test_ret); 4057 } 4058 4059 4060 static int 4061 test_xmlSAX2EndElement(void) { 4062 int test_ret = 0; 4063 4064 #if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED) || defined(LIBXML_LEGACY_ENABLED) 4065 #ifdef LIBXML_SAX1_ENABLED 4066 int mem_base; 4067 void * ctx; /* the user data (XML parser context) */ 4068 int n_ctx; 4069 xmlChar * name; /* The element name */ 4070 int n_name; 4071 4072 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4073 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 4074 mem_base = xmlMemBlocks(); 4075 ctx = gen_void_ptr(n_ctx, 0); 4076 name = gen_const_xmlChar_ptr(n_name, 1); 4077 4078 xmlSAX2EndElement(ctx, (const xmlChar *)name); 4079 call_tests++; 4080 des_void_ptr(n_ctx, ctx, 0); 4081 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 4082 xmlResetLastError(); 4083 if (mem_base != xmlMemBlocks()) { 4084 printf("Leak of %d blocks found in xmlSAX2EndElement", 4085 xmlMemBlocks() - mem_base); 4086 test_ret++; 4087 printf(" %d", n_ctx); 4088 printf(" %d", n_name); 4089 printf("\n"); 4090 } 4091 } 4092 } 4093 function_tests++; 4094 #endif 4095 #endif 4096 4097 return(test_ret); 4098 } 4099 4100 4101 static int 4102 test_xmlSAX2EndElementNs(void) { 4103 int test_ret = 0; 4104 4105 int mem_base; 4106 void * ctx; /* the user data (XML parser context) */ 4107 int n_ctx; 4108 xmlChar * localname; /* the local name of the element */ 4109 int n_localname; 4110 xmlChar * prefix; /* the element namespace prefix if available */ 4111 int n_prefix; 4112 xmlChar * URI; /* the element namespace name if available */ 4113 int n_URI; 4114 4115 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4116 for (n_localname = 0;n_localname < gen_nb_const_xmlChar_ptr;n_localname++) { 4117 for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) { 4118 for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) { 4119 mem_base = xmlMemBlocks(); 4120 ctx = gen_void_ptr(n_ctx, 0); 4121 localname = gen_const_xmlChar_ptr(n_localname, 1); 4122 prefix = gen_const_xmlChar_ptr(n_prefix, 2); 4123 URI = gen_const_xmlChar_ptr(n_URI, 3); 4124 4125 xmlSAX2EndElementNs(ctx, (const xmlChar *)localname, (const xmlChar *)prefix, (const xmlChar *)URI); 4126 call_tests++; 4127 des_void_ptr(n_ctx, ctx, 0); 4128 des_const_xmlChar_ptr(n_localname, (const xmlChar *)localname, 1); 4129 des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2); 4130 des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 3); 4131 xmlResetLastError(); 4132 if (mem_base != xmlMemBlocks()) { 4133 printf("Leak of %d blocks found in xmlSAX2EndElementNs", 4134 xmlMemBlocks() - mem_base); 4135 test_ret++; 4136 printf(" %d", n_ctx); 4137 printf(" %d", n_localname); 4138 printf(" %d", n_prefix); 4139 printf(" %d", n_URI); 4140 printf("\n"); 4141 } 4142 } 4143 } 4144 } 4145 } 4146 function_tests++; 4147 4148 return(test_ret); 4149 } 4150 4151 4152 static int 4153 test_xmlSAX2EntityDecl(void) { 4154 int test_ret = 0; 4155 4156 int mem_base; 4157 void * ctx; /* the user data (XML parser context) */ 4158 int n_ctx; 4159 xmlChar * name; /* the entity name */ 4160 int n_name; 4161 int type; /* the entity type */ 4162 int n_type; 4163 xmlChar * publicId; /* The public ID of the entity */ 4164 int n_publicId; 4165 xmlChar * systemId; /* The system ID of the entity */ 4166 int n_systemId; 4167 xmlChar * content; /* the entity value (without processing). */ 4168 int n_content; 4169 4170 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4171 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 4172 for (n_type = 0;n_type < gen_nb_int;n_type++) { 4173 for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) { 4174 for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) { 4175 for (n_content = 0;n_content < gen_nb_xmlChar_ptr;n_content++) { 4176 mem_base = xmlMemBlocks(); 4177 ctx = gen_void_ptr(n_ctx, 0); 4178 name = gen_const_xmlChar_ptr(n_name, 1); 4179 type = gen_int(n_type, 2); 4180 publicId = gen_const_xmlChar_ptr(n_publicId, 3); 4181 systemId = gen_const_xmlChar_ptr(n_systemId, 4); 4182 content = gen_xmlChar_ptr(n_content, 5); 4183 4184 xmlSAX2EntityDecl(ctx, (const xmlChar *)name, type, (const xmlChar *)publicId, (const xmlChar *)systemId, content); 4185 call_tests++; 4186 des_void_ptr(n_ctx, ctx, 0); 4187 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 4188 des_int(n_type, type, 2); 4189 des_const_xmlChar_ptr(n_publicId, (const xmlChar *)publicId, 3); 4190 des_const_xmlChar_ptr(n_systemId, (const xmlChar *)systemId, 4); 4191 des_xmlChar_ptr(n_content, content, 5); 4192 xmlResetLastError(); 4193 if (mem_base != xmlMemBlocks()) { 4194 printf("Leak of %d blocks found in xmlSAX2EntityDecl", 4195 xmlMemBlocks() - mem_base); 4196 test_ret++; 4197 printf(" %d", n_ctx); 4198 printf(" %d", n_name); 4199 printf(" %d", n_type); 4200 printf(" %d", n_publicId); 4201 printf(" %d", n_systemId); 4202 printf(" %d", n_content); 4203 printf("\n"); 4204 } 4205 } 4206 } 4207 } 4208 } 4209 } 4210 } 4211 function_tests++; 4212 4213 return(test_ret); 4214 } 4215 4216 4217 static int 4218 test_xmlSAX2ExternalSubset(void) { 4219 int test_ret = 0; 4220 4221 int mem_base; 4222 void * ctx; /* the user data (XML parser context) */ 4223 int n_ctx; 4224 xmlChar * name; /* the root element name */ 4225 int n_name; 4226 xmlChar * ExternalID; /* the external ID */ 4227 int n_ExternalID; 4228 xmlChar * SystemID; /* the SYSTEM ID (e.g. filename or URL) */ 4229 int n_SystemID; 4230 4231 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4232 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 4233 for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) { 4234 for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) { 4235 mem_base = xmlMemBlocks(); 4236 ctx = gen_void_ptr(n_ctx, 0); 4237 name = gen_const_xmlChar_ptr(n_name, 1); 4238 ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2); 4239 SystemID = gen_const_xmlChar_ptr(n_SystemID, 3); 4240 4241 xmlSAX2ExternalSubset(ctx, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID); 4242 call_tests++; 4243 des_void_ptr(n_ctx, ctx, 0); 4244 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 4245 des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2); 4246 des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3); 4247 xmlResetLastError(); 4248 if (mem_base != xmlMemBlocks()) { 4249 printf("Leak of %d blocks found in xmlSAX2ExternalSubset", 4250 xmlMemBlocks() - mem_base); 4251 test_ret++; 4252 printf(" %d", n_ctx); 4253 printf(" %d", n_name); 4254 printf(" %d", n_ExternalID); 4255 printf(" %d", n_SystemID); 4256 printf("\n"); 4257 } 4258 } 4259 } 4260 } 4261 } 4262 function_tests++; 4263 4264 return(test_ret); 4265 } 4266 4267 4268 static int 4269 test_xmlSAX2GetColumnNumber(void) { 4270 int test_ret = 0; 4271 4272 int mem_base; 4273 int ret_val; 4274 void * ctx; /* the user data (XML parser context) */ 4275 int n_ctx; 4276 4277 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4278 mem_base = xmlMemBlocks(); 4279 ctx = gen_void_ptr(n_ctx, 0); 4280 4281 ret_val = xmlSAX2GetColumnNumber(ctx); 4282 desret_int(ret_val); 4283 call_tests++; 4284 des_void_ptr(n_ctx, ctx, 0); 4285 xmlResetLastError(); 4286 if (mem_base != xmlMemBlocks()) { 4287 printf("Leak of %d blocks found in xmlSAX2GetColumnNumber", 4288 xmlMemBlocks() - mem_base); 4289 test_ret++; 4290 printf(" %d", n_ctx); 4291 printf("\n"); 4292 } 4293 } 4294 function_tests++; 4295 4296 return(test_ret); 4297 } 4298 4299 4300 static int 4301 test_xmlSAX2GetEntity(void) { 4302 int test_ret = 0; 4303 4304 int mem_base; 4305 xmlEntityPtr ret_val; 4306 void * ctx; /* the user data (XML parser context) */ 4307 int n_ctx; 4308 xmlChar * name; /* The entity name */ 4309 int n_name; 4310 4311 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4312 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 4313 mem_base = xmlMemBlocks(); 4314 ctx = gen_void_ptr(n_ctx, 0); 4315 name = gen_const_xmlChar_ptr(n_name, 1); 4316 4317 ret_val = xmlSAX2GetEntity(ctx, (const xmlChar *)name); 4318 desret_xmlEntityPtr(ret_val); 4319 call_tests++; 4320 des_void_ptr(n_ctx, ctx, 0); 4321 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 4322 xmlResetLastError(); 4323 if (mem_base != xmlMemBlocks()) { 4324 printf("Leak of %d blocks found in xmlSAX2GetEntity", 4325 xmlMemBlocks() - mem_base); 4326 test_ret++; 4327 printf(" %d", n_ctx); 4328 printf(" %d", n_name); 4329 printf("\n"); 4330 } 4331 } 4332 } 4333 function_tests++; 4334 4335 return(test_ret); 4336 } 4337 4338 4339 static int 4340 test_xmlSAX2GetLineNumber(void) { 4341 int test_ret = 0; 4342 4343 int mem_base; 4344 int ret_val; 4345 void * ctx; /* the user data (XML parser context) */ 4346 int n_ctx; 4347 4348 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4349 mem_base = xmlMemBlocks(); 4350 ctx = gen_void_ptr(n_ctx, 0); 4351 4352 ret_val = xmlSAX2GetLineNumber(ctx); 4353 desret_int(ret_val); 4354 call_tests++; 4355 des_void_ptr(n_ctx, ctx, 0); 4356 xmlResetLastError(); 4357 if (mem_base != xmlMemBlocks()) { 4358 printf("Leak of %d blocks found in xmlSAX2GetLineNumber", 4359 xmlMemBlocks() - mem_base); 4360 test_ret++; 4361 printf(" %d", n_ctx); 4362 printf("\n"); 4363 } 4364 } 4365 function_tests++; 4366 4367 return(test_ret); 4368 } 4369 4370 4371 static int 4372 test_xmlSAX2GetParameterEntity(void) { 4373 int test_ret = 0; 4374 4375 int mem_base; 4376 xmlEntityPtr ret_val; 4377 void * ctx; /* the user data (XML parser context) */ 4378 int n_ctx; 4379 xmlChar * name; /* The entity name */ 4380 int n_name; 4381 4382 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4383 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 4384 mem_base = xmlMemBlocks(); 4385 ctx = gen_void_ptr(n_ctx, 0); 4386 name = gen_const_xmlChar_ptr(n_name, 1); 4387 4388 ret_val = xmlSAX2GetParameterEntity(ctx, (const xmlChar *)name); 4389 desret_xmlEntityPtr(ret_val); 4390 call_tests++; 4391 des_void_ptr(n_ctx, ctx, 0); 4392 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 4393 xmlResetLastError(); 4394 if (mem_base != xmlMemBlocks()) { 4395 printf("Leak of %d blocks found in xmlSAX2GetParameterEntity", 4396 xmlMemBlocks() - mem_base); 4397 test_ret++; 4398 printf(" %d", n_ctx); 4399 printf(" %d", n_name); 4400 printf("\n"); 4401 } 4402 } 4403 } 4404 function_tests++; 4405 4406 return(test_ret); 4407 } 4408 4409 4410 static int 4411 test_xmlSAX2GetPublicId(void) { 4412 int test_ret = 0; 4413 4414 int mem_base; 4415 const xmlChar * ret_val; 4416 void * ctx; /* the user data (XML parser context) */ 4417 int n_ctx; 4418 4419 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4420 mem_base = xmlMemBlocks(); 4421 ctx = gen_void_ptr(n_ctx, 0); 4422 4423 ret_val = xmlSAX2GetPublicId(ctx); 4424 desret_const_xmlChar_ptr(ret_val); 4425 call_tests++; 4426 des_void_ptr(n_ctx, ctx, 0); 4427 xmlResetLastError(); 4428 if (mem_base != xmlMemBlocks()) { 4429 printf("Leak of %d blocks found in xmlSAX2GetPublicId", 4430 xmlMemBlocks() - mem_base); 4431 test_ret++; 4432 printf(" %d", n_ctx); 4433 printf("\n"); 4434 } 4435 } 4436 function_tests++; 4437 4438 return(test_ret); 4439 } 4440 4441 4442 static int 4443 test_xmlSAX2GetSystemId(void) { 4444 int test_ret = 0; 4445 4446 int mem_base; 4447 const xmlChar * ret_val; 4448 void * ctx; /* the user data (XML parser context) */ 4449 int n_ctx; 4450 4451 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4452 mem_base = xmlMemBlocks(); 4453 ctx = gen_void_ptr(n_ctx, 0); 4454 4455 ret_val = xmlSAX2GetSystemId(ctx); 4456 desret_const_xmlChar_ptr(ret_val); 4457 call_tests++; 4458 des_void_ptr(n_ctx, ctx, 0); 4459 xmlResetLastError(); 4460 if (mem_base != xmlMemBlocks()) { 4461 printf("Leak of %d blocks found in xmlSAX2GetSystemId", 4462 xmlMemBlocks() - mem_base); 4463 test_ret++; 4464 printf(" %d", n_ctx); 4465 printf("\n"); 4466 } 4467 } 4468 function_tests++; 4469 4470 return(test_ret); 4471 } 4472 4473 4474 static int 4475 test_xmlSAX2HasExternalSubset(void) { 4476 int test_ret = 0; 4477 4478 int mem_base; 4479 int ret_val; 4480 void * ctx; /* the user data (XML parser context) */ 4481 int n_ctx; 4482 4483 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4484 mem_base = xmlMemBlocks(); 4485 ctx = gen_void_ptr(n_ctx, 0); 4486 4487 ret_val = xmlSAX2HasExternalSubset(ctx); 4488 desret_int(ret_val); 4489 call_tests++; 4490 des_void_ptr(n_ctx, ctx, 0); 4491 xmlResetLastError(); 4492 if (mem_base != xmlMemBlocks()) { 4493 printf("Leak of %d blocks found in xmlSAX2HasExternalSubset", 4494 xmlMemBlocks() - mem_base); 4495 test_ret++; 4496 printf(" %d", n_ctx); 4497 printf("\n"); 4498 } 4499 } 4500 function_tests++; 4501 4502 return(test_ret); 4503 } 4504 4505 4506 static int 4507 test_xmlSAX2HasInternalSubset(void) { 4508 int test_ret = 0; 4509 4510 int mem_base; 4511 int ret_val; 4512 void * ctx; /* the user data (XML parser context) */ 4513 int n_ctx; 4514 4515 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4516 mem_base = xmlMemBlocks(); 4517 ctx = gen_void_ptr(n_ctx, 0); 4518 4519 ret_val = xmlSAX2HasInternalSubset(ctx); 4520 desret_int(ret_val); 4521 call_tests++; 4522 des_void_ptr(n_ctx, ctx, 0); 4523 xmlResetLastError(); 4524 if (mem_base != xmlMemBlocks()) { 4525 printf("Leak of %d blocks found in xmlSAX2HasInternalSubset", 4526 xmlMemBlocks() - mem_base); 4527 test_ret++; 4528 printf(" %d", n_ctx); 4529 printf("\n"); 4530 } 4531 } 4532 function_tests++; 4533 4534 return(test_ret); 4535 } 4536 4537 4538 static int 4539 test_xmlSAX2IgnorableWhitespace(void) { 4540 int test_ret = 0; 4541 4542 int mem_base; 4543 void * ctx; /* the user data (XML parser context) */ 4544 int n_ctx; 4545 xmlChar * ch; /* a xmlChar string */ 4546 int n_ch; 4547 int len; /* the number of xmlChar */ 4548 int n_len; 4549 4550 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4551 for (n_ch = 0;n_ch < gen_nb_const_xmlChar_ptr;n_ch++) { 4552 for (n_len = 0;n_len < gen_nb_int;n_len++) { 4553 mem_base = xmlMemBlocks(); 4554 ctx = gen_void_ptr(n_ctx, 0); 4555 ch = gen_const_xmlChar_ptr(n_ch, 1); 4556 len = gen_int(n_len, 2); 4557 4558 xmlSAX2IgnorableWhitespace(ctx, (const xmlChar *)ch, len); 4559 call_tests++; 4560 des_void_ptr(n_ctx, ctx, 0); 4561 des_const_xmlChar_ptr(n_ch, (const xmlChar *)ch, 1); 4562 des_int(n_len, len, 2); 4563 xmlResetLastError(); 4564 if (mem_base != xmlMemBlocks()) { 4565 printf("Leak of %d blocks found in xmlSAX2IgnorableWhitespace", 4566 xmlMemBlocks() - mem_base); 4567 test_ret++; 4568 printf(" %d", n_ctx); 4569 printf(" %d", n_ch); 4570 printf(" %d", n_len); 4571 printf("\n"); 4572 } 4573 } 4574 } 4575 } 4576 function_tests++; 4577 4578 return(test_ret); 4579 } 4580 4581 4582 #define gen_nb_xmlSAXHandler_ptr 1 4583 static xmlSAXHandler * gen_xmlSAXHandler_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 4584 return(NULL); 4585 } 4586 static void des_xmlSAXHandler_ptr(int no ATTRIBUTE_UNUSED, xmlSAXHandler * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 4587 } 4588 4589 static int 4590 test_xmlSAX2InitDefaultSAXHandler(void) { 4591 int test_ret = 0; 4592 4593 int mem_base; 4594 xmlSAXHandler * hdlr; /* the SAX handler */ 4595 int n_hdlr; 4596 int warning; /* flag if non-zero sets the handler warning procedure */ 4597 int n_warning; 4598 4599 for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) { 4600 for (n_warning = 0;n_warning < gen_nb_int;n_warning++) { 4601 mem_base = xmlMemBlocks(); 4602 hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0); 4603 warning = gen_int(n_warning, 1); 4604 4605 xmlSAX2InitDefaultSAXHandler(hdlr, warning); 4606 call_tests++; 4607 des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0); 4608 des_int(n_warning, warning, 1); 4609 xmlResetLastError(); 4610 if (mem_base != xmlMemBlocks()) { 4611 printf("Leak of %d blocks found in xmlSAX2InitDefaultSAXHandler", 4612 xmlMemBlocks() - mem_base); 4613 test_ret++; 4614 printf(" %d", n_hdlr); 4615 printf(" %d", n_warning); 4616 printf("\n"); 4617 } 4618 } 4619 } 4620 function_tests++; 4621 4622 return(test_ret); 4623 } 4624 4625 4626 static int 4627 test_xmlSAX2InitDocbDefaultSAXHandler(void) { 4628 int test_ret = 0; 4629 4630 #if defined(LIBXML_DOCB_ENABLED) 4631 int mem_base; 4632 xmlSAXHandler * hdlr; /* the SAX handler */ 4633 int n_hdlr; 4634 4635 for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) { 4636 mem_base = xmlMemBlocks(); 4637 hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0); 4638 4639 xmlSAX2InitDocbDefaultSAXHandler(hdlr); 4640 call_tests++; 4641 des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0); 4642 xmlResetLastError(); 4643 if (mem_base != xmlMemBlocks()) { 4644 printf("Leak of %d blocks found in xmlSAX2InitDocbDefaultSAXHandler", 4645 xmlMemBlocks() - mem_base); 4646 test_ret++; 4647 printf(" %d", n_hdlr); 4648 printf("\n"); 4649 } 4650 } 4651 function_tests++; 4652 #endif 4653 4654 return(test_ret); 4655 } 4656 4657 4658 static int 4659 test_xmlSAX2InitHtmlDefaultSAXHandler(void) { 4660 int test_ret = 0; 4661 4662 #if defined(LIBXML_HTML_ENABLED) 4663 int mem_base; 4664 xmlSAXHandler * hdlr; /* the SAX handler */ 4665 int n_hdlr; 4666 4667 for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) { 4668 mem_base = xmlMemBlocks(); 4669 hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0); 4670 4671 xmlSAX2InitHtmlDefaultSAXHandler(hdlr); 4672 call_tests++; 4673 des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0); 4674 xmlResetLastError(); 4675 if (mem_base != xmlMemBlocks()) { 4676 printf("Leak of %d blocks found in xmlSAX2InitHtmlDefaultSAXHandler", 4677 xmlMemBlocks() - mem_base); 4678 test_ret++; 4679 printf(" %d", n_hdlr); 4680 printf("\n"); 4681 } 4682 } 4683 function_tests++; 4684 #endif 4685 4686 return(test_ret); 4687 } 4688 4689 4690 static int 4691 test_xmlSAX2InternalSubset(void) { 4692 int test_ret = 0; 4693 4694 int mem_base; 4695 void * ctx; /* the user data (XML parser context) */ 4696 int n_ctx; 4697 xmlChar * name; /* the root element name */ 4698 int n_name; 4699 xmlChar * ExternalID; /* the external ID */ 4700 int n_ExternalID; 4701 xmlChar * SystemID; /* the SYSTEM ID (e.g. filename or URL) */ 4702 int n_SystemID; 4703 4704 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4705 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 4706 for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) { 4707 for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) { 4708 mem_base = xmlMemBlocks(); 4709 ctx = gen_void_ptr(n_ctx, 0); 4710 name = gen_const_xmlChar_ptr(n_name, 1); 4711 ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2); 4712 SystemID = gen_const_xmlChar_ptr(n_SystemID, 3); 4713 4714 xmlSAX2InternalSubset(ctx, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID); 4715 call_tests++; 4716 des_void_ptr(n_ctx, ctx, 0); 4717 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 4718 des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2); 4719 des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3); 4720 xmlResetLastError(); 4721 if (mem_base != xmlMemBlocks()) { 4722 printf("Leak of %d blocks found in xmlSAX2InternalSubset", 4723 xmlMemBlocks() - mem_base); 4724 test_ret++; 4725 printf(" %d", n_ctx); 4726 printf(" %d", n_name); 4727 printf(" %d", n_ExternalID); 4728 printf(" %d", n_SystemID); 4729 printf("\n"); 4730 } 4731 } 4732 } 4733 } 4734 } 4735 function_tests++; 4736 4737 return(test_ret); 4738 } 4739 4740 4741 static int 4742 test_xmlSAX2IsStandalone(void) { 4743 int test_ret = 0; 4744 4745 int mem_base; 4746 int ret_val; 4747 void * ctx; /* the user data (XML parser context) */ 4748 int n_ctx; 4749 4750 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4751 mem_base = xmlMemBlocks(); 4752 ctx = gen_void_ptr(n_ctx, 0); 4753 4754 ret_val = xmlSAX2IsStandalone(ctx); 4755 desret_int(ret_val); 4756 call_tests++; 4757 des_void_ptr(n_ctx, ctx, 0); 4758 xmlResetLastError(); 4759 if (mem_base != xmlMemBlocks()) { 4760 printf("Leak of %d blocks found in xmlSAX2IsStandalone", 4761 xmlMemBlocks() - mem_base); 4762 test_ret++; 4763 printf(" %d", n_ctx); 4764 printf("\n"); 4765 } 4766 } 4767 function_tests++; 4768 4769 return(test_ret); 4770 } 4771 4772 4773 static int 4774 test_xmlSAX2NotationDecl(void) { 4775 int test_ret = 0; 4776 4777 int mem_base; 4778 void * ctx; /* the user data (XML parser context) */ 4779 int n_ctx; 4780 xmlChar * name; /* The name of the notation */ 4781 int n_name; 4782 xmlChar * publicId; /* The public ID of the entity */ 4783 int n_publicId; 4784 xmlChar * systemId; /* The system ID of the entity */ 4785 int n_systemId; 4786 4787 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4788 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 4789 for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) { 4790 for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) { 4791 mem_base = xmlMemBlocks(); 4792 ctx = gen_void_ptr(n_ctx, 0); 4793 name = gen_const_xmlChar_ptr(n_name, 1); 4794 publicId = gen_const_xmlChar_ptr(n_publicId, 2); 4795 systemId = gen_const_xmlChar_ptr(n_systemId, 3); 4796 4797 xmlSAX2NotationDecl(ctx, (const xmlChar *)name, (const xmlChar *)publicId, (const xmlChar *)systemId); 4798 call_tests++; 4799 des_void_ptr(n_ctx, ctx, 0); 4800 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 4801 des_const_xmlChar_ptr(n_publicId, (const xmlChar *)publicId, 2); 4802 des_const_xmlChar_ptr(n_systemId, (const xmlChar *)systemId, 3); 4803 xmlResetLastError(); 4804 if (mem_base != xmlMemBlocks()) { 4805 printf("Leak of %d blocks found in xmlSAX2NotationDecl", 4806 xmlMemBlocks() - mem_base); 4807 test_ret++; 4808 printf(" %d", n_ctx); 4809 printf(" %d", n_name); 4810 printf(" %d", n_publicId); 4811 printf(" %d", n_systemId); 4812 printf("\n"); 4813 } 4814 } 4815 } 4816 } 4817 } 4818 function_tests++; 4819 4820 return(test_ret); 4821 } 4822 4823 4824 static int 4825 test_xmlSAX2ProcessingInstruction(void) { 4826 int test_ret = 0; 4827 4828 int mem_base; 4829 void * ctx; /* the user data (XML parser context) */ 4830 int n_ctx; 4831 xmlChar * target; /* the target name */ 4832 int n_target; 4833 xmlChar * data; /* the PI data's */ 4834 int n_data; 4835 4836 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4837 for (n_target = 0;n_target < gen_nb_const_xmlChar_ptr;n_target++) { 4838 for (n_data = 0;n_data < gen_nb_const_xmlChar_ptr;n_data++) { 4839 mem_base = xmlMemBlocks(); 4840 ctx = gen_void_ptr(n_ctx, 0); 4841 target = gen_const_xmlChar_ptr(n_target, 1); 4842 data = gen_const_xmlChar_ptr(n_data, 2); 4843 4844 xmlSAX2ProcessingInstruction(ctx, (const xmlChar *)target, (const xmlChar *)data); 4845 call_tests++; 4846 des_void_ptr(n_ctx, ctx, 0); 4847 des_const_xmlChar_ptr(n_target, (const xmlChar *)target, 1); 4848 des_const_xmlChar_ptr(n_data, (const xmlChar *)data, 2); 4849 xmlResetLastError(); 4850 if (mem_base != xmlMemBlocks()) { 4851 printf("Leak of %d blocks found in xmlSAX2ProcessingInstruction", 4852 xmlMemBlocks() - mem_base); 4853 test_ret++; 4854 printf(" %d", n_ctx); 4855 printf(" %d", n_target); 4856 printf(" %d", n_data); 4857 printf("\n"); 4858 } 4859 } 4860 } 4861 } 4862 function_tests++; 4863 4864 return(test_ret); 4865 } 4866 4867 4868 static int 4869 test_xmlSAX2Reference(void) { 4870 int test_ret = 0; 4871 4872 int mem_base; 4873 void * ctx; /* the user data (XML parser context) */ 4874 int n_ctx; 4875 xmlChar * name; /* The entity name */ 4876 int n_name; 4877 4878 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4879 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 4880 mem_base = xmlMemBlocks(); 4881 ctx = gen_void_ptr(n_ctx, 0); 4882 name = gen_const_xmlChar_ptr(n_name, 1); 4883 4884 xmlSAX2Reference(ctx, (const xmlChar *)name); 4885 call_tests++; 4886 des_void_ptr(n_ctx, ctx, 0); 4887 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 4888 xmlResetLastError(); 4889 if (mem_base != xmlMemBlocks()) { 4890 printf("Leak of %d blocks found in xmlSAX2Reference", 4891 xmlMemBlocks() - mem_base); 4892 test_ret++; 4893 printf(" %d", n_ctx); 4894 printf(" %d", n_name); 4895 printf("\n"); 4896 } 4897 } 4898 } 4899 function_tests++; 4900 4901 return(test_ret); 4902 } 4903 4904 4905 static int 4906 test_xmlSAX2ResolveEntity(void) { 4907 int test_ret = 0; 4908 4909 int mem_base; 4910 xmlParserInputPtr ret_val; 4911 void * ctx; /* the user data (XML parser context) */ 4912 int n_ctx; 4913 xmlChar * publicId; /* The public ID of the entity */ 4914 int n_publicId; 4915 xmlChar * systemId; /* The system ID of the entity */ 4916 int n_systemId; 4917 4918 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4919 for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) { 4920 for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) { 4921 mem_base = xmlMemBlocks(); 4922 ctx = gen_void_ptr(n_ctx, 0); 4923 publicId = gen_const_xmlChar_ptr(n_publicId, 1); 4924 systemId = gen_const_xmlChar_ptr(n_systemId, 2); 4925 4926 ret_val = xmlSAX2ResolveEntity(ctx, (const xmlChar *)publicId, (const xmlChar *)systemId); 4927 desret_xmlParserInputPtr(ret_val); 4928 call_tests++; 4929 des_void_ptr(n_ctx, ctx, 0); 4930 des_const_xmlChar_ptr(n_publicId, (const xmlChar *)publicId, 1); 4931 des_const_xmlChar_ptr(n_systemId, (const xmlChar *)systemId, 2); 4932 xmlResetLastError(); 4933 if (mem_base != xmlMemBlocks()) { 4934 printf("Leak of %d blocks found in xmlSAX2ResolveEntity", 4935 xmlMemBlocks() - mem_base); 4936 test_ret++; 4937 printf(" %d", n_ctx); 4938 printf(" %d", n_publicId); 4939 printf(" %d", n_systemId); 4940 printf("\n"); 4941 } 4942 } 4943 } 4944 } 4945 function_tests++; 4946 4947 return(test_ret); 4948 } 4949 4950 4951 #define gen_nb_xmlSAXLocatorPtr 1 4952 static xmlSAXLocatorPtr gen_xmlSAXLocatorPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 4953 return(NULL); 4954 } 4955 static void des_xmlSAXLocatorPtr(int no ATTRIBUTE_UNUSED, xmlSAXLocatorPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 4956 } 4957 4958 static int 4959 test_xmlSAX2SetDocumentLocator(void) { 4960 int test_ret = 0; 4961 4962 int mem_base; 4963 void * ctx; /* the user data (XML parser context) */ 4964 int n_ctx; 4965 xmlSAXLocatorPtr loc; /* A SAX Locator */ 4966 int n_loc; 4967 4968 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 4969 for (n_loc = 0;n_loc < gen_nb_xmlSAXLocatorPtr;n_loc++) { 4970 mem_base = xmlMemBlocks(); 4971 ctx = gen_void_ptr(n_ctx, 0); 4972 loc = gen_xmlSAXLocatorPtr(n_loc, 1); 4973 4974 xmlSAX2SetDocumentLocator(ctx, loc); 4975 call_tests++; 4976 des_void_ptr(n_ctx, ctx, 0); 4977 des_xmlSAXLocatorPtr(n_loc, loc, 1); 4978 xmlResetLastError(); 4979 if (mem_base != xmlMemBlocks()) { 4980 printf("Leak of %d blocks found in xmlSAX2SetDocumentLocator", 4981 xmlMemBlocks() - mem_base); 4982 test_ret++; 4983 printf(" %d", n_ctx); 4984 printf(" %d", n_loc); 4985 printf("\n"); 4986 } 4987 } 4988 } 4989 function_tests++; 4990 4991 return(test_ret); 4992 } 4993 4994 4995 static int 4996 test_xmlSAX2StartDocument(void) { 4997 int test_ret = 0; 4998 4999 int mem_base; 5000 void * ctx; /* the user data (XML parser context) */ 5001 int n_ctx; 5002 5003 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 5004 mem_base = xmlMemBlocks(); 5005 ctx = gen_void_ptr(n_ctx, 0); 5006 5007 xmlSAX2StartDocument(ctx); 5008 call_tests++; 5009 des_void_ptr(n_ctx, ctx, 0); 5010 xmlResetLastError(); 5011 if (mem_base != xmlMemBlocks()) { 5012 printf("Leak of %d blocks found in xmlSAX2StartDocument", 5013 xmlMemBlocks() - mem_base); 5014 test_ret++; 5015 printf(" %d", n_ctx); 5016 printf("\n"); 5017 } 5018 } 5019 function_tests++; 5020 5021 return(test_ret); 5022 } 5023 5024 5025 static int 5026 test_xmlSAX2StartElement(void) { 5027 int test_ret = 0; 5028 5029 #if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED) || defined(LIBXML_LEGACY_ENABLED) 5030 #ifdef LIBXML_SAX1_ENABLED 5031 int mem_base; 5032 void * ctx; /* the user data (XML parser context) */ 5033 int n_ctx; 5034 xmlChar * fullname; /* The element name, including namespace prefix */ 5035 int n_fullname; 5036 xmlChar ** atts; /* An array of name/value attributes pairs, NULL terminated */ 5037 int n_atts; 5038 5039 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 5040 for (n_fullname = 0;n_fullname < gen_nb_const_xmlChar_ptr;n_fullname++) { 5041 for (n_atts = 0;n_atts < gen_nb_const_xmlChar_ptr_ptr;n_atts++) { 5042 mem_base = xmlMemBlocks(); 5043 ctx = gen_void_ptr(n_ctx, 0); 5044 fullname = gen_const_xmlChar_ptr(n_fullname, 1); 5045 atts = gen_const_xmlChar_ptr_ptr(n_atts, 2); 5046 5047 xmlSAX2StartElement(ctx, (const xmlChar *)fullname, (const xmlChar **)atts); 5048 call_tests++; 5049 des_void_ptr(n_ctx, ctx, 0); 5050 des_const_xmlChar_ptr(n_fullname, (const xmlChar *)fullname, 1); 5051 des_const_xmlChar_ptr_ptr(n_atts, (const xmlChar **)atts, 2); 5052 xmlResetLastError(); 5053 if (mem_base != xmlMemBlocks()) { 5054 printf("Leak of %d blocks found in xmlSAX2StartElement", 5055 xmlMemBlocks() - mem_base); 5056 test_ret++; 5057 printf(" %d", n_ctx); 5058 printf(" %d", n_fullname); 5059 printf(" %d", n_atts); 5060 printf("\n"); 5061 } 5062 } 5063 } 5064 } 5065 function_tests++; 5066 #endif 5067 #endif 5068 5069 return(test_ret); 5070 } 5071 5072 5073 static int 5074 test_xmlSAX2StartElementNs(void) { 5075 int test_ret = 0; 5076 5077 int mem_base; 5078 void * ctx; /* the user data (XML parser context) */ 5079 int n_ctx; 5080 xmlChar * localname; /* the local name of the element */ 5081 int n_localname; 5082 xmlChar * prefix; /* the element namespace prefix if available */ 5083 int n_prefix; 5084 xmlChar * URI; /* the element namespace name if available */ 5085 int n_URI; 5086 int nb_namespaces; /* number of namespace definitions on that node */ 5087 int n_nb_namespaces; 5088 xmlChar ** namespaces; /* pointer to the array of prefix/URI pairs namespace definitions */ 5089 int n_namespaces; 5090 int nb_attributes; /* the number of attributes on that node */ 5091 int n_nb_attributes; 5092 int nb_defaulted; /* the number of defaulted attributes. */ 5093 int n_nb_defaulted; 5094 xmlChar ** attributes; /* pointer to the array of (localname/prefix/URI/value/end) attribute values. */ 5095 int n_attributes; 5096 5097 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 5098 for (n_localname = 0;n_localname < gen_nb_const_xmlChar_ptr;n_localname++) { 5099 for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) { 5100 for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) { 5101 for (n_nb_namespaces = 0;n_nb_namespaces < gen_nb_int;n_nb_namespaces++) { 5102 for (n_namespaces = 0;n_namespaces < gen_nb_const_xmlChar_ptr_ptr;n_namespaces++) { 5103 for (n_nb_attributes = 0;n_nb_attributes < gen_nb_int;n_nb_attributes++) { 5104 for (n_nb_defaulted = 0;n_nb_defaulted < gen_nb_int;n_nb_defaulted++) { 5105 for (n_attributes = 0;n_attributes < gen_nb_const_xmlChar_ptr_ptr;n_attributes++) { 5106 mem_base = xmlMemBlocks(); 5107 ctx = gen_void_ptr(n_ctx, 0); 5108 localname = gen_const_xmlChar_ptr(n_localname, 1); 5109 prefix = gen_const_xmlChar_ptr(n_prefix, 2); 5110 URI = gen_const_xmlChar_ptr(n_URI, 3); 5111 nb_namespaces = gen_int(n_nb_namespaces, 4); 5112 namespaces = gen_const_xmlChar_ptr_ptr(n_namespaces, 5); 5113 nb_attributes = gen_int(n_nb_attributes, 6); 5114 nb_defaulted = gen_int(n_nb_defaulted, 7); 5115 attributes = gen_const_xmlChar_ptr_ptr(n_attributes, 8); 5116 5117 xmlSAX2StartElementNs(ctx, (const xmlChar *)localname, (const xmlChar *)prefix, (const xmlChar *)URI, nb_namespaces, (const xmlChar **)namespaces, nb_attributes, nb_defaulted, (const xmlChar **)attributes); 5118 call_tests++; 5119 des_void_ptr(n_ctx, ctx, 0); 5120 des_const_xmlChar_ptr(n_localname, (const xmlChar *)localname, 1); 5121 des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2); 5122 des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 3); 5123 des_int(n_nb_namespaces, nb_namespaces, 4); 5124 des_const_xmlChar_ptr_ptr(n_namespaces, (const xmlChar **)namespaces, 5); 5125 des_int(n_nb_attributes, nb_attributes, 6); 5126 des_int(n_nb_defaulted, nb_defaulted, 7); 5127 des_const_xmlChar_ptr_ptr(n_attributes, (const xmlChar **)attributes, 8); 5128 xmlResetLastError(); 5129 if (mem_base != xmlMemBlocks()) { 5130 printf("Leak of %d blocks found in xmlSAX2StartElementNs", 5131 xmlMemBlocks() - mem_base); 5132 test_ret++; 5133 printf(" %d", n_ctx); 5134 printf(" %d", n_localname); 5135 printf(" %d", n_prefix); 5136 printf(" %d", n_URI); 5137 printf(" %d", n_nb_namespaces); 5138 printf(" %d", n_namespaces); 5139 printf(" %d", n_nb_attributes); 5140 printf(" %d", n_nb_defaulted); 5141 printf(" %d", n_attributes); 5142 printf("\n"); 5143 } 5144 } 5145 } 5146 } 5147 } 5148 } 5149 } 5150 } 5151 } 5152 } 5153 function_tests++; 5154 5155 return(test_ret); 5156 } 5157 5158 5159 static int 5160 test_xmlSAX2UnparsedEntityDecl(void) { 5161 int test_ret = 0; 5162 5163 int mem_base; 5164 void * ctx; /* the user data (XML parser context) */ 5165 int n_ctx; 5166 xmlChar * name; /* The name of the entity */ 5167 int n_name; 5168 xmlChar * publicId; /* The public ID of the entity */ 5169 int n_publicId; 5170 xmlChar * systemId; /* The system ID of the entity */ 5171 int n_systemId; 5172 xmlChar * notationName; /* the name of the notation */ 5173 int n_notationName; 5174 5175 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 5176 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 5177 for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) { 5178 for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) { 5179 for (n_notationName = 0;n_notationName < gen_nb_const_xmlChar_ptr;n_notationName++) { 5180 mem_base = xmlMemBlocks(); 5181 ctx = gen_void_ptr(n_ctx, 0); 5182 name = gen_const_xmlChar_ptr(n_name, 1); 5183 publicId = gen_const_xmlChar_ptr(n_publicId, 2); 5184 systemId = gen_const_xmlChar_ptr(n_systemId, 3); 5185 notationName = gen_const_xmlChar_ptr(n_notationName, 4); 5186 5187 xmlSAX2UnparsedEntityDecl(ctx, (const xmlChar *)name, (const xmlChar *)publicId, (const xmlChar *)systemId, (const xmlChar *)notationName); 5188 call_tests++; 5189 des_void_ptr(n_ctx, ctx, 0); 5190 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 5191 des_const_xmlChar_ptr(n_publicId, (const xmlChar *)publicId, 2); 5192 des_const_xmlChar_ptr(n_systemId, (const xmlChar *)systemId, 3); 5193 des_const_xmlChar_ptr(n_notationName, (const xmlChar *)notationName, 4); 5194 xmlResetLastError(); 5195 if (mem_base != xmlMemBlocks()) { 5196 printf("Leak of %d blocks found in xmlSAX2UnparsedEntityDecl", 5197 xmlMemBlocks() - mem_base); 5198 test_ret++; 5199 printf(" %d", n_ctx); 5200 printf(" %d", n_name); 5201 printf(" %d", n_publicId); 5202 printf(" %d", n_systemId); 5203 printf(" %d", n_notationName); 5204 printf("\n"); 5205 } 5206 } 5207 } 5208 } 5209 } 5210 } 5211 function_tests++; 5212 5213 return(test_ret); 5214 } 5215 5216 5217 static int 5218 test_xmlSAXDefaultVersion(void) { 5219 int test_ret = 0; 5220 5221 #if defined(LIBXML_SAX1_ENABLED) 5222 #ifdef LIBXML_SAX1_ENABLED 5223 int mem_base; 5224 int ret_val; 5225 int version; /* the version, 1 or 2 */ 5226 int n_version; 5227 5228 for (n_version = 0;n_version < gen_nb_int;n_version++) { 5229 mem_base = xmlMemBlocks(); 5230 version = gen_int(n_version, 0); 5231 5232 ret_val = xmlSAXDefaultVersion(version); 5233 desret_int(ret_val); 5234 call_tests++; 5235 des_int(n_version, version, 0); 5236 xmlResetLastError(); 5237 if (mem_base != xmlMemBlocks()) { 5238 printf("Leak of %d blocks found in xmlSAXDefaultVersion", 5239 xmlMemBlocks() - mem_base); 5240 test_ret++; 5241 printf(" %d", n_version); 5242 printf("\n"); 5243 } 5244 } 5245 function_tests++; 5246 #endif 5247 #endif 5248 5249 return(test_ret); 5250 } 5251 5252 5253 static int 5254 test_xmlSAXVersion(void) { 5255 int test_ret = 0; 5256 5257 int mem_base; 5258 int ret_val; 5259 xmlSAXHandler * hdlr; /* the SAX handler */ 5260 int n_hdlr; 5261 int version; /* the version, 1 or 2 */ 5262 int n_version; 5263 5264 for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) { 5265 for (n_version = 0;n_version < gen_nb_int;n_version++) { 5266 mem_base = xmlMemBlocks(); 5267 hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0); 5268 version = gen_int(n_version, 1); 5269 5270 ret_val = xmlSAXVersion(hdlr, version); 5271 desret_int(ret_val); 5272 call_tests++; 5273 des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0); 5274 des_int(n_version, version, 1); 5275 xmlResetLastError(); 5276 if (mem_base != xmlMemBlocks()) { 5277 printf("Leak of %d blocks found in xmlSAXVersion", 5278 xmlMemBlocks() - mem_base); 5279 test_ret++; 5280 printf(" %d", n_hdlr); 5281 printf(" %d", n_version); 5282 printf("\n"); 5283 } 5284 } 5285 } 5286 function_tests++; 5287 5288 return(test_ret); 5289 } 5290 5291 static int 5292 test_SAX2(void) { 5293 int test_ret = 0; 5294 5295 if (quiet == 0) printf("Testing SAX2 : 38 of 38 functions ...\n"); 5296 test_ret += test_docbDefaultSAXHandlerInit(); 5297 test_ret += test_htmlDefaultSAXHandlerInit(); 5298 test_ret += test_xmlDefaultSAXHandlerInit(); 5299 test_ret += test_xmlSAX2AttributeDecl(); 5300 test_ret += test_xmlSAX2CDataBlock(); 5301 test_ret += test_xmlSAX2Characters(); 5302 test_ret += test_xmlSAX2Comment(); 5303 test_ret += test_xmlSAX2ElementDecl(); 5304 test_ret += test_xmlSAX2EndDocument(); 5305 test_ret += test_xmlSAX2EndElement(); 5306 test_ret += test_xmlSAX2EndElementNs(); 5307 test_ret += test_xmlSAX2EntityDecl(); 5308 test_ret += test_xmlSAX2ExternalSubset(); 5309 test_ret += test_xmlSAX2GetColumnNumber(); 5310 test_ret += test_xmlSAX2GetEntity(); 5311 test_ret += test_xmlSAX2GetLineNumber(); 5312 test_ret += test_xmlSAX2GetParameterEntity(); 5313 test_ret += test_xmlSAX2GetPublicId(); 5314 test_ret += test_xmlSAX2GetSystemId(); 5315 test_ret += test_xmlSAX2HasExternalSubset(); 5316 test_ret += test_xmlSAX2HasInternalSubset(); 5317 test_ret += test_xmlSAX2IgnorableWhitespace(); 5318 test_ret += test_xmlSAX2InitDefaultSAXHandler(); 5319 test_ret += test_xmlSAX2InitDocbDefaultSAXHandler(); 5320 test_ret += test_xmlSAX2InitHtmlDefaultSAXHandler(); 5321 test_ret += test_xmlSAX2InternalSubset(); 5322 test_ret += test_xmlSAX2IsStandalone(); 5323 test_ret += test_xmlSAX2NotationDecl(); 5324 test_ret += test_xmlSAX2ProcessingInstruction(); 5325 test_ret += test_xmlSAX2Reference(); 5326 test_ret += test_xmlSAX2ResolveEntity(); 5327 test_ret += test_xmlSAX2SetDocumentLocator(); 5328 test_ret += test_xmlSAX2StartDocument(); 5329 test_ret += test_xmlSAX2StartElement(); 5330 test_ret += test_xmlSAX2StartElementNs(); 5331 test_ret += test_xmlSAX2UnparsedEntityDecl(); 5332 test_ret += test_xmlSAXDefaultVersion(); 5333 test_ret += test_xmlSAXVersion(); 5334 5335 if (test_ret != 0) 5336 printf("Module SAX2: %d errors\n", test_ret); 5337 return(test_ret); 5338 } 5339 5340 static int 5341 test_xmlC14NDocDumpMemory(void) { 5342 int test_ret = 0; 5343 5344 #if defined(LIBXML_C14N_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 5345 int mem_base; 5346 int ret_val; 5347 xmlDocPtr doc; /* the XML document for canonization */ 5348 int n_doc; 5349 xmlNodeSetPtr nodes; /* the nodes set to be included in the canonized image or NULL if all document nodes should be included */ 5350 int n_nodes; 5351 int mode; /* the c14n mode (see @xmlC14NMode) */ 5352 int n_mode; 5353 xmlChar ** inclusive_ns_prefixes; /* the list of inclusive namespace prefixes ended with a NULL or NULL if there is no inclusive namespaces (only for exclusive canonicalization, ignored otherwise) */ 5354 int n_inclusive_ns_prefixes; 5355 int with_comments; /* include comments in the result (!=0) or not (==0) */ 5356 int n_with_comments; 5357 xmlChar ** doc_txt_ptr; /* the memory pointer for allocated canonical XML text; the caller of this functions is responsible for calling xmlFree() to free allocated memory */ 5358 int n_doc_txt_ptr; 5359 5360 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 5361 for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) { 5362 for (n_mode = 0;n_mode < gen_nb_int;n_mode++) { 5363 for (n_inclusive_ns_prefixes = 0;n_inclusive_ns_prefixes < gen_nb_xmlChar_ptr_ptr;n_inclusive_ns_prefixes++) { 5364 for (n_with_comments = 0;n_with_comments < gen_nb_int;n_with_comments++) { 5365 for (n_doc_txt_ptr = 0;n_doc_txt_ptr < gen_nb_xmlChar_ptr_ptr;n_doc_txt_ptr++) { 5366 mem_base = xmlMemBlocks(); 5367 doc = gen_xmlDocPtr(n_doc, 0); 5368 nodes = gen_xmlNodeSetPtr(n_nodes, 1); 5369 mode = gen_int(n_mode, 2); 5370 inclusive_ns_prefixes = gen_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, 3); 5371 with_comments = gen_int(n_with_comments, 4); 5372 doc_txt_ptr = gen_xmlChar_ptr_ptr(n_doc_txt_ptr, 5); 5373 5374 ret_val = xmlC14NDocDumpMemory(doc, nodes, mode, inclusive_ns_prefixes, with_comments, doc_txt_ptr); 5375 desret_int(ret_val); 5376 call_tests++; 5377 des_xmlDocPtr(n_doc, doc, 0); 5378 des_xmlNodeSetPtr(n_nodes, nodes, 1); 5379 des_int(n_mode, mode, 2); 5380 des_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, inclusive_ns_prefixes, 3); 5381 des_int(n_with_comments, with_comments, 4); 5382 des_xmlChar_ptr_ptr(n_doc_txt_ptr, doc_txt_ptr, 5); 5383 xmlResetLastError(); 5384 if (mem_base != xmlMemBlocks()) { 5385 printf("Leak of %d blocks found in xmlC14NDocDumpMemory", 5386 xmlMemBlocks() - mem_base); 5387 test_ret++; 5388 printf(" %d", n_doc); 5389 printf(" %d", n_nodes); 5390 printf(" %d", n_mode); 5391 printf(" %d", n_inclusive_ns_prefixes); 5392 printf(" %d", n_with_comments); 5393 printf(" %d", n_doc_txt_ptr); 5394 printf("\n"); 5395 } 5396 } 5397 } 5398 } 5399 } 5400 } 5401 } 5402 function_tests++; 5403 #endif 5404 5405 return(test_ret); 5406 } 5407 5408 5409 static int 5410 test_xmlC14NDocSave(void) { 5411 int test_ret = 0; 5412 5413 #if defined(LIBXML_C14N_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 5414 int mem_base; 5415 int ret_val; 5416 xmlDocPtr doc; /* the XML document for canonization */ 5417 int n_doc; 5418 xmlNodeSetPtr nodes; /* the nodes set to be included in the canonized image or NULL if all document nodes should be included */ 5419 int n_nodes; 5420 int mode; /* the c14n mode (see @xmlC14NMode) */ 5421 int n_mode; 5422 xmlChar ** inclusive_ns_prefixes; /* the list of inclusive namespace prefixes ended with a NULL or NULL if there is no inclusive namespaces (only for exclusive canonicalization, ignored otherwise) */ 5423 int n_inclusive_ns_prefixes; 5424 int with_comments; /* include comments in the result (!=0) or not (==0) */ 5425 int n_with_comments; 5426 const char * filename; /* the filename to store canonical XML image */ 5427 int n_filename; 5428 int compression; /* the compression level (zlib requred): -1 - libxml default, 0 - uncompressed, >0 - compression level */ 5429 int n_compression; 5430 5431 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 5432 for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) { 5433 for (n_mode = 0;n_mode < gen_nb_int;n_mode++) { 5434 for (n_inclusive_ns_prefixes = 0;n_inclusive_ns_prefixes < gen_nb_xmlChar_ptr_ptr;n_inclusive_ns_prefixes++) { 5435 for (n_with_comments = 0;n_with_comments < gen_nb_int;n_with_comments++) { 5436 for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) { 5437 for (n_compression = 0;n_compression < gen_nb_int;n_compression++) { 5438 mem_base = xmlMemBlocks(); 5439 doc = gen_xmlDocPtr(n_doc, 0); 5440 nodes = gen_xmlNodeSetPtr(n_nodes, 1); 5441 mode = gen_int(n_mode, 2); 5442 inclusive_ns_prefixes = gen_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, 3); 5443 with_comments = gen_int(n_with_comments, 4); 5444 filename = gen_fileoutput(n_filename, 5); 5445 compression = gen_int(n_compression, 6); 5446 5447 ret_val = xmlC14NDocSave(doc, nodes, mode, inclusive_ns_prefixes, with_comments, filename, compression); 5448 desret_int(ret_val); 5449 call_tests++; 5450 des_xmlDocPtr(n_doc, doc, 0); 5451 des_xmlNodeSetPtr(n_nodes, nodes, 1); 5452 des_int(n_mode, mode, 2); 5453 des_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, inclusive_ns_prefixes, 3); 5454 des_int(n_with_comments, with_comments, 4); 5455 des_fileoutput(n_filename, filename, 5); 5456 des_int(n_compression, compression, 6); 5457 xmlResetLastError(); 5458 if (mem_base != xmlMemBlocks()) { 5459 printf("Leak of %d blocks found in xmlC14NDocSave", 5460 xmlMemBlocks() - mem_base); 5461 test_ret++; 5462 printf(" %d", n_doc); 5463 printf(" %d", n_nodes); 5464 printf(" %d", n_mode); 5465 printf(" %d", n_inclusive_ns_prefixes); 5466 printf(" %d", n_with_comments); 5467 printf(" %d", n_filename); 5468 printf(" %d", n_compression); 5469 printf("\n"); 5470 } 5471 } 5472 } 5473 } 5474 } 5475 } 5476 } 5477 } 5478 function_tests++; 5479 #endif 5480 5481 return(test_ret); 5482 } 5483 5484 5485 static int 5486 test_xmlC14NDocSaveTo(void) { 5487 int test_ret = 0; 5488 5489 #if defined(LIBXML_C14N_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 5490 int mem_base; 5491 int ret_val; 5492 xmlDocPtr doc; /* the XML document for canonization */ 5493 int n_doc; 5494 xmlNodeSetPtr nodes; /* the nodes set to be included in the canonized image or NULL if all document nodes should be included */ 5495 int n_nodes; 5496 int mode; /* the c14n mode (see @xmlC14NMode) */ 5497 int n_mode; 5498 xmlChar ** inclusive_ns_prefixes; /* the list of inclusive namespace prefixes ended with a NULL or NULL if there is no inclusive namespaces (only for exclusive canonicalization, ignored otherwise) */ 5499 int n_inclusive_ns_prefixes; 5500 int with_comments; /* include comments in the result (!=0) or not (==0) */ 5501 int n_with_comments; 5502 xmlOutputBufferPtr buf; /* the output buffer to store canonical XML; this buffer MUST have encoder==NULL because C14N requires UTF-8 output */ 5503 int n_buf; 5504 5505 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 5506 for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) { 5507 for (n_mode = 0;n_mode < gen_nb_int;n_mode++) { 5508 for (n_inclusive_ns_prefixes = 0;n_inclusive_ns_prefixes < gen_nb_xmlChar_ptr_ptr;n_inclusive_ns_prefixes++) { 5509 for (n_with_comments = 0;n_with_comments < gen_nb_int;n_with_comments++) { 5510 for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) { 5511 mem_base = xmlMemBlocks(); 5512 doc = gen_xmlDocPtr(n_doc, 0); 5513 nodes = gen_xmlNodeSetPtr(n_nodes, 1); 5514 mode = gen_int(n_mode, 2); 5515 inclusive_ns_prefixes = gen_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, 3); 5516 with_comments = gen_int(n_with_comments, 4); 5517 buf = gen_xmlOutputBufferPtr(n_buf, 5); 5518 5519 ret_val = xmlC14NDocSaveTo(doc, nodes, mode, inclusive_ns_prefixes, with_comments, buf); 5520 desret_int(ret_val); 5521 call_tests++; 5522 des_xmlDocPtr(n_doc, doc, 0); 5523 des_xmlNodeSetPtr(n_nodes, nodes, 1); 5524 des_int(n_mode, mode, 2); 5525 des_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, inclusive_ns_prefixes, 3); 5526 des_int(n_with_comments, with_comments, 4); 5527 des_xmlOutputBufferPtr(n_buf, buf, 5); 5528 xmlResetLastError(); 5529 if (mem_base != xmlMemBlocks()) { 5530 printf("Leak of %d blocks found in xmlC14NDocSaveTo", 5531 xmlMemBlocks() - mem_base); 5532 test_ret++; 5533 printf(" %d", n_doc); 5534 printf(" %d", n_nodes); 5535 printf(" %d", n_mode); 5536 printf(" %d", n_inclusive_ns_prefixes); 5537 printf(" %d", n_with_comments); 5538 printf(" %d", n_buf); 5539 printf("\n"); 5540 } 5541 } 5542 } 5543 } 5544 } 5545 } 5546 } 5547 function_tests++; 5548 #endif 5549 5550 return(test_ret); 5551 } 5552 5553 5554 static int 5555 test_xmlC14NExecute(void) { 5556 int test_ret = 0; 5557 5558 5559 /* missing type support */ 5560 return(test_ret); 5561 } 5562 5563 static int 5564 test_c14n(void) { 5565 int test_ret = 0; 5566 5567 if (quiet == 0) printf("Testing c14n : 3 of 4 functions ...\n"); 5568 test_ret += test_xmlC14NDocDumpMemory(); 5569 test_ret += test_xmlC14NDocSave(); 5570 test_ret += test_xmlC14NDocSaveTo(); 5571 test_ret += test_xmlC14NExecute(); 5572 5573 if (test_ret != 0) 5574 printf("Module c14n: %d errors\n", test_ret); 5575 return(test_ret); 5576 } 5577 #ifdef LIBXML_CATALOG_ENABLED 5578 5579 #define gen_nb_xmlCatalogPtr 1 5580 static xmlCatalogPtr gen_xmlCatalogPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 5581 return(NULL); 5582 } 5583 static void des_xmlCatalogPtr(int no ATTRIBUTE_UNUSED, xmlCatalogPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 5584 } 5585 #endif 5586 5587 5588 static int 5589 test_xmlACatalogAdd(void) { 5590 int test_ret = 0; 5591 5592 #if defined(LIBXML_CATALOG_ENABLED) 5593 int mem_base; 5594 int ret_val; 5595 xmlCatalogPtr catal; /* a Catalog */ 5596 int n_catal; 5597 xmlChar * type; /* the type of record to add to the catalog */ 5598 int n_type; 5599 xmlChar * orig; /* the system, public or prefix to match */ 5600 int n_orig; 5601 xmlChar * replace; /* the replacement value for the match */ 5602 int n_replace; 5603 5604 for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) { 5605 for (n_type = 0;n_type < gen_nb_const_xmlChar_ptr;n_type++) { 5606 for (n_orig = 0;n_orig < gen_nb_const_xmlChar_ptr;n_orig++) { 5607 for (n_replace = 0;n_replace < gen_nb_const_xmlChar_ptr;n_replace++) { 5608 mem_base = xmlMemBlocks(); 5609 catal = gen_xmlCatalogPtr(n_catal, 0); 5610 type = gen_const_xmlChar_ptr(n_type, 1); 5611 orig = gen_const_xmlChar_ptr(n_orig, 2); 5612 replace = gen_const_xmlChar_ptr(n_replace, 3); 5613 5614 ret_val = xmlACatalogAdd(catal, (const xmlChar *)type, (const xmlChar *)orig, (const xmlChar *)replace); 5615 desret_int(ret_val); 5616 call_tests++; 5617 des_xmlCatalogPtr(n_catal, catal, 0); 5618 des_const_xmlChar_ptr(n_type, (const xmlChar *)type, 1); 5619 des_const_xmlChar_ptr(n_orig, (const xmlChar *)orig, 2); 5620 des_const_xmlChar_ptr(n_replace, (const xmlChar *)replace, 3); 5621 xmlResetLastError(); 5622 if (mem_base != xmlMemBlocks()) { 5623 printf("Leak of %d blocks found in xmlACatalogAdd", 5624 xmlMemBlocks() - mem_base); 5625 test_ret++; 5626 printf(" %d", n_catal); 5627 printf(" %d", n_type); 5628 printf(" %d", n_orig); 5629 printf(" %d", n_replace); 5630 printf("\n"); 5631 } 5632 } 5633 } 5634 } 5635 } 5636 function_tests++; 5637 #endif 5638 5639 return(test_ret); 5640 } 5641 5642 5643 static int 5644 test_xmlACatalogDump(void) { 5645 int test_ret = 0; 5646 5647 #if defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 5648 int mem_base; 5649 xmlCatalogPtr catal; /* a Catalog */ 5650 int n_catal; 5651 FILE * out; /* the file. */ 5652 int n_out; 5653 5654 for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) { 5655 for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) { 5656 mem_base = xmlMemBlocks(); 5657 catal = gen_xmlCatalogPtr(n_catal, 0); 5658 out = gen_FILE_ptr(n_out, 1); 5659 5660 xmlACatalogDump(catal, out); 5661 call_tests++; 5662 des_xmlCatalogPtr(n_catal, catal, 0); 5663 des_FILE_ptr(n_out, out, 1); 5664 xmlResetLastError(); 5665 if (mem_base != xmlMemBlocks()) { 5666 printf("Leak of %d blocks found in xmlACatalogDump", 5667 xmlMemBlocks() - mem_base); 5668 test_ret++; 5669 printf(" %d", n_catal); 5670 printf(" %d", n_out); 5671 printf("\n"); 5672 } 5673 } 5674 } 5675 function_tests++; 5676 #endif 5677 5678 return(test_ret); 5679 } 5680 5681 5682 static int 5683 test_xmlACatalogRemove(void) { 5684 int test_ret = 0; 5685 5686 #if defined(LIBXML_CATALOG_ENABLED) 5687 int mem_base; 5688 int ret_val; 5689 xmlCatalogPtr catal; /* a Catalog */ 5690 int n_catal; 5691 xmlChar * value; /* the value to remove */ 5692 int n_value; 5693 5694 for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) { 5695 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 5696 mem_base = xmlMemBlocks(); 5697 catal = gen_xmlCatalogPtr(n_catal, 0); 5698 value = gen_const_xmlChar_ptr(n_value, 1); 5699 5700 ret_val = xmlACatalogRemove(catal, (const xmlChar *)value); 5701 desret_int(ret_val); 5702 call_tests++; 5703 des_xmlCatalogPtr(n_catal, catal, 0); 5704 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1); 5705 xmlResetLastError(); 5706 if (mem_base != xmlMemBlocks()) { 5707 printf("Leak of %d blocks found in xmlACatalogRemove", 5708 xmlMemBlocks() - mem_base); 5709 test_ret++; 5710 printf(" %d", n_catal); 5711 printf(" %d", n_value); 5712 printf("\n"); 5713 } 5714 } 5715 } 5716 function_tests++; 5717 #endif 5718 5719 return(test_ret); 5720 } 5721 5722 5723 static int 5724 test_xmlACatalogResolve(void) { 5725 int test_ret = 0; 5726 5727 #if defined(LIBXML_CATALOG_ENABLED) 5728 int mem_base; 5729 xmlChar * ret_val; 5730 xmlCatalogPtr catal; /* a Catalog */ 5731 int n_catal; 5732 xmlChar * pubID; /* the public ID string */ 5733 int n_pubID; 5734 xmlChar * sysID; /* the system ID string */ 5735 int n_sysID; 5736 5737 for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) { 5738 for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) { 5739 for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) { 5740 mem_base = xmlMemBlocks(); 5741 catal = gen_xmlCatalogPtr(n_catal, 0); 5742 pubID = gen_const_xmlChar_ptr(n_pubID, 1); 5743 sysID = gen_const_xmlChar_ptr(n_sysID, 2); 5744 5745 ret_val = xmlACatalogResolve(catal, (const xmlChar *)pubID, (const xmlChar *)sysID); 5746 desret_xmlChar_ptr(ret_val); 5747 call_tests++; 5748 des_xmlCatalogPtr(n_catal, catal, 0); 5749 des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 1); 5750 des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 2); 5751 xmlResetLastError(); 5752 if (mem_base != xmlMemBlocks()) { 5753 printf("Leak of %d blocks found in xmlACatalogResolve", 5754 xmlMemBlocks() - mem_base); 5755 test_ret++; 5756 printf(" %d", n_catal); 5757 printf(" %d", n_pubID); 5758 printf(" %d", n_sysID); 5759 printf("\n"); 5760 } 5761 } 5762 } 5763 } 5764 function_tests++; 5765 #endif 5766 5767 return(test_ret); 5768 } 5769 5770 5771 static int 5772 test_xmlACatalogResolvePublic(void) { 5773 int test_ret = 0; 5774 5775 #if defined(LIBXML_CATALOG_ENABLED) 5776 int mem_base; 5777 xmlChar * ret_val; 5778 xmlCatalogPtr catal; /* a Catalog */ 5779 int n_catal; 5780 xmlChar * pubID; /* the public ID string */ 5781 int n_pubID; 5782 5783 for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) { 5784 for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) { 5785 mem_base = xmlMemBlocks(); 5786 catal = gen_xmlCatalogPtr(n_catal, 0); 5787 pubID = gen_const_xmlChar_ptr(n_pubID, 1); 5788 5789 ret_val = xmlACatalogResolvePublic(catal, (const xmlChar *)pubID); 5790 desret_xmlChar_ptr(ret_val); 5791 call_tests++; 5792 des_xmlCatalogPtr(n_catal, catal, 0); 5793 des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 1); 5794 xmlResetLastError(); 5795 if (mem_base != xmlMemBlocks()) { 5796 printf("Leak of %d blocks found in xmlACatalogResolvePublic", 5797 xmlMemBlocks() - mem_base); 5798 test_ret++; 5799 printf(" %d", n_catal); 5800 printf(" %d", n_pubID); 5801 printf("\n"); 5802 } 5803 } 5804 } 5805 function_tests++; 5806 #endif 5807 5808 return(test_ret); 5809 } 5810 5811 5812 static int 5813 test_xmlACatalogResolveSystem(void) { 5814 int test_ret = 0; 5815 5816 #if defined(LIBXML_CATALOG_ENABLED) 5817 int mem_base; 5818 xmlChar * ret_val; 5819 xmlCatalogPtr catal; /* a Catalog */ 5820 int n_catal; 5821 xmlChar * sysID; /* the system ID string */ 5822 int n_sysID; 5823 5824 for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) { 5825 for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) { 5826 mem_base = xmlMemBlocks(); 5827 catal = gen_xmlCatalogPtr(n_catal, 0); 5828 sysID = gen_const_xmlChar_ptr(n_sysID, 1); 5829 5830 ret_val = xmlACatalogResolveSystem(catal, (const xmlChar *)sysID); 5831 desret_xmlChar_ptr(ret_val); 5832 call_tests++; 5833 des_xmlCatalogPtr(n_catal, catal, 0); 5834 des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 1); 5835 xmlResetLastError(); 5836 if (mem_base != xmlMemBlocks()) { 5837 printf("Leak of %d blocks found in xmlACatalogResolveSystem", 5838 xmlMemBlocks() - mem_base); 5839 test_ret++; 5840 printf(" %d", n_catal); 5841 printf(" %d", n_sysID); 5842 printf("\n"); 5843 } 5844 } 5845 } 5846 function_tests++; 5847 #endif 5848 5849 return(test_ret); 5850 } 5851 5852 5853 static int 5854 test_xmlACatalogResolveURI(void) { 5855 int test_ret = 0; 5856 5857 #if defined(LIBXML_CATALOG_ENABLED) 5858 int mem_base; 5859 xmlChar * ret_val; 5860 xmlCatalogPtr catal; /* a Catalog */ 5861 int n_catal; 5862 xmlChar * URI; /* the URI */ 5863 int n_URI; 5864 5865 for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) { 5866 for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) { 5867 mem_base = xmlMemBlocks(); 5868 catal = gen_xmlCatalogPtr(n_catal, 0); 5869 URI = gen_const_xmlChar_ptr(n_URI, 1); 5870 5871 ret_val = xmlACatalogResolveURI(catal, (const xmlChar *)URI); 5872 desret_xmlChar_ptr(ret_val); 5873 call_tests++; 5874 des_xmlCatalogPtr(n_catal, catal, 0); 5875 des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 1); 5876 xmlResetLastError(); 5877 if (mem_base != xmlMemBlocks()) { 5878 printf("Leak of %d blocks found in xmlACatalogResolveURI", 5879 xmlMemBlocks() - mem_base); 5880 test_ret++; 5881 printf(" %d", n_catal); 5882 printf(" %d", n_URI); 5883 printf("\n"); 5884 } 5885 } 5886 } 5887 function_tests++; 5888 #endif 5889 5890 return(test_ret); 5891 } 5892 5893 5894 static int 5895 test_xmlCatalogAdd(void) { 5896 int test_ret = 0; 5897 5898 #if defined(LIBXML_CATALOG_ENABLED) 5899 int mem_base; 5900 int ret_val; 5901 xmlChar * type; /* the type of record to add to the catalog */ 5902 int n_type; 5903 xmlChar * orig; /* the system, public or prefix to match */ 5904 int n_orig; 5905 xmlChar * replace; /* the replacement value for the match */ 5906 int n_replace; 5907 5908 for (n_type = 0;n_type < gen_nb_const_xmlChar_ptr;n_type++) { 5909 for (n_orig = 0;n_orig < gen_nb_const_xmlChar_ptr;n_orig++) { 5910 for (n_replace = 0;n_replace < gen_nb_const_xmlChar_ptr;n_replace++) { 5911 mem_base = xmlMemBlocks(); 5912 type = gen_const_xmlChar_ptr(n_type, 0); 5913 orig = gen_const_xmlChar_ptr(n_orig, 1); 5914 replace = gen_const_xmlChar_ptr(n_replace, 2); 5915 5916 ret_val = xmlCatalogAdd((const xmlChar *)type, (const xmlChar *)orig, (const xmlChar *)replace); 5917 desret_int(ret_val); 5918 call_tests++; 5919 des_const_xmlChar_ptr(n_type, (const xmlChar *)type, 0); 5920 des_const_xmlChar_ptr(n_orig, (const xmlChar *)orig, 1); 5921 des_const_xmlChar_ptr(n_replace, (const xmlChar *)replace, 2); 5922 xmlResetLastError(); 5923 if (mem_base != xmlMemBlocks()) { 5924 printf("Leak of %d blocks found in xmlCatalogAdd", 5925 xmlMemBlocks() - mem_base); 5926 test_ret++; 5927 printf(" %d", n_type); 5928 printf(" %d", n_orig); 5929 printf(" %d", n_replace); 5930 printf("\n"); 5931 } 5932 } 5933 } 5934 } 5935 function_tests++; 5936 #endif 5937 5938 return(test_ret); 5939 } 5940 5941 5942 static int 5943 test_xmlCatalogCleanup(void) { 5944 int test_ret = 0; 5945 5946 #if defined(LIBXML_CATALOG_ENABLED) 5947 5948 5949 xmlCatalogCleanup(); 5950 call_tests++; 5951 xmlResetLastError(); 5952 function_tests++; 5953 #endif 5954 5955 return(test_ret); 5956 } 5957 5958 5959 static int 5960 test_xmlCatalogConvert(void) { 5961 int test_ret = 0; 5962 5963 #if defined(LIBXML_CATALOG_ENABLED) 5964 int ret_val; 5965 5966 5967 ret_val = xmlCatalogConvert(); 5968 desret_int(ret_val); 5969 call_tests++; 5970 xmlResetLastError(); 5971 function_tests++; 5972 #endif 5973 5974 return(test_ret); 5975 } 5976 5977 5978 static int 5979 test_xmlCatalogDump(void) { 5980 int test_ret = 0; 5981 5982 #if defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 5983 int mem_base; 5984 FILE * out; /* the file. */ 5985 int n_out; 5986 5987 for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) { 5988 mem_base = xmlMemBlocks(); 5989 out = gen_FILE_ptr(n_out, 0); 5990 5991 xmlCatalogDump(out); 5992 call_tests++; 5993 des_FILE_ptr(n_out, out, 0); 5994 xmlResetLastError(); 5995 if (mem_base != xmlMemBlocks()) { 5996 printf("Leak of %d blocks found in xmlCatalogDump", 5997 xmlMemBlocks() - mem_base); 5998 test_ret++; 5999 printf(" %d", n_out); 6000 printf("\n"); 6001 } 6002 } 6003 function_tests++; 6004 #endif 6005 6006 return(test_ret); 6007 } 6008 6009 6010 static int 6011 test_xmlCatalogGetDefaults(void) { 6012 int test_ret = 0; 6013 6014 #if defined(LIBXML_CATALOG_ENABLED) 6015 int mem_base; 6016 xmlCatalogAllow ret_val; 6017 6018 mem_base = xmlMemBlocks(); 6019 6020 ret_val = xmlCatalogGetDefaults(); 6021 desret_xmlCatalogAllow(ret_val); 6022 call_tests++; 6023 xmlResetLastError(); 6024 if (mem_base != xmlMemBlocks()) { 6025 printf("Leak of %d blocks found in xmlCatalogGetDefaults", 6026 xmlMemBlocks() - mem_base); 6027 test_ret++; 6028 printf("\n"); 6029 } 6030 function_tests++; 6031 #endif 6032 6033 return(test_ret); 6034 } 6035 6036 6037 static int 6038 test_xmlCatalogIsEmpty(void) { 6039 int test_ret = 0; 6040 6041 #if defined(LIBXML_CATALOG_ENABLED) 6042 int mem_base; 6043 int ret_val; 6044 xmlCatalogPtr catal; /* should this create an SGML catalog */ 6045 int n_catal; 6046 6047 for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) { 6048 mem_base = xmlMemBlocks(); 6049 catal = gen_xmlCatalogPtr(n_catal, 0); 6050 6051 ret_val = xmlCatalogIsEmpty(catal); 6052 desret_int(ret_val); 6053 call_tests++; 6054 des_xmlCatalogPtr(n_catal, catal, 0); 6055 xmlResetLastError(); 6056 if (mem_base != xmlMemBlocks()) { 6057 printf("Leak of %d blocks found in xmlCatalogIsEmpty", 6058 xmlMemBlocks() - mem_base); 6059 test_ret++; 6060 printf(" %d", n_catal); 6061 printf("\n"); 6062 } 6063 } 6064 function_tests++; 6065 #endif 6066 6067 return(test_ret); 6068 } 6069 6070 6071 static int 6072 test_xmlCatalogLocalResolve(void) { 6073 int test_ret = 0; 6074 6075 #if defined(LIBXML_CATALOG_ENABLED) 6076 int mem_base; 6077 xmlChar * ret_val; 6078 void * catalogs; /* a document's list of catalogs */ 6079 int n_catalogs; 6080 xmlChar * pubID; /* the public ID string */ 6081 int n_pubID; 6082 xmlChar * sysID; /* the system ID string */ 6083 int n_sysID; 6084 6085 for (n_catalogs = 0;n_catalogs < gen_nb_void_ptr;n_catalogs++) { 6086 for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) { 6087 for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) { 6088 mem_base = xmlMemBlocks(); 6089 catalogs = gen_void_ptr(n_catalogs, 0); 6090 pubID = gen_const_xmlChar_ptr(n_pubID, 1); 6091 sysID = gen_const_xmlChar_ptr(n_sysID, 2); 6092 6093 ret_val = xmlCatalogLocalResolve(catalogs, (const xmlChar *)pubID, (const xmlChar *)sysID); 6094 desret_xmlChar_ptr(ret_val); 6095 call_tests++; 6096 des_void_ptr(n_catalogs, catalogs, 0); 6097 des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 1); 6098 des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 2); 6099 xmlResetLastError(); 6100 if (mem_base != xmlMemBlocks()) { 6101 printf("Leak of %d blocks found in xmlCatalogLocalResolve", 6102 xmlMemBlocks() - mem_base); 6103 test_ret++; 6104 printf(" %d", n_catalogs); 6105 printf(" %d", n_pubID); 6106 printf(" %d", n_sysID); 6107 printf("\n"); 6108 } 6109 } 6110 } 6111 } 6112 function_tests++; 6113 #endif 6114 6115 return(test_ret); 6116 } 6117 6118 6119 static int 6120 test_xmlCatalogLocalResolveURI(void) { 6121 int test_ret = 0; 6122 6123 #if defined(LIBXML_CATALOG_ENABLED) 6124 int mem_base; 6125 xmlChar * ret_val; 6126 void * catalogs; /* a document's list of catalogs */ 6127 int n_catalogs; 6128 xmlChar * URI; /* the URI */ 6129 int n_URI; 6130 6131 for (n_catalogs = 0;n_catalogs < gen_nb_void_ptr;n_catalogs++) { 6132 for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) { 6133 mem_base = xmlMemBlocks(); 6134 catalogs = gen_void_ptr(n_catalogs, 0); 6135 URI = gen_const_xmlChar_ptr(n_URI, 1); 6136 6137 ret_val = xmlCatalogLocalResolveURI(catalogs, (const xmlChar *)URI); 6138 desret_xmlChar_ptr(ret_val); 6139 call_tests++; 6140 des_void_ptr(n_catalogs, catalogs, 0); 6141 des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 1); 6142 xmlResetLastError(); 6143 if (mem_base != xmlMemBlocks()) { 6144 printf("Leak of %d blocks found in xmlCatalogLocalResolveURI", 6145 xmlMemBlocks() - mem_base); 6146 test_ret++; 6147 printf(" %d", n_catalogs); 6148 printf(" %d", n_URI); 6149 printf("\n"); 6150 } 6151 } 6152 } 6153 function_tests++; 6154 #endif 6155 6156 return(test_ret); 6157 } 6158 6159 6160 static int 6161 test_xmlCatalogRemove(void) { 6162 int test_ret = 0; 6163 6164 #if defined(LIBXML_CATALOG_ENABLED) 6165 int ret_val; 6166 xmlChar * value; /* the value to remove */ 6167 int n_value; 6168 6169 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 6170 value = gen_const_xmlChar_ptr(n_value, 0); 6171 6172 ret_val = xmlCatalogRemove((const xmlChar *)value); 6173 desret_int(ret_val); 6174 call_tests++; 6175 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0); 6176 xmlResetLastError(); 6177 } 6178 function_tests++; 6179 #endif 6180 6181 return(test_ret); 6182 } 6183 6184 6185 static int 6186 test_xmlCatalogResolve(void) { 6187 int test_ret = 0; 6188 6189 #if defined(LIBXML_CATALOG_ENABLED) 6190 xmlChar * ret_val; 6191 xmlChar * pubID; /* the public ID string */ 6192 int n_pubID; 6193 xmlChar * sysID; /* the system ID string */ 6194 int n_sysID; 6195 6196 for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) { 6197 for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) { 6198 pubID = gen_const_xmlChar_ptr(n_pubID, 0); 6199 sysID = gen_const_xmlChar_ptr(n_sysID, 1); 6200 6201 ret_val = xmlCatalogResolve((const xmlChar *)pubID, (const xmlChar *)sysID); 6202 desret_xmlChar_ptr(ret_val); 6203 call_tests++; 6204 des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 0); 6205 des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 1); 6206 xmlResetLastError(); 6207 } 6208 } 6209 function_tests++; 6210 #endif 6211 6212 return(test_ret); 6213 } 6214 6215 6216 static int 6217 test_xmlCatalogResolvePublic(void) { 6218 int test_ret = 0; 6219 6220 #if defined(LIBXML_CATALOG_ENABLED) 6221 int mem_base; 6222 xmlChar * ret_val; 6223 xmlChar * pubID; /* the public ID string */ 6224 int n_pubID; 6225 6226 for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) { 6227 mem_base = xmlMemBlocks(); 6228 pubID = gen_const_xmlChar_ptr(n_pubID, 0); 6229 6230 ret_val = xmlCatalogResolvePublic((const xmlChar *)pubID); 6231 desret_xmlChar_ptr(ret_val); 6232 call_tests++; 6233 des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 0); 6234 xmlResetLastError(); 6235 if (mem_base != xmlMemBlocks()) { 6236 printf("Leak of %d blocks found in xmlCatalogResolvePublic", 6237 xmlMemBlocks() - mem_base); 6238 test_ret++; 6239 printf(" %d", n_pubID); 6240 printf("\n"); 6241 } 6242 } 6243 function_tests++; 6244 #endif 6245 6246 return(test_ret); 6247 } 6248 6249 6250 static int 6251 test_xmlCatalogResolveSystem(void) { 6252 int test_ret = 0; 6253 6254 #if defined(LIBXML_CATALOG_ENABLED) 6255 int mem_base; 6256 xmlChar * ret_val; 6257 xmlChar * sysID; /* the system ID string */ 6258 int n_sysID; 6259 6260 for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) { 6261 mem_base = xmlMemBlocks(); 6262 sysID = gen_const_xmlChar_ptr(n_sysID, 0); 6263 6264 ret_val = xmlCatalogResolveSystem((const xmlChar *)sysID); 6265 desret_xmlChar_ptr(ret_val); 6266 call_tests++; 6267 des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 0); 6268 xmlResetLastError(); 6269 if (mem_base != xmlMemBlocks()) { 6270 printf("Leak of %d blocks found in xmlCatalogResolveSystem", 6271 xmlMemBlocks() - mem_base); 6272 test_ret++; 6273 printf(" %d", n_sysID); 6274 printf("\n"); 6275 } 6276 } 6277 function_tests++; 6278 #endif 6279 6280 return(test_ret); 6281 } 6282 6283 6284 static int 6285 test_xmlCatalogResolveURI(void) { 6286 int test_ret = 0; 6287 6288 #if defined(LIBXML_CATALOG_ENABLED) 6289 int mem_base; 6290 xmlChar * ret_val; 6291 xmlChar * URI; /* the URI */ 6292 int n_URI; 6293 6294 for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) { 6295 mem_base = xmlMemBlocks(); 6296 URI = gen_const_xmlChar_ptr(n_URI, 0); 6297 6298 ret_val = xmlCatalogResolveURI((const xmlChar *)URI); 6299 desret_xmlChar_ptr(ret_val); 6300 call_tests++; 6301 des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0); 6302 xmlResetLastError(); 6303 if (mem_base != xmlMemBlocks()) { 6304 printf("Leak of %d blocks found in xmlCatalogResolveURI", 6305 xmlMemBlocks() - mem_base); 6306 test_ret++; 6307 printf(" %d", n_URI); 6308 printf("\n"); 6309 } 6310 } 6311 function_tests++; 6312 #endif 6313 6314 return(test_ret); 6315 } 6316 6317 6318 static int 6319 test_xmlCatalogSetDefaultPrefer(void) { 6320 int test_ret = 0; 6321 6322 #if defined(LIBXML_CATALOG_ENABLED) 6323 int mem_base; 6324 xmlCatalogPrefer ret_val; 6325 xmlCatalogPrefer prefer; /* the default preference for delegation */ 6326 int n_prefer; 6327 6328 for (n_prefer = 0;n_prefer < gen_nb_xmlCatalogPrefer;n_prefer++) { 6329 mem_base = xmlMemBlocks(); 6330 prefer = gen_xmlCatalogPrefer(n_prefer, 0); 6331 6332 ret_val = xmlCatalogSetDefaultPrefer(prefer); 6333 desret_xmlCatalogPrefer(ret_val); 6334 call_tests++; 6335 des_xmlCatalogPrefer(n_prefer, prefer, 0); 6336 xmlResetLastError(); 6337 if (mem_base != xmlMemBlocks()) { 6338 printf("Leak of %d blocks found in xmlCatalogSetDefaultPrefer", 6339 xmlMemBlocks() - mem_base); 6340 test_ret++; 6341 printf(" %d", n_prefer); 6342 printf("\n"); 6343 } 6344 } 6345 function_tests++; 6346 #endif 6347 6348 return(test_ret); 6349 } 6350 6351 6352 static int 6353 test_xmlCatalogSetDefaults(void) { 6354 int test_ret = 0; 6355 6356 #if defined(LIBXML_CATALOG_ENABLED) 6357 int mem_base; 6358 xmlCatalogAllow allow; /* what catalogs should be accepted */ 6359 int n_allow; 6360 6361 for (n_allow = 0;n_allow < gen_nb_xmlCatalogAllow;n_allow++) { 6362 mem_base = xmlMemBlocks(); 6363 allow = gen_xmlCatalogAllow(n_allow, 0); 6364 6365 xmlCatalogSetDefaults(allow); 6366 call_tests++; 6367 des_xmlCatalogAllow(n_allow, allow, 0); 6368 xmlResetLastError(); 6369 if (mem_base != xmlMemBlocks()) { 6370 printf("Leak of %d blocks found in xmlCatalogSetDefaults", 6371 xmlMemBlocks() - mem_base); 6372 test_ret++; 6373 printf(" %d", n_allow); 6374 printf("\n"); 6375 } 6376 } 6377 function_tests++; 6378 #endif 6379 6380 return(test_ret); 6381 } 6382 6383 6384 static int 6385 test_xmlConvertSGMLCatalog(void) { 6386 int test_ret = 0; 6387 6388 #if defined(LIBXML_CATALOG_ENABLED) 6389 int mem_base; 6390 int ret_val; 6391 xmlCatalogPtr catal; /* the catalog */ 6392 int n_catal; 6393 6394 for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) { 6395 mem_base = xmlMemBlocks(); 6396 catal = gen_xmlCatalogPtr(n_catal, 0); 6397 6398 ret_val = xmlConvertSGMLCatalog(catal); 6399 desret_int(ret_val); 6400 call_tests++; 6401 des_xmlCatalogPtr(n_catal, catal, 0); 6402 xmlResetLastError(); 6403 if (mem_base != xmlMemBlocks()) { 6404 printf("Leak of %d blocks found in xmlConvertSGMLCatalog", 6405 xmlMemBlocks() - mem_base); 6406 test_ret++; 6407 printf(" %d", n_catal); 6408 printf("\n"); 6409 } 6410 } 6411 function_tests++; 6412 #endif 6413 6414 return(test_ret); 6415 } 6416 6417 6418 static int 6419 test_xmlInitializeCatalog(void) { 6420 int test_ret = 0; 6421 6422 #if defined(LIBXML_CATALOG_ENABLED) 6423 int mem_base; 6424 6425 mem_base = xmlMemBlocks(); 6426 6427 xmlInitializeCatalog(); 6428 call_tests++; 6429 xmlResetLastError(); 6430 if (mem_base != xmlMemBlocks()) { 6431 printf("Leak of %d blocks found in xmlInitializeCatalog", 6432 xmlMemBlocks() - mem_base); 6433 test_ret++; 6434 printf("\n"); 6435 } 6436 function_tests++; 6437 #endif 6438 6439 return(test_ret); 6440 } 6441 6442 6443 static int 6444 test_xmlLoadACatalog(void) { 6445 int test_ret = 0; 6446 6447 6448 /* missing type support */ 6449 return(test_ret); 6450 } 6451 6452 6453 static int 6454 test_xmlLoadCatalog(void) { 6455 int test_ret = 0; 6456 6457 #if defined(LIBXML_CATALOG_ENABLED) 6458 int ret_val; 6459 const char * filename; /* a file path */ 6460 int n_filename; 6461 6462 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 6463 filename = gen_filepath(n_filename, 0); 6464 6465 ret_val = xmlLoadCatalog(filename); 6466 desret_int(ret_val); 6467 call_tests++; 6468 des_filepath(n_filename, filename, 0); 6469 xmlResetLastError(); 6470 } 6471 function_tests++; 6472 #endif 6473 6474 return(test_ret); 6475 } 6476 6477 6478 static int 6479 test_xmlLoadCatalogs(void) { 6480 int test_ret = 0; 6481 6482 #if defined(LIBXML_CATALOG_ENABLED) 6483 char * pathss; /* a list of directories separated by a colon or a space. */ 6484 int n_pathss; 6485 6486 for (n_pathss = 0;n_pathss < gen_nb_const_char_ptr;n_pathss++) { 6487 pathss = gen_const_char_ptr(n_pathss, 0); 6488 6489 xmlLoadCatalogs((const char *)pathss); 6490 call_tests++; 6491 des_const_char_ptr(n_pathss, (const char *)pathss, 0); 6492 xmlResetLastError(); 6493 } 6494 function_tests++; 6495 #endif 6496 6497 return(test_ret); 6498 } 6499 6500 6501 static int 6502 test_xmlLoadSGMLSuperCatalog(void) { 6503 int test_ret = 0; 6504 6505 6506 /* missing type support */ 6507 return(test_ret); 6508 } 6509 6510 6511 static int 6512 test_xmlNewCatalog(void) { 6513 int test_ret = 0; 6514 6515 6516 /* missing type support */ 6517 return(test_ret); 6518 } 6519 6520 6521 static int 6522 test_xmlParseCatalogFile(void) { 6523 int test_ret = 0; 6524 6525 #if defined(LIBXML_CATALOG_ENABLED) 6526 int mem_base; 6527 xmlDocPtr ret_val; 6528 const char * filename; /* the filename */ 6529 int n_filename; 6530 6531 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 6532 mem_base = xmlMemBlocks(); 6533 filename = gen_filepath(n_filename, 0); 6534 6535 ret_val = xmlParseCatalogFile(filename); 6536 desret_xmlDocPtr(ret_val); 6537 call_tests++; 6538 des_filepath(n_filename, filename, 0); 6539 xmlResetLastError(); 6540 if (mem_base != xmlMemBlocks()) { 6541 printf("Leak of %d blocks found in xmlParseCatalogFile", 6542 xmlMemBlocks() - mem_base); 6543 test_ret++; 6544 printf(" %d", n_filename); 6545 printf("\n"); 6546 } 6547 } 6548 function_tests++; 6549 #endif 6550 6551 return(test_ret); 6552 } 6553 6554 static int 6555 test_catalog(void) { 6556 int test_ret = 0; 6557 6558 if (quiet == 0) printf("Testing catalog : 27 of 36 functions ...\n"); 6559 test_ret += test_xmlACatalogAdd(); 6560 test_ret += test_xmlACatalogDump(); 6561 test_ret += test_xmlACatalogRemove(); 6562 test_ret += test_xmlACatalogResolve(); 6563 test_ret += test_xmlACatalogResolvePublic(); 6564 test_ret += test_xmlACatalogResolveSystem(); 6565 test_ret += test_xmlACatalogResolveURI(); 6566 test_ret += test_xmlCatalogAdd(); 6567 test_ret += test_xmlCatalogCleanup(); 6568 test_ret += test_xmlCatalogConvert(); 6569 test_ret += test_xmlCatalogDump(); 6570 test_ret += test_xmlCatalogGetDefaults(); 6571 test_ret += test_xmlCatalogIsEmpty(); 6572 test_ret += test_xmlCatalogLocalResolve(); 6573 test_ret += test_xmlCatalogLocalResolveURI(); 6574 test_ret += test_xmlCatalogRemove(); 6575 test_ret += test_xmlCatalogResolve(); 6576 test_ret += test_xmlCatalogResolvePublic(); 6577 test_ret += test_xmlCatalogResolveSystem(); 6578 test_ret += test_xmlCatalogResolveURI(); 6579 test_ret += test_xmlCatalogSetDefaultPrefer(); 6580 test_ret += test_xmlCatalogSetDefaults(); 6581 test_ret += test_xmlConvertSGMLCatalog(); 6582 test_ret += test_xmlInitializeCatalog(); 6583 test_ret += test_xmlLoadACatalog(); 6584 test_ret += test_xmlLoadCatalog(); 6585 test_ret += test_xmlLoadCatalogs(); 6586 test_ret += test_xmlLoadSGMLSuperCatalog(); 6587 test_ret += test_xmlNewCatalog(); 6588 test_ret += test_xmlParseCatalogFile(); 6589 6590 if (test_ret != 0) 6591 printf("Module catalog: %d errors\n", test_ret); 6592 return(test_ret); 6593 } 6594 6595 #define gen_nb_const_xmlChRangeGroup_ptr 1 6596 static xmlChRangeGroup * gen_const_xmlChRangeGroup_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 6597 return(NULL); 6598 } 6599 static void des_const_xmlChRangeGroup_ptr(int no ATTRIBUTE_UNUSED, const xmlChRangeGroup * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 6600 } 6601 6602 static int 6603 test_xmlCharInRange(void) { 6604 int test_ret = 0; 6605 6606 int mem_base; 6607 int ret_val; 6608 unsigned int val; /* character to be validated */ 6609 int n_val; 6610 xmlChRangeGroup * rptr; /* pointer to range to be used to validate */ 6611 int n_rptr; 6612 6613 for (n_val = 0;n_val < gen_nb_unsigned_int;n_val++) { 6614 for (n_rptr = 0;n_rptr < gen_nb_const_xmlChRangeGroup_ptr;n_rptr++) { 6615 mem_base = xmlMemBlocks(); 6616 val = gen_unsigned_int(n_val, 0); 6617 rptr = gen_const_xmlChRangeGroup_ptr(n_rptr, 1); 6618 6619 ret_val = xmlCharInRange(val, (const xmlChRangeGroup *)rptr); 6620 desret_int(ret_val); 6621 call_tests++; 6622 des_unsigned_int(n_val, val, 0); 6623 des_const_xmlChRangeGroup_ptr(n_rptr, (const xmlChRangeGroup *)rptr, 1); 6624 xmlResetLastError(); 6625 if (mem_base != xmlMemBlocks()) { 6626 printf("Leak of %d blocks found in xmlCharInRange", 6627 xmlMemBlocks() - mem_base); 6628 test_ret++; 6629 printf(" %d", n_val); 6630 printf(" %d", n_rptr); 6631 printf("\n"); 6632 } 6633 } 6634 } 6635 function_tests++; 6636 6637 return(test_ret); 6638 } 6639 6640 6641 static int 6642 test_xmlIsBaseChar(void) { 6643 int test_ret = 0; 6644 6645 int mem_base; 6646 int ret_val; 6647 unsigned int ch; /* character to validate */ 6648 int n_ch; 6649 6650 for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) { 6651 mem_base = xmlMemBlocks(); 6652 ch = gen_unsigned_int(n_ch, 0); 6653 6654 ret_val = xmlIsBaseChar(ch); 6655 desret_int(ret_val); 6656 call_tests++; 6657 des_unsigned_int(n_ch, ch, 0); 6658 xmlResetLastError(); 6659 if (mem_base != xmlMemBlocks()) { 6660 printf("Leak of %d blocks found in xmlIsBaseChar", 6661 xmlMemBlocks() - mem_base); 6662 test_ret++; 6663 printf(" %d", n_ch); 6664 printf("\n"); 6665 } 6666 } 6667 function_tests++; 6668 6669 return(test_ret); 6670 } 6671 6672 6673 static int 6674 test_xmlIsBlank(void) { 6675 int test_ret = 0; 6676 6677 int mem_base; 6678 int ret_val; 6679 unsigned int ch; /* character to validate */ 6680 int n_ch; 6681 6682 for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) { 6683 mem_base = xmlMemBlocks(); 6684 ch = gen_unsigned_int(n_ch, 0); 6685 6686 ret_val = xmlIsBlank(ch); 6687 desret_int(ret_val); 6688 call_tests++; 6689 des_unsigned_int(n_ch, ch, 0); 6690 xmlResetLastError(); 6691 if (mem_base != xmlMemBlocks()) { 6692 printf("Leak of %d blocks found in xmlIsBlank", 6693 xmlMemBlocks() - mem_base); 6694 test_ret++; 6695 printf(" %d", n_ch); 6696 printf("\n"); 6697 } 6698 } 6699 function_tests++; 6700 6701 return(test_ret); 6702 } 6703 6704 6705 static int 6706 test_xmlIsChar(void) { 6707 int test_ret = 0; 6708 6709 int mem_base; 6710 int ret_val; 6711 unsigned int ch; /* character to validate */ 6712 int n_ch; 6713 6714 for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) { 6715 mem_base = xmlMemBlocks(); 6716 ch = gen_unsigned_int(n_ch, 0); 6717 6718 ret_val = xmlIsChar(ch); 6719 desret_int(ret_val); 6720 call_tests++; 6721 des_unsigned_int(n_ch, ch, 0); 6722 xmlResetLastError(); 6723 if (mem_base != xmlMemBlocks()) { 6724 printf("Leak of %d blocks found in xmlIsChar", 6725 xmlMemBlocks() - mem_base); 6726 test_ret++; 6727 printf(" %d", n_ch); 6728 printf("\n"); 6729 } 6730 } 6731 function_tests++; 6732 6733 return(test_ret); 6734 } 6735 6736 6737 static int 6738 test_xmlIsCombining(void) { 6739 int test_ret = 0; 6740 6741 int mem_base; 6742 int ret_val; 6743 unsigned int ch; /* character to validate */ 6744 int n_ch; 6745 6746 for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) { 6747 mem_base = xmlMemBlocks(); 6748 ch = gen_unsigned_int(n_ch, 0); 6749 6750 ret_val = xmlIsCombining(ch); 6751 desret_int(ret_val); 6752 call_tests++; 6753 des_unsigned_int(n_ch, ch, 0); 6754 xmlResetLastError(); 6755 if (mem_base != xmlMemBlocks()) { 6756 printf("Leak of %d blocks found in xmlIsCombining", 6757 xmlMemBlocks() - mem_base); 6758 test_ret++; 6759 printf(" %d", n_ch); 6760 printf("\n"); 6761 } 6762 } 6763 function_tests++; 6764 6765 return(test_ret); 6766 } 6767 6768 6769 static int 6770 test_xmlIsDigit(void) { 6771 int test_ret = 0; 6772 6773 int mem_base; 6774 int ret_val; 6775 unsigned int ch; /* character to validate */ 6776 int n_ch; 6777 6778 for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) { 6779 mem_base = xmlMemBlocks(); 6780 ch = gen_unsigned_int(n_ch, 0); 6781 6782 ret_val = xmlIsDigit(ch); 6783 desret_int(ret_val); 6784 call_tests++; 6785 des_unsigned_int(n_ch, ch, 0); 6786 xmlResetLastError(); 6787 if (mem_base != xmlMemBlocks()) { 6788 printf("Leak of %d blocks found in xmlIsDigit", 6789 xmlMemBlocks() - mem_base); 6790 test_ret++; 6791 printf(" %d", n_ch); 6792 printf("\n"); 6793 } 6794 } 6795 function_tests++; 6796 6797 return(test_ret); 6798 } 6799 6800 6801 static int 6802 test_xmlIsExtender(void) { 6803 int test_ret = 0; 6804 6805 int mem_base; 6806 int ret_val; 6807 unsigned int ch; /* character to validate */ 6808 int n_ch; 6809 6810 for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) { 6811 mem_base = xmlMemBlocks(); 6812 ch = gen_unsigned_int(n_ch, 0); 6813 6814 ret_val = xmlIsExtender(ch); 6815 desret_int(ret_val); 6816 call_tests++; 6817 des_unsigned_int(n_ch, ch, 0); 6818 xmlResetLastError(); 6819 if (mem_base != xmlMemBlocks()) { 6820 printf("Leak of %d blocks found in xmlIsExtender", 6821 xmlMemBlocks() - mem_base); 6822 test_ret++; 6823 printf(" %d", n_ch); 6824 printf("\n"); 6825 } 6826 } 6827 function_tests++; 6828 6829 return(test_ret); 6830 } 6831 6832 6833 static int 6834 test_xmlIsIdeographic(void) { 6835 int test_ret = 0; 6836 6837 int mem_base; 6838 int ret_val; 6839 unsigned int ch; /* character to validate */ 6840 int n_ch; 6841 6842 for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) { 6843 mem_base = xmlMemBlocks(); 6844 ch = gen_unsigned_int(n_ch, 0); 6845 6846 ret_val = xmlIsIdeographic(ch); 6847 desret_int(ret_val); 6848 call_tests++; 6849 des_unsigned_int(n_ch, ch, 0); 6850 xmlResetLastError(); 6851 if (mem_base != xmlMemBlocks()) { 6852 printf("Leak of %d blocks found in xmlIsIdeographic", 6853 xmlMemBlocks() - mem_base); 6854 test_ret++; 6855 printf(" %d", n_ch); 6856 printf("\n"); 6857 } 6858 } 6859 function_tests++; 6860 6861 return(test_ret); 6862 } 6863 6864 6865 static int 6866 test_xmlIsPubidChar(void) { 6867 int test_ret = 0; 6868 6869 int mem_base; 6870 int ret_val; 6871 unsigned int ch; /* character to validate */ 6872 int n_ch; 6873 6874 for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) { 6875 mem_base = xmlMemBlocks(); 6876 ch = gen_unsigned_int(n_ch, 0); 6877 6878 ret_val = xmlIsPubidChar(ch); 6879 desret_int(ret_val); 6880 call_tests++; 6881 des_unsigned_int(n_ch, ch, 0); 6882 xmlResetLastError(); 6883 if (mem_base != xmlMemBlocks()) { 6884 printf("Leak of %d blocks found in xmlIsPubidChar", 6885 xmlMemBlocks() - mem_base); 6886 test_ret++; 6887 printf(" %d", n_ch); 6888 printf("\n"); 6889 } 6890 } 6891 function_tests++; 6892 6893 return(test_ret); 6894 } 6895 6896 static int 6897 test_chvalid(void) { 6898 int test_ret = 0; 6899 6900 if (quiet == 0) printf("Testing chvalid : 9 of 9 functions ...\n"); 6901 test_ret += test_xmlCharInRange(); 6902 test_ret += test_xmlIsBaseChar(); 6903 test_ret += test_xmlIsBlank(); 6904 test_ret += test_xmlIsChar(); 6905 test_ret += test_xmlIsCombining(); 6906 test_ret += test_xmlIsDigit(); 6907 test_ret += test_xmlIsExtender(); 6908 test_ret += test_xmlIsIdeographic(); 6909 test_ret += test_xmlIsPubidChar(); 6910 6911 if (test_ret != 0) 6912 printf("Module chvalid: %d errors\n", test_ret); 6913 return(test_ret); 6914 } 6915 6916 static int 6917 test_xmlBoolToText(void) { 6918 int test_ret = 0; 6919 6920 #if defined(LIBXML_DEBUG_ENABLED) 6921 int mem_base; 6922 const char * ret_val; 6923 int boolval; /* a bool to turn into text */ 6924 int n_boolval; 6925 6926 for (n_boolval = 0;n_boolval < gen_nb_int;n_boolval++) { 6927 mem_base = xmlMemBlocks(); 6928 boolval = gen_int(n_boolval, 0); 6929 6930 ret_val = xmlBoolToText(boolval); 6931 desret_const_char_ptr(ret_val); 6932 call_tests++; 6933 des_int(n_boolval, boolval, 0); 6934 xmlResetLastError(); 6935 if (mem_base != xmlMemBlocks()) { 6936 printf("Leak of %d blocks found in xmlBoolToText", 6937 xmlMemBlocks() - mem_base); 6938 test_ret++; 6939 printf(" %d", n_boolval); 6940 printf("\n"); 6941 } 6942 } 6943 function_tests++; 6944 #endif 6945 6946 return(test_ret); 6947 } 6948 6949 6950 static int 6951 test_xmlDebugCheckDocument(void) { 6952 int test_ret = 0; 6953 6954 #if defined(LIBXML_DEBUG_ENABLED) 6955 int mem_base; 6956 int ret_val; 6957 FILE * output; /* the FILE * for the output */ 6958 int n_output; 6959 xmlDocPtr doc; /* the document */ 6960 int n_doc; 6961 6962 for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) { 6963 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 6964 mem_base = xmlMemBlocks(); 6965 output = gen_debug_FILE_ptr(n_output, 0); 6966 doc = gen_xmlDocPtr(n_doc, 1); 6967 6968 ret_val = xmlDebugCheckDocument(output, doc); 6969 desret_int(ret_val); 6970 call_tests++; 6971 des_debug_FILE_ptr(n_output, output, 0); 6972 des_xmlDocPtr(n_doc, doc, 1); 6973 xmlResetLastError(); 6974 if (mem_base != xmlMemBlocks()) { 6975 printf("Leak of %d blocks found in xmlDebugCheckDocument", 6976 xmlMemBlocks() - mem_base); 6977 test_ret++; 6978 printf(" %d", n_output); 6979 printf(" %d", n_doc); 6980 printf("\n"); 6981 } 6982 } 6983 } 6984 function_tests++; 6985 #endif 6986 6987 return(test_ret); 6988 } 6989 6990 6991 static int 6992 test_xmlDebugDumpAttr(void) { 6993 int test_ret = 0; 6994 6995 #if defined(LIBXML_DEBUG_ENABLED) 6996 int mem_base; 6997 FILE * output; /* the FILE * for the output */ 6998 int n_output; 6999 xmlAttrPtr attr; /* the attribute */ 7000 int n_attr; 7001 int depth; /* the indentation level. */ 7002 int n_depth; 7003 7004 for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) { 7005 for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) { 7006 for (n_depth = 0;n_depth < gen_nb_int;n_depth++) { 7007 mem_base = xmlMemBlocks(); 7008 output = gen_debug_FILE_ptr(n_output, 0); 7009 attr = gen_xmlAttrPtr(n_attr, 1); 7010 depth = gen_int(n_depth, 2); 7011 7012 xmlDebugDumpAttr(output, attr, depth); 7013 call_tests++; 7014 des_debug_FILE_ptr(n_output, output, 0); 7015 des_xmlAttrPtr(n_attr, attr, 1); 7016 des_int(n_depth, depth, 2); 7017 xmlResetLastError(); 7018 if (mem_base != xmlMemBlocks()) { 7019 printf("Leak of %d blocks found in xmlDebugDumpAttr", 7020 xmlMemBlocks() - mem_base); 7021 test_ret++; 7022 printf(" %d", n_output); 7023 printf(" %d", n_attr); 7024 printf(" %d", n_depth); 7025 printf("\n"); 7026 } 7027 } 7028 } 7029 } 7030 function_tests++; 7031 #endif 7032 7033 return(test_ret); 7034 } 7035 7036 7037 static int 7038 test_xmlDebugDumpAttrList(void) { 7039 int test_ret = 0; 7040 7041 #if defined(LIBXML_DEBUG_ENABLED) 7042 int mem_base; 7043 FILE * output; /* the FILE * for the output */ 7044 int n_output; 7045 xmlAttrPtr attr; /* the attribute list */ 7046 int n_attr; 7047 int depth; /* the indentation level. */ 7048 int n_depth; 7049 7050 for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) { 7051 for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) { 7052 for (n_depth = 0;n_depth < gen_nb_int;n_depth++) { 7053 mem_base = xmlMemBlocks(); 7054 output = gen_debug_FILE_ptr(n_output, 0); 7055 attr = gen_xmlAttrPtr(n_attr, 1); 7056 depth = gen_int(n_depth, 2); 7057 7058 xmlDebugDumpAttrList(output, attr, depth); 7059 call_tests++; 7060 des_debug_FILE_ptr(n_output, output, 0); 7061 des_xmlAttrPtr(n_attr, attr, 1); 7062 des_int(n_depth, depth, 2); 7063 xmlResetLastError(); 7064 if (mem_base != xmlMemBlocks()) { 7065 printf("Leak of %d blocks found in xmlDebugDumpAttrList", 7066 xmlMemBlocks() - mem_base); 7067 test_ret++; 7068 printf(" %d", n_output); 7069 printf(" %d", n_attr); 7070 printf(" %d", n_depth); 7071 printf("\n"); 7072 } 7073 } 7074 } 7075 } 7076 function_tests++; 7077 #endif 7078 7079 return(test_ret); 7080 } 7081 7082 7083 static int 7084 test_xmlDebugDumpDTD(void) { 7085 int test_ret = 0; 7086 7087 #if defined(LIBXML_DEBUG_ENABLED) 7088 int mem_base; 7089 FILE * output; /* the FILE * for the output */ 7090 int n_output; 7091 xmlDtdPtr dtd; /* the DTD */ 7092 int n_dtd; 7093 7094 for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) { 7095 for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) { 7096 mem_base = xmlMemBlocks(); 7097 output = gen_debug_FILE_ptr(n_output, 0); 7098 dtd = gen_xmlDtdPtr(n_dtd, 1); 7099 7100 xmlDebugDumpDTD(output, dtd); 7101 call_tests++; 7102 des_debug_FILE_ptr(n_output, output, 0); 7103 des_xmlDtdPtr(n_dtd, dtd, 1); 7104 xmlResetLastError(); 7105 if (mem_base != xmlMemBlocks()) { 7106 printf("Leak of %d blocks found in xmlDebugDumpDTD", 7107 xmlMemBlocks() - mem_base); 7108 test_ret++; 7109 printf(" %d", n_output); 7110 printf(" %d", n_dtd); 7111 printf("\n"); 7112 } 7113 } 7114 } 7115 function_tests++; 7116 #endif 7117 7118 return(test_ret); 7119 } 7120 7121 7122 static int 7123 test_xmlDebugDumpDocument(void) { 7124 int test_ret = 0; 7125 7126 #if defined(LIBXML_DEBUG_ENABLED) 7127 int mem_base; 7128 FILE * output; /* the FILE * for the output */ 7129 int n_output; 7130 xmlDocPtr doc; /* the document */ 7131 int n_doc; 7132 7133 for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) { 7134 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 7135 mem_base = xmlMemBlocks(); 7136 output = gen_debug_FILE_ptr(n_output, 0); 7137 doc = gen_xmlDocPtr(n_doc, 1); 7138 7139 xmlDebugDumpDocument(output, doc); 7140 call_tests++; 7141 des_debug_FILE_ptr(n_output, output, 0); 7142 des_xmlDocPtr(n_doc, doc, 1); 7143 xmlResetLastError(); 7144 if (mem_base != xmlMemBlocks()) { 7145 printf("Leak of %d blocks found in xmlDebugDumpDocument", 7146 xmlMemBlocks() - mem_base); 7147 test_ret++; 7148 printf(" %d", n_output); 7149 printf(" %d", n_doc); 7150 printf("\n"); 7151 } 7152 } 7153 } 7154 function_tests++; 7155 #endif 7156 7157 return(test_ret); 7158 } 7159 7160 7161 static int 7162 test_xmlDebugDumpDocumentHead(void) { 7163 int test_ret = 0; 7164 7165 #if defined(LIBXML_DEBUG_ENABLED) 7166 int mem_base; 7167 FILE * output; /* the FILE * for the output */ 7168 int n_output; 7169 xmlDocPtr doc; /* the document */ 7170 int n_doc; 7171 7172 for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) { 7173 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 7174 mem_base = xmlMemBlocks(); 7175 output = gen_debug_FILE_ptr(n_output, 0); 7176 doc = gen_xmlDocPtr(n_doc, 1); 7177 7178 xmlDebugDumpDocumentHead(output, doc); 7179 call_tests++; 7180 des_debug_FILE_ptr(n_output, output, 0); 7181 des_xmlDocPtr(n_doc, doc, 1); 7182 xmlResetLastError(); 7183 if (mem_base != xmlMemBlocks()) { 7184 printf("Leak of %d blocks found in xmlDebugDumpDocumentHead", 7185 xmlMemBlocks() - mem_base); 7186 test_ret++; 7187 printf(" %d", n_output); 7188 printf(" %d", n_doc); 7189 printf("\n"); 7190 } 7191 } 7192 } 7193 function_tests++; 7194 #endif 7195 7196 return(test_ret); 7197 } 7198 7199 7200 static int 7201 test_xmlDebugDumpEntities(void) { 7202 int test_ret = 0; 7203 7204 #if defined(LIBXML_DEBUG_ENABLED) 7205 int mem_base; 7206 FILE * output; /* the FILE * for the output */ 7207 int n_output; 7208 xmlDocPtr doc; /* the document */ 7209 int n_doc; 7210 7211 for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) { 7212 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 7213 mem_base = xmlMemBlocks(); 7214 output = gen_debug_FILE_ptr(n_output, 0); 7215 doc = gen_xmlDocPtr(n_doc, 1); 7216 7217 xmlDebugDumpEntities(output, doc); 7218 call_tests++; 7219 des_debug_FILE_ptr(n_output, output, 0); 7220 des_xmlDocPtr(n_doc, doc, 1); 7221 xmlResetLastError(); 7222 if (mem_base != xmlMemBlocks()) { 7223 printf("Leak of %d blocks found in xmlDebugDumpEntities", 7224 xmlMemBlocks() - mem_base); 7225 test_ret++; 7226 printf(" %d", n_output); 7227 printf(" %d", n_doc); 7228 printf("\n"); 7229 } 7230 } 7231 } 7232 function_tests++; 7233 #endif 7234 7235 return(test_ret); 7236 } 7237 7238 7239 static int 7240 test_xmlDebugDumpNode(void) { 7241 int test_ret = 0; 7242 7243 #if defined(LIBXML_DEBUG_ENABLED) 7244 int mem_base; 7245 FILE * output; /* the FILE * for the output */ 7246 int n_output; 7247 xmlNodePtr node; /* the node */ 7248 int n_node; 7249 int depth; /* the indentation level. */ 7250 int n_depth; 7251 7252 for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) { 7253 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 7254 for (n_depth = 0;n_depth < gen_nb_int;n_depth++) { 7255 mem_base = xmlMemBlocks(); 7256 output = gen_debug_FILE_ptr(n_output, 0); 7257 node = gen_xmlNodePtr(n_node, 1); 7258 depth = gen_int(n_depth, 2); 7259 7260 xmlDebugDumpNode(output, node, depth); 7261 call_tests++; 7262 des_debug_FILE_ptr(n_output, output, 0); 7263 des_xmlNodePtr(n_node, node, 1); 7264 des_int(n_depth, depth, 2); 7265 xmlResetLastError(); 7266 if (mem_base != xmlMemBlocks()) { 7267 printf("Leak of %d blocks found in xmlDebugDumpNode", 7268 xmlMemBlocks() - mem_base); 7269 test_ret++; 7270 printf(" %d", n_output); 7271 printf(" %d", n_node); 7272 printf(" %d", n_depth); 7273 printf("\n"); 7274 } 7275 } 7276 } 7277 } 7278 function_tests++; 7279 #endif 7280 7281 return(test_ret); 7282 } 7283 7284 7285 static int 7286 test_xmlDebugDumpNodeList(void) { 7287 int test_ret = 0; 7288 7289 #if defined(LIBXML_DEBUG_ENABLED) 7290 int mem_base; 7291 FILE * output; /* the FILE * for the output */ 7292 int n_output; 7293 xmlNodePtr node; /* the node list */ 7294 int n_node; 7295 int depth; /* the indentation level. */ 7296 int n_depth; 7297 7298 for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) { 7299 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 7300 for (n_depth = 0;n_depth < gen_nb_int;n_depth++) { 7301 mem_base = xmlMemBlocks(); 7302 output = gen_debug_FILE_ptr(n_output, 0); 7303 node = gen_xmlNodePtr(n_node, 1); 7304 depth = gen_int(n_depth, 2); 7305 7306 xmlDebugDumpNodeList(output, node, depth); 7307 call_tests++; 7308 des_debug_FILE_ptr(n_output, output, 0); 7309 des_xmlNodePtr(n_node, node, 1); 7310 des_int(n_depth, depth, 2); 7311 xmlResetLastError(); 7312 if (mem_base != xmlMemBlocks()) { 7313 printf("Leak of %d blocks found in xmlDebugDumpNodeList", 7314 xmlMemBlocks() - mem_base); 7315 test_ret++; 7316 printf(" %d", n_output); 7317 printf(" %d", n_node); 7318 printf(" %d", n_depth); 7319 printf("\n"); 7320 } 7321 } 7322 } 7323 } 7324 function_tests++; 7325 #endif 7326 7327 return(test_ret); 7328 } 7329 7330 7331 static int 7332 test_xmlDebugDumpOneNode(void) { 7333 int test_ret = 0; 7334 7335 #if defined(LIBXML_DEBUG_ENABLED) 7336 int mem_base; 7337 FILE * output; /* the FILE * for the output */ 7338 int n_output; 7339 xmlNodePtr node; /* the node */ 7340 int n_node; 7341 int depth; /* the indentation level. */ 7342 int n_depth; 7343 7344 for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) { 7345 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 7346 for (n_depth = 0;n_depth < gen_nb_int;n_depth++) { 7347 mem_base = xmlMemBlocks(); 7348 output = gen_debug_FILE_ptr(n_output, 0); 7349 node = gen_xmlNodePtr(n_node, 1); 7350 depth = gen_int(n_depth, 2); 7351 7352 xmlDebugDumpOneNode(output, node, depth); 7353 call_tests++; 7354 des_debug_FILE_ptr(n_output, output, 0); 7355 des_xmlNodePtr(n_node, node, 1); 7356 des_int(n_depth, depth, 2); 7357 xmlResetLastError(); 7358 if (mem_base != xmlMemBlocks()) { 7359 printf("Leak of %d blocks found in xmlDebugDumpOneNode", 7360 xmlMemBlocks() - mem_base); 7361 test_ret++; 7362 printf(" %d", n_output); 7363 printf(" %d", n_node); 7364 printf(" %d", n_depth); 7365 printf("\n"); 7366 } 7367 } 7368 } 7369 } 7370 function_tests++; 7371 #endif 7372 7373 return(test_ret); 7374 } 7375 7376 7377 static int 7378 test_xmlDebugDumpString(void) { 7379 int test_ret = 0; 7380 7381 #if defined(LIBXML_DEBUG_ENABLED) 7382 int mem_base; 7383 FILE * output; /* the FILE * for the output */ 7384 int n_output; 7385 xmlChar * str; /* the string */ 7386 int n_str; 7387 7388 for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) { 7389 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 7390 mem_base = xmlMemBlocks(); 7391 output = gen_debug_FILE_ptr(n_output, 0); 7392 str = gen_const_xmlChar_ptr(n_str, 1); 7393 7394 xmlDebugDumpString(output, (const xmlChar *)str); 7395 call_tests++; 7396 des_debug_FILE_ptr(n_output, output, 0); 7397 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1); 7398 xmlResetLastError(); 7399 if (mem_base != xmlMemBlocks()) { 7400 printf("Leak of %d blocks found in xmlDebugDumpString", 7401 xmlMemBlocks() - mem_base); 7402 test_ret++; 7403 printf(" %d", n_output); 7404 printf(" %d", n_str); 7405 printf("\n"); 7406 } 7407 } 7408 } 7409 function_tests++; 7410 #endif 7411 7412 return(test_ret); 7413 } 7414 7415 7416 static int 7417 test_xmlLsCountNode(void) { 7418 int test_ret = 0; 7419 7420 #if defined(LIBXML_DEBUG_ENABLED) 7421 int mem_base; 7422 int ret_val; 7423 xmlNodePtr node; /* the node to count */ 7424 int n_node; 7425 7426 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 7427 mem_base = xmlMemBlocks(); 7428 node = gen_xmlNodePtr(n_node, 0); 7429 7430 ret_val = xmlLsCountNode(node); 7431 desret_int(ret_val); 7432 call_tests++; 7433 des_xmlNodePtr(n_node, node, 0); 7434 xmlResetLastError(); 7435 if (mem_base != xmlMemBlocks()) { 7436 printf("Leak of %d blocks found in xmlLsCountNode", 7437 xmlMemBlocks() - mem_base); 7438 test_ret++; 7439 printf(" %d", n_node); 7440 printf("\n"); 7441 } 7442 } 7443 function_tests++; 7444 #endif 7445 7446 return(test_ret); 7447 } 7448 7449 7450 static int 7451 test_xmlLsOneNode(void) { 7452 int test_ret = 0; 7453 7454 #if defined(LIBXML_DEBUG_ENABLED) 7455 int mem_base; 7456 FILE * output; /* the FILE * for the output */ 7457 int n_output; 7458 xmlNodePtr node; /* the node to dump */ 7459 int n_node; 7460 7461 for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) { 7462 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 7463 mem_base = xmlMemBlocks(); 7464 output = gen_debug_FILE_ptr(n_output, 0); 7465 node = gen_xmlNodePtr(n_node, 1); 7466 7467 xmlLsOneNode(output, node); 7468 call_tests++; 7469 des_debug_FILE_ptr(n_output, output, 0); 7470 des_xmlNodePtr(n_node, node, 1); 7471 xmlResetLastError(); 7472 if (mem_base != xmlMemBlocks()) { 7473 printf("Leak of %d blocks found in xmlLsOneNode", 7474 xmlMemBlocks() - mem_base); 7475 test_ret++; 7476 printf(" %d", n_output); 7477 printf(" %d", n_node); 7478 printf("\n"); 7479 } 7480 } 7481 } 7482 function_tests++; 7483 #endif 7484 7485 return(test_ret); 7486 } 7487 7488 7489 #define gen_nb_char_ptr 1 7490 static char * gen_char_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 7491 return(NULL); 7492 } 7493 static void des_char_ptr(int no ATTRIBUTE_UNUSED, char * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 7494 } 7495 7496 static int 7497 test_xmlShell(void) { 7498 int test_ret = 0; 7499 7500 7501 /* missing type support */ 7502 return(test_ret); 7503 } 7504 7505 7506 static int 7507 test_xmlShellBase(void) { 7508 int test_ret = 0; 7509 7510 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) 7511 int mem_base; 7512 int ret_val; 7513 xmlShellCtxtPtr ctxt; /* the shell context */ 7514 int n_ctxt; 7515 char * arg; /* unused */ 7516 int n_arg; 7517 xmlNodePtr node; /* a node */ 7518 int n_node; 7519 xmlNodePtr node2; /* unused */ 7520 int n_node2; 7521 7522 for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) { 7523 for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) { 7524 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 7525 for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) { 7526 mem_base = xmlMemBlocks(); 7527 ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0); 7528 arg = gen_char_ptr(n_arg, 1); 7529 node = gen_xmlNodePtr(n_node, 2); 7530 node2 = gen_xmlNodePtr(n_node2, 3); 7531 7532 ret_val = xmlShellBase(ctxt, arg, node, node2); 7533 desret_int(ret_val); 7534 call_tests++; 7535 des_xmlShellCtxtPtr(n_ctxt, ctxt, 0); 7536 des_char_ptr(n_arg, arg, 1); 7537 des_xmlNodePtr(n_node, node, 2); 7538 des_xmlNodePtr(n_node2, node2, 3); 7539 xmlResetLastError(); 7540 if (mem_base != xmlMemBlocks()) { 7541 printf("Leak of %d blocks found in xmlShellBase", 7542 xmlMemBlocks() - mem_base); 7543 test_ret++; 7544 printf(" %d", n_ctxt); 7545 printf(" %d", n_arg); 7546 printf(" %d", n_node); 7547 printf(" %d", n_node2); 7548 printf("\n"); 7549 } 7550 } 7551 } 7552 } 7553 } 7554 function_tests++; 7555 #endif 7556 7557 return(test_ret); 7558 } 7559 7560 7561 static int 7562 test_xmlShellCat(void) { 7563 int test_ret = 0; 7564 7565 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 7566 int mem_base; 7567 int ret_val; 7568 xmlShellCtxtPtr ctxt; /* the shell context */ 7569 int n_ctxt; 7570 char * arg; /* unused */ 7571 int n_arg; 7572 xmlNodePtr node; /* a node */ 7573 int n_node; 7574 xmlNodePtr node2; /* unused */ 7575 int n_node2; 7576 7577 for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) { 7578 for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) { 7579 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 7580 for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) { 7581 mem_base = xmlMemBlocks(); 7582 ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0); 7583 arg = gen_char_ptr(n_arg, 1); 7584 node = gen_xmlNodePtr(n_node, 2); 7585 node2 = gen_xmlNodePtr(n_node2, 3); 7586 7587 ret_val = xmlShellCat(ctxt, arg, node, node2); 7588 desret_int(ret_val); 7589 call_tests++; 7590 des_xmlShellCtxtPtr(n_ctxt, ctxt, 0); 7591 des_char_ptr(n_arg, arg, 1); 7592 des_xmlNodePtr(n_node, node, 2); 7593 des_xmlNodePtr(n_node2, node2, 3); 7594 xmlResetLastError(); 7595 if (mem_base != xmlMemBlocks()) { 7596 printf("Leak of %d blocks found in xmlShellCat", 7597 xmlMemBlocks() - mem_base); 7598 test_ret++; 7599 printf(" %d", n_ctxt); 7600 printf(" %d", n_arg); 7601 printf(" %d", n_node); 7602 printf(" %d", n_node2); 7603 printf("\n"); 7604 } 7605 } 7606 } 7607 } 7608 } 7609 function_tests++; 7610 #endif 7611 7612 return(test_ret); 7613 } 7614 7615 7616 static int 7617 test_xmlShellDir(void) { 7618 int test_ret = 0; 7619 7620 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) 7621 int mem_base; 7622 int ret_val; 7623 xmlShellCtxtPtr ctxt; /* the shell context */ 7624 int n_ctxt; 7625 char * arg; /* unused */ 7626 int n_arg; 7627 xmlNodePtr node; /* a node */ 7628 int n_node; 7629 xmlNodePtr node2; /* unused */ 7630 int n_node2; 7631 7632 for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) { 7633 for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) { 7634 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 7635 for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) { 7636 mem_base = xmlMemBlocks(); 7637 ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0); 7638 arg = gen_char_ptr(n_arg, 1); 7639 node = gen_xmlNodePtr(n_node, 2); 7640 node2 = gen_xmlNodePtr(n_node2, 3); 7641 7642 ret_val = xmlShellDir(ctxt, arg, node, node2); 7643 desret_int(ret_val); 7644 call_tests++; 7645 des_xmlShellCtxtPtr(n_ctxt, ctxt, 0); 7646 des_char_ptr(n_arg, arg, 1); 7647 des_xmlNodePtr(n_node, node, 2); 7648 des_xmlNodePtr(n_node2, node2, 3); 7649 xmlResetLastError(); 7650 if (mem_base != xmlMemBlocks()) { 7651 printf("Leak of %d blocks found in xmlShellDir", 7652 xmlMemBlocks() - mem_base); 7653 test_ret++; 7654 printf(" %d", n_ctxt); 7655 printf(" %d", n_arg); 7656 printf(" %d", n_node); 7657 printf(" %d", n_node2); 7658 printf("\n"); 7659 } 7660 } 7661 } 7662 } 7663 } 7664 function_tests++; 7665 #endif 7666 7667 return(test_ret); 7668 } 7669 7670 7671 static int 7672 test_xmlShellDu(void) { 7673 int test_ret = 0; 7674 7675 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) 7676 int mem_base; 7677 int ret_val; 7678 xmlShellCtxtPtr ctxt; /* the shell context */ 7679 int n_ctxt; 7680 char * arg; /* unused */ 7681 int n_arg; 7682 xmlNodePtr tree; /* a node defining a subtree */ 7683 int n_tree; 7684 xmlNodePtr node2; /* unused */ 7685 int n_node2; 7686 7687 for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) { 7688 for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) { 7689 for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) { 7690 for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) { 7691 mem_base = xmlMemBlocks(); 7692 ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0); 7693 arg = gen_char_ptr(n_arg, 1); 7694 tree = gen_xmlNodePtr(n_tree, 2); 7695 node2 = gen_xmlNodePtr(n_node2, 3); 7696 7697 ret_val = xmlShellDu(ctxt, arg, tree, node2); 7698 desret_int(ret_val); 7699 call_tests++; 7700 des_xmlShellCtxtPtr(n_ctxt, ctxt, 0); 7701 des_char_ptr(n_arg, arg, 1); 7702 des_xmlNodePtr(n_tree, tree, 2); 7703 des_xmlNodePtr(n_node2, node2, 3); 7704 xmlResetLastError(); 7705 if (mem_base != xmlMemBlocks()) { 7706 printf("Leak of %d blocks found in xmlShellDu", 7707 xmlMemBlocks() - mem_base); 7708 test_ret++; 7709 printf(" %d", n_ctxt); 7710 printf(" %d", n_arg); 7711 printf(" %d", n_tree); 7712 printf(" %d", n_node2); 7713 printf("\n"); 7714 } 7715 } 7716 } 7717 } 7718 } 7719 function_tests++; 7720 #endif 7721 7722 return(test_ret); 7723 } 7724 7725 7726 static int 7727 test_xmlShellList(void) { 7728 int test_ret = 0; 7729 7730 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) 7731 int mem_base; 7732 int ret_val; 7733 xmlShellCtxtPtr ctxt; /* the shell context */ 7734 int n_ctxt; 7735 char * arg; /* unused */ 7736 int n_arg; 7737 xmlNodePtr node; /* a node */ 7738 int n_node; 7739 xmlNodePtr node2; /* unused */ 7740 int n_node2; 7741 7742 for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) { 7743 for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) { 7744 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 7745 for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) { 7746 mem_base = xmlMemBlocks(); 7747 ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0); 7748 arg = gen_char_ptr(n_arg, 1); 7749 node = gen_xmlNodePtr(n_node, 2); 7750 node2 = gen_xmlNodePtr(n_node2, 3); 7751 7752 ret_val = xmlShellList(ctxt, arg, node, node2); 7753 desret_int(ret_val); 7754 call_tests++; 7755 des_xmlShellCtxtPtr(n_ctxt, ctxt, 0); 7756 des_char_ptr(n_arg, arg, 1); 7757 des_xmlNodePtr(n_node, node, 2); 7758 des_xmlNodePtr(n_node2, node2, 3); 7759 xmlResetLastError(); 7760 if (mem_base != xmlMemBlocks()) { 7761 printf("Leak of %d blocks found in xmlShellList", 7762 xmlMemBlocks() - mem_base); 7763 test_ret++; 7764 printf(" %d", n_ctxt); 7765 printf(" %d", n_arg); 7766 printf(" %d", n_node); 7767 printf(" %d", n_node2); 7768 printf("\n"); 7769 } 7770 } 7771 } 7772 } 7773 } 7774 function_tests++; 7775 #endif 7776 7777 return(test_ret); 7778 } 7779 7780 7781 static int 7782 test_xmlShellLoad(void) { 7783 int test_ret = 0; 7784 7785 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) 7786 int mem_base; 7787 int ret_val; 7788 xmlShellCtxtPtr ctxt; /* the shell context */ 7789 int n_ctxt; 7790 char * filename; /* the file name */ 7791 int n_filename; 7792 xmlNodePtr node; /* unused */ 7793 int n_node; 7794 xmlNodePtr node2; /* unused */ 7795 int n_node2; 7796 7797 for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) { 7798 for (n_filename = 0;n_filename < gen_nb_char_ptr;n_filename++) { 7799 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 7800 for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) { 7801 mem_base = xmlMemBlocks(); 7802 ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0); 7803 filename = gen_char_ptr(n_filename, 1); 7804 node = gen_xmlNodePtr(n_node, 2); 7805 node2 = gen_xmlNodePtr(n_node2, 3); 7806 7807 ret_val = xmlShellLoad(ctxt, filename, node, node2); 7808 desret_int(ret_val); 7809 call_tests++; 7810 des_xmlShellCtxtPtr(n_ctxt, ctxt, 0); 7811 des_char_ptr(n_filename, filename, 1); 7812 des_xmlNodePtr(n_node, node, 2); 7813 des_xmlNodePtr(n_node2, node2, 3); 7814 xmlResetLastError(); 7815 if (mem_base != xmlMemBlocks()) { 7816 printf("Leak of %d blocks found in xmlShellLoad", 7817 xmlMemBlocks() - mem_base); 7818 test_ret++; 7819 printf(" %d", n_ctxt); 7820 printf(" %d", n_filename); 7821 printf(" %d", n_node); 7822 printf(" %d", n_node2); 7823 printf("\n"); 7824 } 7825 } 7826 } 7827 } 7828 } 7829 function_tests++; 7830 #endif 7831 7832 return(test_ret); 7833 } 7834 7835 7836 static int 7837 test_xmlShellPrintXPathResult(void) { 7838 int test_ret = 0; 7839 7840 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) 7841 int mem_base; 7842 xmlXPathObjectPtr list; /* a valid result generated by an xpath evaluation */ 7843 int n_list; 7844 7845 for (n_list = 0;n_list < gen_nb_xmlXPathObjectPtr;n_list++) { 7846 mem_base = xmlMemBlocks(); 7847 list = gen_xmlXPathObjectPtr(n_list, 0); 7848 7849 xmlShellPrintXPathResult(list); 7850 call_tests++; 7851 des_xmlXPathObjectPtr(n_list, list, 0); 7852 xmlResetLastError(); 7853 if (mem_base != xmlMemBlocks()) { 7854 printf("Leak of %d blocks found in xmlShellPrintXPathResult", 7855 xmlMemBlocks() - mem_base); 7856 test_ret++; 7857 printf(" %d", n_list); 7858 printf("\n"); 7859 } 7860 } 7861 function_tests++; 7862 #endif 7863 7864 return(test_ret); 7865 } 7866 7867 7868 static int 7869 test_xmlShellPwd(void) { 7870 int test_ret = 0; 7871 7872 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) 7873 int mem_base; 7874 int ret_val; 7875 xmlShellCtxtPtr ctxt; /* the shell context */ 7876 int n_ctxt; 7877 char * buffer; /* the output buffer */ 7878 int n_buffer; 7879 xmlNodePtr node; /* a node */ 7880 int n_node; 7881 xmlNodePtr node2; /* unused */ 7882 int n_node2; 7883 7884 for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) { 7885 for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) { 7886 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 7887 for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) { 7888 mem_base = xmlMemBlocks(); 7889 ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0); 7890 buffer = gen_char_ptr(n_buffer, 1); 7891 node = gen_xmlNodePtr(n_node, 2); 7892 node2 = gen_xmlNodePtr(n_node2, 3); 7893 7894 ret_val = xmlShellPwd(ctxt, buffer, node, node2); 7895 desret_int(ret_val); 7896 call_tests++; 7897 des_xmlShellCtxtPtr(n_ctxt, ctxt, 0); 7898 des_char_ptr(n_buffer, buffer, 1); 7899 des_xmlNodePtr(n_node, node, 2); 7900 des_xmlNodePtr(n_node2, node2, 3); 7901 xmlResetLastError(); 7902 if (mem_base != xmlMemBlocks()) { 7903 printf("Leak of %d blocks found in xmlShellPwd", 7904 xmlMemBlocks() - mem_base); 7905 test_ret++; 7906 printf(" %d", n_ctxt); 7907 printf(" %d", n_buffer); 7908 printf(" %d", n_node); 7909 printf(" %d", n_node2); 7910 printf("\n"); 7911 } 7912 } 7913 } 7914 } 7915 } 7916 function_tests++; 7917 #endif 7918 7919 return(test_ret); 7920 } 7921 7922 7923 static int 7924 test_xmlShellSave(void) { 7925 int test_ret = 0; 7926 7927 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 7928 int mem_base; 7929 int ret_val; 7930 xmlShellCtxtPtr ctxt; /* the shell context */ 7931 int n_ctxt; 7932 char * filename; /* the file name (optional) */ 7933 int n_filename; 7934 xmlNodePtr node; /* unused */ 7935 int n_node; 7936 xmlNodePtr node2; /* unused */ 7937 int n_node2; 7938 7939 for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) { 7940 for (n_filename = 0;n_filename < gen_nb_char_ptr;n_filename++) { 7941 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 7942 for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) { 7943 mem_base = xmlMemBlocks(); 7944 ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0); 7945 filename = gen_char_ptr(n_filename, 1); 7946 node = gen_xmlNodePtr(n_node, 2); 7947 node2 = gen_xmlNodePtr(n_node2, 3); 7948 7949 ret_val = xmlShellSave(ctxt, filename, node, node2); 7950 desret_int(ret_val); 7951 call_tests++; 7952 des_xmlShellCtxtPtr(n_ctxt, ctxt, 0); 7953 des_char_ptr(n_filename, filename, 1); 7954 des_xmlNodePtr(n_node, node, 2); 7955 des_xmlNodePtr(n_node2, node2, 3); 7956 xmlResetLastError(); 7957 if (mem_base != xmlMemBlocks()) { 7958 printf("Leak of %d blocks found in xmlShellSave", 7959 xmlMemBlocks() - mem_base); 7960 test_ret++; 7961 printf(" %d", n_ctxt); 7962 printf(" %d", n_filename); 7963 printf(" %d", n_node); 7964 printf(" %d", n_node2); 7965 printf("\n"); 7966 } 7967 } 7968 } 7969 } 7970 } 7971 function_tests++; 7972 #endif 7973 7974 return(test_ret); 7975 } 7976 7977 7978 static int 7979 test_xmlShellValidate(void) { 7980 int test_ret = 0; 7981 7982 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_VALID_ENABLED) 7983 int mem_base; 7984 int ret_val; 7985 xmlShellCtxtPtr ctxt; /* the shell context */ 7986 int n_ctxt; 7987 char * dtd; /* the DTD URI (optional) */ 7988 int n_dtd; 7989 xmlNodePtr node; /* unused */ 7990 int n_node; 7991 xmlNodePtr node2; /* unused */ 7992 int n_node2; 7993 7994 for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) { 7995 for (n_dtd = 0;n_dtd < gen_nb_char_ptr;n_dtd++) { 7996 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 7997 for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) { 7998 mem_base = xmlMemBlocks(); 7999 ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0); 8000 dtd = gen_char_ptr(n_dtd, 1); 8001 node = gen_xmlNodePtr(n_node, 2); 8002 node2 = gen_xmlNodePtr(n_node2, 3); 8003 8004 ret_val = xmlShellValidate(ctxt, dtd, node, node2); 8005 desret_int(ret_val); 8006 call_tests++; 8007 des_xmlShellCtxtPtr(n_ctxt, ctxt, 0); 8008 des_char_ptr(n_dtd, dtd, 1); 8009 des_xmlNodePtr(n_node, node, 2); 8010 des_xmlNodePtr(n_node2, node2, 3); 8011 xmlResetLastError(); 8012 if (mem_base != xmlMemBlocks()) { 8013 printf("Leak of %d blocks found in xmlShellValidate", 8014 xmlMemBlocks() - mem_base); 8015 test_ret++; 8016 printf(" %d", n_ctxt); 8017 printf(" %d", n_dtd); 8018 printf(" %d", n_node); 8019 printf(" %d", n_node2); 8020 printf("\n"); 8021 } 8022 } 8023 } 8024 } 8025 } 8026 function_tests++; 8027 #endif 8028 8029 return(test_ret); 8030 } 8031 8032 8033 static int 8034 test_xmlShellWrite(void) { 8035 int test_ret = 0; 8036 8037 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 8038 int mem_base; 8039 int ret_val; 8040 xmlShellCtxtPtr ctxt; /* the shell context */ 8041 int n_ctxt; 8042 char * filename; /* the file name */ 8043 int n_filename; 8044 xmlNodePtr node; /* a node in the tree */ 8045 int n_node; 8046 xmlNodePtr node2; /* unused */ 8047 int n_node2; 8048 8049 for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) { 8050 for (n_filename = 0;n_filename < gen_nb_char_ptr;n_filename++) { 8051 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 8052 for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) { 8053 mem_base = xmlMemBlocks(); 8054 ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0); 8055 filename = gen_char_ptr(n_filename, 1); 8056 node = gen_xmlNodePtr(n_node, 2); 8057 node2 = gen_xmlNodePtr(n_node2, 3); 8058 8059 ret_val = xmlShellWrite(ctxt, filename, node, node2); 8060 desret_int(ret_val); 8061 call_tests++; 8062 des_xmlShellCtxtPtr(n_ctxt, ctxt, 0); 8063 des_char_ptr(n_filename, filename, 1); 8064 des_xmlNodePtr(n_node, node, 2); 8065 des_xmlNodePtr(n_node2, node2, 3); 8066 xmlResetLastError(); 8067 if (mem_base != xmlMemBlocks()) { 8068 printf("Leak of %d blocks found in xmlShellWrite", 8069 xmlMemBlocks() - mem_base); 8070 test_ret++; 8071 printf(" %d", n_ctxt); 8072 printf(" %d", n_filename); 8073 printf(" %d", n_node); 8074 printf(" %d", n_node2); 8075 printf("\n"); 8076 } 8077 } 8078 } 8079 } 8080 } 8081 function_tests++; 8082 #endif 8083 8084 return(test_ret); 8085 } 8086 8087 static int 8088 test_debugXML(void) { 8089 int test_ret = 0; 8090 8091 if (quiet == 0) printf("Testing debugXML : 25 of 28 functions ...\n"); 8092 test_ret += test_xmlBoolToText(); 8093 test_ret += test_xmlDebugCheckDocument(); 8094 test_ret += test_xmlDebugDumpAttr(); 8095 test_ret += test_xmlDebugDumpAttrList(); 8096 test_ret += test_xmlDebugDumpDTD(); 8097 test_ret += test_xmlDebugDumpDocument(); 8098 test_ret += test_xmlDebugDumpDocumentHead(); 8099 test_ret += test_xmlDebugDumpEntities(); 8100 test_ret += test_xmlDebugDumpNode(); 8101 test_ret += test_xmlDebugDumpNodeList(); 8102 test_ret += test_xmlDebugDumpOneNode(); 8103 test_ret += test_xmlDebugDumpString(); 8104 test_ret += test_xmlLsCountNode(); 8105 test_ret += test_xmlLsOneNode(); 8106 test_ret += test_xmlShell(); 8107 test_ret += test_xmlShellBase(); 8108 test_ret += test_xmlShellCat(); 8109 test_ret += test_xmlShellDir(); 8110 test_ret += test_xmlShellDu(); 8111 test_ret += test_xmlShellList(); 8112 test_ret += test_xmlShellLoad(); 8113 test_ret += test_xmlShellPrintXPathResult(); 8114 test_ret += test_xmlShellPwd(); 8115 test_ret += test_xmlShellSave(); 8116 test_ret += test_xmlShellValidate(); 8117 test_ret += test_xmlShellWrite(); 8118 8119 if (test_ret != 0) 8120 printf("Module debugXML: %d errors\n", test_ret); 8121 return(test_ret); 8122 } 8123 8124 static int 8125 test_xmlDictCleanup(void) { 8126 int test_ret = 0; 8127 8128 int mem_base; 8129 8130 mem_base = xmlMemBlocks(); 8131 8132 xmlDictCleanup(); 8133 call_tests++; 8134 xmlResetLastError(); 8135 if (mem_base != xmlMemBlocks()) { 8136 printf("Leak of %d blocks found in xmlDictCleanup", 8137 xmlMemBlocks() - mem_base); 8138 test_ret++; 8139 printf("\n"); 8140 } 8141 function_tests++; 8142 8143 return(test_ret); 8144 } 8145 8146 8147 static int 8148 test_xmlDictCreate(void) { 8149 int test_ret = 0; 8150 8151 int mem_base; 8152 xmlDictPtr ret_val; 8153 8154 mem_base = xmlMemBlocks(); 8155 8156 ret_val = xmlDictCreate(); 8157 desret_xmlDictPtr(ret_val); 8158 call_tests++; 8159 xmlResetLastError(); 8160 if (mem_base != xmlMemBlocks()) { 8161 printf("Leak of %d blocks found in xmlDictCreate", 8162 xmlMemBlocks() - mem_base); 8163 test_ret++; 8164 printf("\n"); 8165 } 8166 function_tests++; 8167 8168 return(test_ret); 8169 } 8170 8171 8172 static int 8173 test_xmlDictCreateSub(void) { 8174 int test_ret = 0; 8175 8176 int mem_base; 8177 xmlDictPtr ret_val; 8178 xmlDictPtr sub; /* an existing dictionary */ 8179 int n_sub; 8180 8181 for (n_sub = 0;n_sub < gen_nb_xmlDictPtr;n_sub++) { 8182 mem_base = xmlMemBlocks(); 8183 sub = gen_xmlDictPtr(n_sub, 0); 8184 8185 ret_val = xmlDictCreateSub(sub); 8186 desret_xmlDictPtr(ret_val); 8187 call_tests++; 8188 des_xmlDictPtr(n_sub, sub, 0); 8189 xmlResetLastError(); 8190 if (mem_base != xmlMemBlocks()) { 8191 printf("Leak of %d blocks found in xmlDictCreateSub", 8192 xmlMemBlocks() - mem_base); 8193 test_ret++; 8194 printf(" %d", n_sub); 8195 printf("\n"); 8196 } 8197 } 8198 function_tests++; 8199 8200 return(test_ret); 8201 } 8202 8203 8204 static int 8205 test_xmlDictExists(void) { 8206 int test_ret = 0; 8207 8208 int mem_base; 8209 const xmlChar * ret_val; 8210 xmlDictPtr dict; /* the dictionary */ 8211 int n_dict; 8212 xmlChar * name; /* the name of the userdata */ 8213 int n_name; 8214 int len; /* the length of the name, if -1 it is recomputed */ 8215 int n_len; 8216 8217 for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) { 8218 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 8219 for (n_len = 0;n_len < gen_nb_int;n_len++) { 8220 mem_base = xmlMemBlocks(); 8221 dict = gen_xmlDictPtr(n_dict, 0); 8222 name = gen_const_xmlChar_ptr(n_name, 1); 8223 len = gen_int(n_len, 2); 8224 8225 ret_val = xmlDictExists(dict, (const xmlChar *)name, len); 8226 desret_const_xmlChar_ptr(ret_val); 8227 call_tests++; 8228 des_xmlDictPtr(n_dict, dict, 0); 8229 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 8230 des_int(n_len, len, 2); 8231 xmlResetLastError(); 8232 if (mem_base != xmlMemBlocks()) { 8233 printf("Leak of %d blocks found in xmlDictExists", 8234 xmlMemBlocks() - mem_base); 8235 test_ret++; 8236 printf(" %d", n_dict); 8237 printf(" %d", n_name); 8238 printf(" %d", n_len); 8239 printf("\n"); 8240 } 8241 } 8242 } 8243 } 8244 function_tests++; 8245 8246 return(test_ret); 8247 } 8248 8249 8250 static int 8251 test_xmlDictGetUsage(void) { 8252 int test_ret = 0; 8253 8254 8255 /* missing type support */ 8256 return(test_ret); 8257 } 8258 8259 8260 static int 8261 test_xmlDictLookup(void) { 8262 int test_ret = 0; 8263 8264 int mem_base; 8265 const xmlChar * ret_val; 8266 xmlDictPtr dict; /* the dictionary */ 8267 int n_dict; 8268 xmlChar * name; /* the name of the userdata */ 8269 int n_name; 8270 int len; /* the length of the name, if -1 it is recomputed */ 8271 int n_len; 8272 8273 for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) { 8274 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 8275 for (n_len = 0;n_len < gen_nb_int;n_len++) { 8276 mem_base = xmlMemBlocks(); 8277 dict = gen_xmlDictPtr(n_dict, 0); 8278 name = gen_const_xmlChar_ptr(n_name, 1); 8279 len = gen_int(n_len, 2); 8280 8281 ret_val = xmlDictLookup(dict, (const xmlChar *)name, len); 8282 desret_const_xmlChar_ptr(ret_val); 8283 call_tests++; 8284 des_xmlDictPtr(n_dict, dict, 0); 8285 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 8286 des_int(n_len, len, 2); 8287 xmlResetLastError(); 8288 if (mem_base != xmlMemBlocks()) { 8289 printf("Leak of %d blocks found in xmlDictLookup", 8290 xmlMemBlocks() - mem_base); 8291 test_ret++; 8292 printf(" %d", n_dict); 8293 printf(" %d", n_name); 8294 printf(" %d", n_len); 8295 printf("\n"); 8296 } 8297 } 8298 } 8299 } 8300 function_tests++; 8301 8302 return(test_ret); 8303 } 8304 8305 8306 static int 8307 test_xmlDictOwns(void) { 8308 int test_ret = 0; 8309 8310 int mem_base; 8311 int ret_val; 8312 xmlDictPtr dict; /* the dictionary */ 8313 int n_dict; 8314 xmlChar * str; /* the string */ 8315 int n_str; 8316 8317 for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) { 8318 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 8319 mem_base = xmlMemBlocks(); 8320 dict = gen_xmlDictPtr(n_dict, 0); 8321 str = gen_const_xmlChar_ptr(n_str, 1); 8322 8323 ret_val = xmlDictOwns(dict, (const xmlChar *)str); 8324 desret_int(ret_val); 8325 call_tests++; 8326 des_xmlDictPtr(n_dict, dict, 0); 8327 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1); 8328 xmlResetLastError(); 8329 if (mem_base != xmlMemBlocks()) { 8330 printf("Leak of %d blocks found in xmlDictOwns", 8331 xmlMemBlocks() - mem_base); 8332 test_ret++; 8333 printf(" %d", n_dict); 8334 printf(" %d", n_str); 8335 printf("\n"); 8336 } 8337 } 8338 } 8339 function_tests++; 8340 8341 return(test_ret); 8342 } 8343 8344 8345 static int 8346 test_xmlDictQLookup(void) { 8347 int test_ret = 0; 8348 8349 int mem_base; 8350 const xmlChar * ret_val; 8351 xmlDictPtr dict; /* the dictionary */ 8352 int n_dict; 8353 xmlChar * prefix; /* the prefix */ 8354 int n_prefix; 8355 xmlChar * name; /* the name */ 8356 int n_name; 8357 8358 for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) { 8359 for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) { 8360 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 8361 mem_base = xmlMemBlocks(); 8362 dict = gen_xmlDictPtr(n_dict, 0); 8363 prefix = gen_const_xmlChar_ptr(n_prefix, 1); 8364 name = gen_const_xmlChar_ptr(n_name, 2); 8365 8366 ret_val = xmlDictQLookup(dict, (const xmlChar *)prefix, (const xmlChar *)name); 8367 desret_const_xmlChar_ptr(ret_val); 8368 call_tests++; 8369 des_xmlDictPtr(n_dict, dict, 0); 8370 des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1); 8371 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 8372 xmlResetLastError(); 8373 if (mem_base != xmlMemBlocks()) { 8374 printf("Leak of %d blocks found in xmlDictQLookup", 8375 xmlMemBlocks() - mem_base); 8376 test_ret++; 8377 printf(" %d", n_dict); 8378 printf(" %d", n_prefix); 8379 printf(" %d", n_name); 8380 printf("\n"); 8381 } 8382 } 8383 } 8384 } 8385 function_tests++; 8386 8387 return(test_ret); 8388 } 8389 8390 8391 static int 8392 test_xmlDictReference(void) { 8393 int test_ret = 0; 8394 8395 int mem_base; 8396 int ret_val; 8397 xmlDictPtr dict; /* the dictionary */ 8398 int n_dict; 8399 8400 for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) { 8401 mem_base = xmlMemBlocks(); 8402 dict = gen_xmlDictPtr(n_dict, 0); 8403 8404 ret_val = xmlDictReference(dict); 8405 xmlDictFree(dict); 8406 desret_int(ret_val); 8407 call_tests++; 8408 des_xmlDictPtr(n_dict, dict, 0); 8409 xmlResetLastError(); 8410 if (mem_base != xmlMemBlocks()) { 8411 printf("Leak of %d blocks found in xmlDictReference", 8412 xmlMemBlocks() - mem_base); 8413 test_ret++; 8414 printf(" %d", n_dict); 8415 printf("\n"); 8416 } 8417 } 8418 function_tests++; 8419 8420 return(test_ret); 8421 } 8422 8423 8424 static int 8425 test_xmlDictSetLimit(void) { 8426 int test_ret = 0; 8427 8428 8429 /* missing type support */ 8430 return(test_ret); 8431 } 8432 8433 8434 static int 8435 test_xmlDictSize(void) { 8436 int test_ret = 0; 8437 8438 int mem_base; 8439 int ret_val; 8440 xmlDictPtr dict; /* the dictionary */ 8441 int n_dict; 8442 8443 for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) { 8444 mem_base = xmlMemBlocks(); 8445 dict = gen_xmlDictPtr(n_dict, 0); 8446 8447 ret_val = xmlDictSize(dict); 8448 desret_int(ret_val); 8449 call_tests++; 8450 des_xmlDictPtr(n_dict, dict, 0); 8451 xmlResetLastError(); 8452 if (mem_base != xmlMemBlocks()) { 8453 printf("Leak of %d blocks found in xmlDictSize", 8454 xmlMemBlocks() - mem_base); 8455 test_ret++; 8456 printf(" %d", n_dict); 8457 printf("\n"); 8458 } 8459 } 8460 function_tests++; 8461 8462 return(test_ret); 8463 } 8464 8465 8466 static int 8467 test_xmlInitializeDict(void) { 8468 int test_ret = 0; 8469 8470 int mem_base; 8471 int ret_val; 8472 8473 mem_base = xmlMemBlocks(); 8474 8475 ret_val = xmlInitializeDict(); 8476 desret_int(ret_val); 8477 call_tests++; 8478 xmlResetLastError(); 8479 if (mem_base != xmlMemBlocks()) { 8480 printf("Leak of %d blocks found in xmlInitializeDict", 8481 xmlMemBlocks() - mem_base); 8482 test_ret++; 8483 printf("\n"); 8484 } 8485 function_tests++; 8486 8487 return(test_ret); 8488 } 8489 8490 static int 8491 test_dict(void) { 8492 int test_ret = 0; 8493 8494 if (quiet == 0) printf("Testing dict : 10 of 13 functions ...\n"); 8495 test_ret += test_xmlDictCleanup(); 8496 test_ret += test_xmlDictCreate(); 8497 test_ret += test_xmlDictCreateSub(); 8498 test_ret += test_xmlDictExists(); 8499 test_ret += test_xmlDictGetUsage(); 8500 test_ret += test_xmlDictLookup(); 8501 test_ret += test_xmlDictOwns(); 8502 test_ret += test_xmlDictQLookup(); 8503 test_ret += test_xmlDictReference(); 8504 test_ret += test_xmlDictSetLimit(); 8505 test_ret += test_xmlDictSize(); 8506 test_ret += test_xmlInitializeDict(); 8507 8508 if (test_ret != 0) 8509 printf("Module dict: %d errors\n", test_ret); 8510 return(test_ret); 8511 } 8512 8513 static int 8514 test_UTF8Toisolat1(void) { 8515 int test_ret = 0; 8516 8517 #if defined(LIBXML_OUTPUT_ENABLED) 8518 #ifdef LIBXML_OUTPUT_ENABLED 8519 int mem_base; 8520 int ret_val; 8521 unsigned char * out; /* a pointer to an array of bytes to store the result */ 8522 int n_out; 8523 int * outlen; /* the length of @out */ 8524 int n_outlen; 8525 unsigned char * in; /* a pointer to an array of UTF-8 chars */ 8526 int n_in; 8527 int * inlen; /* the length of @in */ 8528 int n_inlen; 8529 8530 for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) { 8531 for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) { 8532 for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) { 8533 for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) { 8534 mem_base = xmlMemBlocks(); 8535 out = gen_unsigned_char_ptr(n_out, 0); 8536 outlen = gen_int_ptr(n_outlen, 1); 8537 in = gen_const_unsigned_char_ptr(n_in, 2); 8538 inlen = gen_int_ptr(n_inlen, 3); 8539 8540 ret_val = UTF8Toisolat1(out, outlen, (const unsigned char *)in, inlen); 8541 desret_int(ret_val); 8542 call_tests++; 8543 des_unsigned_char_ptr(n_out, out, 0); 8544 des_int_ptr(n_outlen, outlen, 1); 8545 des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2); 8546 des_int_ptr(n_inlen, inlen, 3); 8547 xmlResetLastError(); 8548 if (mem_base != xmlMemBlocks()) { 8549 printf("Leak of %d blocks found in UTF8Toisolat1", 8550 xmlMemBlocks() - mem_base); 8551 test_ret++; 8552 printf(" %d", n_out); 8553 printf(" %d", n_outlen); 8554 printf(" %d", n_in); 8555 printf(" %d", n_inlen); 8556 printf("\n"); 8557 } 8558 } 8559 } 8560 } 8561 } 8562 function_tests++; 8563 #endif 8564 #endif 8565 8566 return(test_ret); 8567 } 8568 8569 8570 static int 8571 test_isolat1ToUTF8(void) { 8572 int test_ret = 0; 8573 8574 int mem_base; 8575 int ret_val; 8576 unsigned char * out; /* a pointer to an array of bytes to store the result */ 8577 int n_out; 8578 int * outlen; /* the length of @out */ 8579 int n_outlen; 8580 unsigned char * in; /* a pointer to an array of ISO Latin 1 chars */ 8581 int n_in; 8582 int * inlen; /* the length of @in */ 8583 int n_inlen; 8584 8585 for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) { 8586 for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) { 8587 for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) { 8588 for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) { 8589 mem_base = xmlMemBlocks(); 8590 out = gen_unsigned_char_ptr(n_out, 0); 8591 outlen = gen_int_ptr(n_outlen, 1); 8592 in = gen_const_unsigned_char_ptr(n_in, 2); 8593 inlen = gen_int_ptr(n_inlen, 3); 8594 8595 ret_val = isolat1ToUTF8(out, outlen, (const unsigned char *)in, inlen); 8596 desret_int(ret_val); 8597 call_tests++; 8598 des_unsigned_char_ptr(n_out, out, 0); 8599 des_int_ptr(n_outlen, outlen, 1); 8600 des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2); 8601 des_int_ptr(n_inlen, inlen, 3); 8602 xmlResetLastError(); 8603 if (mem_base != xmlMemBlocks()) { 8604 printf("Leak of %d blocks found in isolat1ToUTF8", 8605 xmlMemBlocks() - mem_base); 8606 test_ret++; 8607 printf(" %d", n_out); 8608 printf(" %d", n_outlen); 8609 printf(" %d", n_in); 8610 printf(" %d", n_inlen); 8611 printf("\n"); 8612 } 8613 } 8614 } 8615 } 8616 } 8617 function_tests++; 8618 8619 return(test_ret); 8620 } 8621 8622 8623 static int 8624 test_xmlAddEncodingAlias(void) { 8625 int test_ret = 0; 8626 8627 int ret_val; 8628 char * name; /* the encoding name as parsed, in UTF-8 format (ASCII actually) */ 8629 int n_name; 8630 char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */ 8631 int n_alias; 8632 8633 for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) { 8634 for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) { 8635 name = gen_const_char_ptr(n_name, 0); 8636 alias = gen_const_char_ptr(n_alias, 1); 8637 8638 ret_val = xmlAddEncodingAlias((const char *)name, (const char *)alias); 8639 desret_int(ret_val); 8640 call_tests++; 8641 des_const_char_ptr(n_name, (const char *)name, 0); 8642 des_const_char_ptr(n_alias, (const char *)alias, 1); 8643 xmlResetLastError(); 8644 } 8645 } 8646 function_tests++; 8647 8648 return(test_ret); 8649 } 8650 8651 8652 #define gen_nb_xmlCharEncodingHandler_ptr 1 8653 static xmlCharEncodingHandler * gen_xmlCharEncodingHandler_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 8654 return(NULL); 8655 } 8656 static void des_xmlCharEncodingHandler_ptr(int no ATTRIBUTE_UNUSED, xmlCharEncodingHandler * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 8657 } 8658 8659 static int 8660 test_xmlCharEncCloseFunc(void) { 8661 int test_ret = 0; 8662 8663 int mem_base; 8664 int ret_val; 8665 xmlCharEncodingHandler * handler; /* char enconding transformation data structure */ 8666 int n_handler; 8667 8668 for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) { 8669 mem_base = xmlMemBlocks(); 8670 handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0); 8671 8672 ret_val = xmlCharEncCloseFunc(handler); 8673 desret_int(ret_val); 8674 call_tests++; 8675 des_xmlCharEncodingHandler_ptr(n_handler, handler, 0); 8676 xmlResetLastError(); 8677 if (mem_base != xmlMemBlocks()) { 8678 printf("Leak of %d blocks found in xmlCharEncCloseFunc", 8679 xmlMemBlocks() - mem_base); 8680 test_ret++; 8681 printf(" %d", n_handler); 8682 printf("\n"); 8683 } 8684 } 8685 function_tests++; 8686 8687 return(test_ret); 8688 } 8689 8690 8691 static int 8692 test_xmlCharEncFirstLine(void) { 8693 int test_ret = 0; 8694 8695 int mem_base; 8696 int ret_val; 8697 xmlCharEncodingHandler * handler; /* char enconding transformation data structure */ 8698 int n_handler; 8699 xmlBufferPtr out; /* an xmlBuffer for the output. */ 8700 int n_out; 8701 xmlBufferPtr in; /* an xmlBuffer for the input */ 8702 int n_in; 8703 8704 for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) { 8705 for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) { 8706 for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) { 8707 mem_base = xmlMemBlocks(); 8708 handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0); 8709 out = gen_xmlBufferPtr(n_out, 1); 8710 in = gen_xmlBufferPtr(n_in, 2); 8711 8712 ret_val = xmlCharEncFirstLine(handler, out, in); 8713 desret_int(ret_val); 8714 call_tests++; 8715 des_xmlCharEncodingHandler_ptr(n_handler, handler, 0); 8716 des_xmlBufferPtr(n_out, out, 1); 8717 des_xmlBufferPtr(n_in, in, 2); 8718 xmlResetLastError(); 8719 if (mem_base != xmlMemBlocks()) { 8720 printf("Leak of %d blocks found in xmlCharEncFirstLine", 8721 xmlMemBlocks() - mem_base); 8722 test_ret++; 8723 printf(" %d", n_handler); 8724 printf(" %d", n_out); 8725 printf(" %d", n_in); 8726 printf("\n"); 8727 } 8728 } 8729 } 8730 } 8731 function_tests++; 8732 8733 return(test_ret); 8734 } 8735 8736 8737 static int 8738 test_xmlCharEncInFunc(void) { 8739 int test_ret = 0; 8740 8741 int mem_base; 8742 int ret_val; 8743 xmlCharEncodingHandler * handler; /* char encoding transformation data structure */ 8744 int n_handler; 8745 xmlBufferPtr out; /* an xmlBuffer for the output. */ 8746 int n_out; 8747 xmlBufferPtr in; /* an xmlBuffer for the input */ 8748 int n_in; 8749 8750 for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) { 8751 for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) { 8752 for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) { 8753 mem_base = xmlMemBlocks(); 8754 handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0); 8755 out = gen_xmlBufferPtr(n_out, 1); 8756 in = gen_xmlBufferPtr(n_in, 2); 8757 8758 ret_val = xmlCharEncInFunc(handler, out, in); 8759 desret_int(ret_val); 8760 call_tests++; 8761 des_xmlCharEncodingHandler_ptr(n_handler, handler, 0); 8762 des_xmlBufferPtr(n_out, out, 1); 8763 des_xmlBufferPtr(n_in, in, 2); 8764 xmlResetLastError(); 8765 if (mem_base != xmlMemBlocks()) { 8766 printf("Leak of %d blocks found in xmlCharEncInFunc", 8767 xmlMemBlocks() - mem_base); 8768 test_ret++; 8769 printf(" %d", n_handler); 8770 printf(" %d", n_out); 8771 printf(" %d", n_in); 8772 printf("\n"); 8773 } 8774 } 8775 } 8776 } 8777 function_tests++; 8778 8779 return(test_ret); 8780 } 8781 8782 8783 static int 8784 test_xmlCharEncOutFunc(void) { 8785 int test_ret = 0; 8786 8787 int mem_base; 8788 int ret_val; 8789 xmlCharEncodingHandler * handler; /* char enconding transformation data structure */ 8790 int n_handler; 8791 xmlBufferPtr out; /* an xmlBuffer for the output. */ 8792 int n_out; 8793 xmlBufferPtr in; /* an xmlBuffer for the input */ 8794 int n_in; 8795 8796 for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) { 8797 for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) { 8798 for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) { 8799 mem_base = xmlMemBlocks(); 8800 handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0); 8801 out = gen_xmlBufferPtr(n_out, 1); 8802 in = gen_xmlBufferPtr(n_in, 2); 8803 8804 ret_val = xmlCharEncOutFunc(handler, out, in); 8805 desret_int(ret_val); 8806 call_tests++; 8807 des_xmlCharEncodingHandler_ptr(n_handler, handler, 0); 8808 des_xmlBufferPtr(n_out, out, 1); 8809 des_xmlBufferPtr(n_in, in, 2); 8810 xmlResetLastError(); 8811 if (mem_base != xmlMemBlocks()) { 8812 printf("Leak of %d blocks found in xmlCharEncOutFunc", 8813 xmlMemBlocks() - mem_base); 8814 test_ret++; 8815 printf(" %d", n_handler); 8816 printf(" %d", n_out); 8817 printf(" %d", n_in); 8818 printf("\n"); 8819 } 8820 } 8821 } 8822 } 8823 function_tests++; 8824 8825 return(test_ret); 8826 } 8827 8828 8829 static int 8830 test_xmlCleanupCharEncodingHandlers(void) { 8831 int test_ret = 0; 8832 8833 8834 8835 xmlCleanupCharEncodingHandlers(); 8836 call_tests++; 8837 xmlResetLastError(); 8838 function_tests++; 8839 8840 return(test_ret); 8841 } 8842 8843 8844 static int 8845 test_xmlCleanupEncodingAliases(void) { 8846 int test_ret = 0; 8847 8848 int mem_base; 8849 8850 mem_base = xmlMemBlocks(); 8851 8852 xmlCleanupEncodingAliases(); 8853 call_tests++; 8854 xmlResetLastError(); 8855 if (mem_base != xmlMemBlocks()) { 8856 printf("Leak of %d blocks found in xmlCleanupEncodingAliases", 8857 xmlMemBlocks() - mem_base); 8858 test_ret++; 8859 printf("\n"); 8860 } 8861 function_tests++; 8862 8863 return(test_ret); 8864 } 8865 8866 8867 static int 8868 test_xmlDelEncodingAlias(void) { 8869 int test_ret = 0; 8870 8871 int mem_base; 8872 int ret_val; 8873 char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */ 8874 int n_alias; 8875 8876 for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) { 8877 mem_base = xmlMemBlocks(); 8878 alias = gen_const_char_ptr(n_alias, 0); 8879 8880 ret_val = xmlDelEncodingAlias((const char *)alias); 8881 desret_int(ret_val); 8882 call_tests++; 8883 des_const_char_ptr(n_alias, (const char *)alias, 0); 8884 xmlResetLastError(); 8885 if (mem_base != xmlMemBlocks()) { 8886 printf("Leak of %d blocks found in xmlDelEncodingAlias", 8887 xmlMemBlocks() - mem_base); 8888 test_ret++; 8889 printf(" %d", n_alias); 8890 printf("\n"); 8891 } 8892 } 8893 function_tests++; 8894 8895 return(test_ret); 8896 } 8897 8898 8899 static int 8900 test_xmlDetectCharEncoding(void) { 8901 int test_ret = 0; 8902 8903 int mem_base; 8904 xmlCharEncoding ret_val; 8905 unsigned char * in; /* a pointer to the first bytes of the XML entity, must be at least 2 bytes long (at least 4 if encoding is UTF4 variant). */ 8906 int n_in; 8907 int len; /* pointer to the length of the buffer */ 8908 int n_len; 8909 8910 for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) { 8911 for (n_len = 0;n_len < gen_nb_int;n_len++) { 8912 mem_base = xmlMemBlocks(); 8913 in = gen_const_unsigned_char_ptr(n_in, 0); 8914 len = gen_int(n_len, 1); 8915 8916 ret_val = xmlDetectCharEncoding((const unsigned char *)in, len); 8917 desret_xmlCharEncoding(ret_val); 8918 call_tests++; 8919 des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 0); 8920 des_int(n_len, len, 1); 8921 xmlResetLastError(); 8922 if (mem_base != xmlMemBlocks()) { 8923 printf("Leak of %d blocks found in xmlDetectCharEncoding", 8924 xmlMemBlocks() - mem_base); 8925 test_ret++; 8926 printf(" %d", n_in); 8927 printf(" %d", n_len); 8928 printf("\n"); 8929 } 8930 } 8931 } 8932 function_tests++; 8933 8934 return(test_ret); 8935 } 8936 8937 8938 static int 8939 test_xmlFindCharEncodingHandler(void) { 8940 int test_ret = 0; 8941 8942 8943 /* missing type support */ 8944 return(test_ret); 8945 } 8946 8947 8948 static int 8949 test_xmlGetCharEncodingHandler(void) { 8950 int test_ret = 0; 8951 8952 8953 /* missing type support */ 8954 return(test_ret); 8955 } 8956 8957 8958 static int 8959 test_xmlGetCharEncodingName(void) { 8960 int test_ret = 0; 8961 8962 int mem_base; 8963 const char * ret_val; 8964 xmlCharEncoding enc; /* the encoding */ 8965 int n_enc; 8966 8967 for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) { 8968 mem_base = xmlMemBlocks(); 8969 enc = gen_xmlCharEncoding(n_enc, 0); 8970 8971 ret_val = xmlGetCharEncodingName(enc); 8972 desret_const_char_ptr(ret_val); 8973 call_tests++; 8974 des_xmlCharEncoding(n_enc, enc, 0); 8975 xmlResetLastError(); 8976 if (mem_base != xmlMemBlocks()) { 8977 printf("Leak of %d blocks found in xmlGetCharEncodingName", 8978 xmlMemBlocks() - mem_base); 8979 test_ret++; 8980 printf(" %d", n_enc); 8981 printf("\n"); 8982 } 8983 } 8984 function_tests++; 8985 8986 return(test_ret); 8987 } 8988 8989 8990 static int 8991 test_xmlGetEncodingAlias(void) { 8992 int test_ret = 0; 8993 8994 int mem_base; 8995 const char * ret_val; 8996 char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */ 8997 int n_alias; 8998 8999 for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) { 9000 mem_base = xmlMemBlocks(); 9001 alias = gen_const_char_ptr(n_alias, 0); 9002 9003 ret_val = xmlGetEncodingAlias((const char *)alias); 9004 desret_const_char_ptr(ret_val); 9005 call_tests++; 9006 des_const_char_ptr(n_alias, (const char *)alias, 0); 9007 xmlResetLastError(); 9008 if (mem_base != xmlMemBlocks()) { 9009 printf("Leak of %d blocks found in xmlGetEncodingAlias", 9010 xmlMemBlocks() - mem_base); 9011 test_ret++; 9012 printf(" %d", n_alias); 9013 printf("\n"); 9014 } 9015 } 9016 function_tests++; 9017 9018 return(test_ret); 9019 } 9020 9021 9022 static int 9023 test_xmlInitCharEncodingHandlers(void) { 9024 int test_ret = 0; 9025 9026 9027 9028 xmlInitCharEncodingHandlers(); 9029 call_tests++; 9030 xmlResetLastError(); 9031 function_tests++; 9032 9033 return(test_ret); 9034 } 9035 9036 9037 static int 9038 test_xmlNewCharEncodingHandler(void) { 9039 int test_ret = 0; 9040 9041 9042 /* missing type support */ 9043 return(test_ret); 9044 } 9045 9046 9047 static int 9048 test_xmlParseCharEncoding(void) { 9049 int test_ret = 0; 9050 9051 int mem_base; 9052 xmlCharEncoding ret_val; 9053 char * name; /* the encoding name as parsed, in UTF-8 format (ASCII actually) */ 9054 int n_name; 9055 9056 for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) { 9057 mem_base = xmlMemBlocks(); 9058 name = gen_const_char_ptr(n_name, 0); 9059 9060 ret_val = xmlParseCharEncoding((const char *)name); 9061 desret_xmlCharEncoding(ret_val); 9062 call_tests++; 9063 des_const_char_ptr(n_name, (const char *)name, 0); 9064 xmlResetLastError(); 9065 if (mem_base != xmlMemBlocks()) { 9066 printf("Leak of %d blocks found in xmlParseCharEncoding", 9067 xmlMemBlocks() - mem_base); 9068 test_ret++; 9069 printf(" %d", n_name); 9070 printf("\n"); 9071 } 9072 } 9073 function_tests++; 9074 9075 return(test_ret); 9076 } 9077 9078 9079 #define gen_nb_xmlCharEncodingHandlerPtr 1 9080 static xmlCharEncodingHandlerPtr gen_xmlCharEncodingHandlerPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 9081 return(NULL); 9082 } 9083 static void des_xmlCharEncodingHandlerPtr(int no ATTRIBUTE_UNUSED, xmlCharEncodingHandlerPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 9084 } 9085 9086 static int 9087 test_xmlRegisterCharEncodingHandler(void) { 9088 int test_ret = 0; 9089 9090 int mem_base; 9091 xmlCharEncodingHandlerPtr handler; /* the xmlCharEncodingHandlerPtr handler block */ 9092 int n_handler; 9093 9094 for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) { 9095 mem_base = xmlMemBlocks(); 9096 handler = gen_xmlCharEncodingHandlerPtr(n_handler, 0); 9097 9098 xmlRegisterCharEncodingHandler(handler); 9099 call_tests++; 9100 des_xmlCharEncodingHandlerPtr(n_handler, handler, 0); 9101 xmlResetLastError(); 9102 if (mem_base != xmlMemBlocks()) { 9103 printf("Leak of %d blocks found in xmlRegisterCharEncodingHandler", 9104 xmlMemBlocks() - mem_base); 9105 test_ret++; 9106 printf(" %d", n_handler); 9107 printf("\n"); 9108 } 9109 } 9110 function_tests++; 9111 9112 return(test_ret); 9113 } 9114 9115 static int 9116 test_encoding(void) { 9117 int test_ret = 0; 9118 9119 if (quiet == 0) printf("Testing encoding : 16 of 19 functions ...\n"); 9120 test_ret += test_UTF8Toisolat1(); 9121 test_ret += test_isolat1ToUTF8(); 9122 test_ret += test_xmlAddEncodingAlias(); 9123 test_ret += test_xmlCharEncCloseFunc(); 9124 test_ret += test_xmlCharEncFirstLine(); 9125 test_ret += test_xmlCharEncInFunc(); 9126 test_ret += test_xmlCharEncOutFunc(); 9127 test_ret += test_xmlCleanupCharEncodingHandlers(); 9128 test_ret += test_xmlCleanupEncodingAliases(); 9129 test_ret += test_xmlDelEncodingAlias(); 9130 test_ret += test_xmlDetectCharEncoding(); 9131 test_ret += test_xmlFindCharEncodingHandler(); 9132 test_ret += test_xmlGetCharEncodingHandler(); 9133 test_ret += test_xmlGetCharEncodingName(); 9134 test_ret += test_xmlGetEncodingAlias(); 9135 test_ret += test_xmlInitCharEncodingHandlers(); 9136 test_ret += test_xmlNewCharEncodingHandler(); 9137 test_ret += test_xmlParseCharEncoding(); 9138 test_ret += test_xmlRegisterCharEncodingHandler(); 9139 9140 if (test_ret != 0) 9141 printf("Module encoding: %d errors\n", test_ret); 9142 return(test_ret); 9143 } 9144 9145 static int 9146 test_xmlAddDocEntity(void) { 9147 int test_ret = 0; 9148 9149 int mem_base; 9150 xmlEntityPtr ret_val; 9151 xmlDocPtr doc; /* the document */ 9152 int n_doc; 9153 xmlChar * name; /* the entity name */ 9154 int n_name; 9155 int type; /* the entity type XML_xxx_yyy_ENTITY */ 9156 int n_type; 9157 xmlChar * ExternalID; /* the entity external ID if available */ 9158 int n_ExternalID; 9159 xmlChar * SystemID; /* the entity system ID if available */ 9160 int n_SystemID; 9161 xmlChar * content; /* the entity content */ 9162 int n_content; 9163 9164 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 9165 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 9166 for (n_type = 0;n_type < gen_nb_int;n_type++) { 9167 for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) { 9168 for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) { 9169 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 9170 mem_base = xmlMemBlocks(); 9171 doc = gen_xmlDocPtr(n_doc, 0); 9172 name = gen_const_xmlChar_ptr(n_name, 1); 9173 type = gen_int(n_type, 2); 9174 ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3); 9175 SystemID = gen_const_xmlChar_ptr(n_SystemID, 4); 9176 content = gen_const_xmlChar_ptr(n_content, 5); 9177 9178 ret_val = xmlAddDocEntity(doc, (const xmlChar *)name, type, (const xmlChar *)ExternalID, (const xmlChar *)SystemID, (const xmlChar *)content); 9179 desret_xmlEntityPtr(ret_val); 9180 call_tests++; 9181 des_xmlDocPtr(n_doc, doc, 0); 9182 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 9183 des_int(n_type, type, 2); 9184 des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 3); 9185 des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 4); 9186 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 5); 9187 xmlResetLastError(); 9188 if (mem_base != xmlMemBlocks()) { 9189 printf("Leak of %d blocks found in xmlAddDocEntity", 9190 xmlMemBlocks() - mem_base); 9191 test_ret++; 9192 printf(" %d", n_doc); 9193 printf(" %d", n_name); 9194 printf(" %d", n_type); 9195 printf(" %d", n_ExternalID); 9196 printf(" %d", n_SystemID); 9197 printf(" %d", n_content); 9198 printf("\n"); 9199 } 9200 } 9201 } 9202 } 9203 } 9204 } 9205 } 9206 function_tests++; 9207 9208 return(test_ret); 9209 } 9210 9211 9212 static int 9213 test_xmlAddDtdEntity(void) { 9214 int test_ret = 0; 9215 9216 int mem_base; 9217 xmlEntityPtr ret_val; 9218 xmlDocPtr doc; /* the document */ 9219 int n_doc; 9220 xmlChar * name; /* the entity name */ 9221 int n_name; 9222 int type; /* the entity type XML_xxx_yyy_ENTITY */ 9223 int n_type; 9224 xmlChar * ExternalID; /* the entity external ID if available */ 9225 int n_ExternalID; 9226 xmlChar * SystemID; /* the entity system ID if available */ 9227 int n_SystemID; 9228 xmlChar * content; /* the entity content */ 9229 int n_content; 9230 9231 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 9232 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 9233 for (n_type = 0;n_type < gen_nb_int;n_type++) { 9234 for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) { 9235 for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) { 9236 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 9237 mem_base = xmlMemBlocks(); 9238 doc = gen_xmlDocPtr(n_doc, 0); 9239 name = gen_const_xmlChar_ptr(n_name, 1); 9240 type = gen_int(n_type, 2); 9241 ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3); 9242 SystemID = gen_const_xmlChar_ptr(n_SystemID, 4); 9243 content = gen_const_xmlChar_ptr(n_content, 5); 9244 9245 ret_val = xmlAddDtdEntity(doc, (const xmlChar *)name, type, (const xmlChar *)ExternalID, (const xmlChar *)SystemID, (const xmlChar *)content); 9246 desret_xmlEntityPtr(ret_val); 9247 call_tests++; 9248 des_xmlDocPtr(n_doc, doc, 0); 9249 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 9250 des_int(n_type, type, 2); 9251 des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 3); 9252 des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 4); 9253 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 5); 9254 xmlResetLastError(); 9255 if (mem_base != xmlMemBlocks()) { 9256 printf("Leak of %d blocks found in xmlAddDtdEntity", 9257 xmlMemBlocks() - mem_base); 9258 test_ret++; 9259 printf(" %d", n_doc); 9260 printf(" %d", n_name); 9261 printf(" %d", n_type); 9262 printf(" %d", n_ExternalID); 9263 printf(" %d", n_SystemID); 9264 printf(" %d", n_content); 9265 printf("\n"); 9266 } 9267 } 9268 } 9269 } 9270 } 9271 } 9272 } 9273 function_tests++; 9274 9275 return(test_ret); 9276 } 9277 9278 9279 static int 9280 test_xmlCleanupPredefinedEntities(void) { 9281 int test_ret = 0; 9282 9283 #if defined(LIBXML_LEGACY_ENABLED) 9284 #ifdef LIBXML_LEGACY_ENABLED 9285 int mem_base; 9286 9287 mem_base = xmlMemBlocks(); 9288 9289 xmlCleanupPredefinedEntities(); 9290 call_tests++; 9291 xmlResetLastError(); 9292 if (mem_base != xmlMemBlocks()) { 9293 printf("Leak of %d blocks found in xmlCleanupPredefinedEntities", 9294 xmlMemBlocks() - mem_base); 9295 test_ret++; 9296 printf("\n"); 9297 } 9298 function_tests++; 9299 #endif 9300 #endif 9301 9302 return(test_ret); 9303 } 9304 9305 9306 #define gen_nb_xmlEntitiesTablePtr 1 9307 static xmlEntitiesTablePtr gen_xmlEntitiesTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 9308 return(NULL); 9309 } 9310 static void des_xmlEntitiesTablePtr(int no ATTRIBUTE_UNUSED, xmlEntitiesTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 9311 } 9312 9313 static int 9314 test_xmlCopyEntitiesTable(void) { 9315 int test_ret = 0; 9316 9317 9318 /* missing type support */ 9319 return(test_ret); 9320 } 9321 9322 9323 static int 9324 test_xmlCreateEntitiesTable(void) { 9325 int test_ret = 0; 9326 9327 9328 /* missing type support */ 9329 return(test_ret); 9330 } 9331 9332 9333 static int 9334 test_xmlDumpEntitiesTable(void) { 9335 int test_ret = 0; 9336 9337 #if defined(LIBXML_OUTPUT_ENABLED) 9338 int mem_base; 9339 xmlBufferPtr buf; /* An XML buffer. */ 9340 int n_buf; 9341 xmlEntitiesTablePtr table; /* An entity table */ 9342 int n_table; 9343 9344 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 9345 for (n_table = 0;n_table < gen_nb_xmlEntitiesTablePtr;n_table++) { 9346 mem_base = xmlMemBlocks(); 9347 buf = gen_xmlBufferPtr(n_buf, 0); 9348 table = gen_xmlEntitiesTablePtr(n_table, 1); 9349 9350 xmlDumpEntitiesTable(buf, table); 9351 call_tests++; 9352 des_xmlBufferPtr(n_buf, buf, 0); 9353 des_xmlEntitiesTablePtr(n_table, table, 1); 9354 xmlResetLastError(); 9355 if (mem_base != xmlMemBlocks()) { 9356 printf("Leak of %d blocks found in xmlDumpEntitiesTable", 9357 xmlMemBlocks() - mem_base); 9358 test_ret++; 9359 printf(" %d", n_buf); 9360 printf(" %d", n_table); 9361 printf("\n"); 9362 } 9363 } 9364 } 9365 function_tests++; 9366 #endif 9367 9368 return(test_ret); 9369 } 9370 9371 9372 #define gen_nb_xmlEntityPtr 1 9373 static xmlEntityPtr gen_xmlEntityPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 9374 return(NULL); 9375 } 9376 static void des_xmlEntityPtr(int no ATTRIBUTE_UNUSED, xmlEntityPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 9377 } 9378 9379 static int 9380 test_xmlDumpEntityDecl(void) { 9381 int test_ret = 0; 9382 9383 #if defined(LIBXML_OUTPUT_ENABLED) 9384 int mem_base; 9385 xmlBufferPtr buf; /* An XML buffer. */ 9386 int n_buf; 9387 xmlEntityPtr ent; /* An entity table */ 9388 int n_ent; 9389 9390 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 9391 for (n_ent = 0;n_ent < gen_nb_xmlEntityPtr;n_ent++) { 9392 mem_base = xmlMemBlocks(); 9393 buf = gen_xmlBufferPtr(n_buf, 0); 9394 ent = gen_xmlEntityPtr(n_ent, 1); 9395 9396 xmlDumpEntityDecl(buf, ent); 9397 call_tests++; 9398 des_xmlBufferPtr(n_buf, buf, 0); 9399 des_xmlEntityPtr(n_ent, ent, 1); 9400 xmlResetLastError(); 9401 if (mem_base != xmlMemBlocks()) { 9402 printf("Leak of %d blocks found in xmlDumpEntityDecl", 9403 xmlMemBlocks() - mem_base); 9404 test_ret++; 9405 printf(" %d", n_buf); 9406 printf(" %d", n_ent); 9407 printf("\n"); 9408 } 9409 } 9410 } 9411 function_tests++; 9412 #endif 9413 9414 return(test_ret); 9415 } 9416 9417 9418 static int 9419 test_xmlEncodeEntitiesReentrant(void) { 9420 int test_ret = 0; 9421 9422 int mem_base; 9423 xmlChar * ret_val; 9424 xmlDocPtr doc; /* the document containing the string */ 9425 int n_doc; 9426 xmlChar * input; /* A string to convert to XML. */ 9427 int n_input; 9428 9429 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 9430 for (n_input = 0;n_input < gen_nb_const_xmlChar_ptr;n_input++) { 9431 mem_base = xmlMemBlocks(); 9432 doc = gen_xmlDocPtr(n_doc, 0); 9433 input = gen_const_xmlChar_ptr(n_input, 1); 9434 9435 ret_val = xmlEncodeEntitiesReentrant(doc, (const xmlChar *)input); 9436 desret_xmlChar_ptr(ret_val); 9437 call_tests++; 9438 des_xmlDocPtr(n_doc, doc, 0); 9439 des_const_xmlChar_ptr(n_input, (const xmlChar *)input, 1); 9440 xmlResetLastError(); 9441 if (mem_base != xmlMemBlocks()) { 9442 printf("Leak of %d blocks found in xmlEncodeEntitiesReentrant", 9443 xmlMemBlocks() - mem_base); 9444 test_ret++; 9445 printf(" %d", n_doc); 9446 printf(" %d", n_input); 9447 printf("\n"); 9448 } 9449 } 9450 } 9451 function_tests++; 9452 9453 return(test_ret); 9454 } 9455 9456 9457 #define gen_nb_const_xmlDoc_ptr 1 9458 static xmlDoc * gen_const_xmlDoc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 9459 return(NULL); 9460 } 9461 static void des_const_xmlDoc_ptr(int no ATTRIBUTE_UNUSED, const xmlDoc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 9462 } 9463 9464 static int 9465 test_xmlEncodeSpecialChars(void) { 9466 int test_ret = 0; 9467 9468 int mem_base; 9469 xmlChar * ret_val; 9470 xmlDoc * doc; /* the document containing the string */ 9471 int n_doc; 9472 xmlChar * input; /* A string to convert to XML. */ 9473 int n_input; 9474 9475 for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) { 9476 for (n_input = 0;n_input < gen_nb_const_xmlChar_ptr;n_input++) { 9477 mem_base = xmlMemBlocks(); 9478 doc = gen_const_xmlDoc_ptr(n_doc, 0); 9479 input = gen_const_xmlChar_ptr(n_input, 1); 9480 9481 ret_val = xmlEncodeSpecialChars((const xmlDoc *)doc, (const xmlChar *)input); 9482 desret_xmlChar_ptr(ret_val); 9483 call_tests++; 9484 des_const_xmlDoc_ptr(n_doc, (const xmlDoc *)doc, 0); 9485 des_const_xmlChar_ptr(n_input, (const xmlChar *)input, 1); 9486 xmlResetLastError(); 9487 if (mem_base != xmlMemBlocks()) { 9488 printf("Leak of %d blocks found in xmlEncodeSpecialChars", 9489 xmlMemBlocks() - mem_base); 9490 test_ret++; 9491 printf(" %d", n_doc); 9492 printf(" %d", n_input); 9493 printf("\n"); 9494 } 9495 } 9496 } 9497 function_tests++; 9498 9499 return(test_ret); 9500 } 9501 9502 9503 static int 9504 test_xmlGetDocEntity(void) { 9505 int test_ret = 0; 9506 9507 int mem_base; 9508 xmlEntityPtr ret_val; 9509 xmlDoc * doc; /* the document referencing the entity */ 9510 int n_doc; 9511 xmlChar * name; /* the entity name */ 9512 int n_name; 9513 9514 for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) { 9515 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 9516 mem_base = xmlMemBlocks(); 9517 doc = gen_const_xmlDoc_ptr(n_doc, 0); 9518 name = gen_const_xmlChar_ptr(n_name, 1); 9519 9520 ret_val = xmlGetDocEntity((const xmlDoc *)doc, (const xmlChar *)name); 9521 desret_xmlEntityPtr(ret_val); 9522 call_tests++; 9523 des_const_xmlDoc_ptr(n_doc, (const xmlDoc *)doc, 0); 9524 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 9525 xmlResetLastError(); 9526 if (mem_base != xmlMemBlocks()) { 9527 printf("Leak of %d blocks found in xmlGetDocEntity", 9528 xmlMemBlocks() - mem_base); 9529 test_ret++; 9530 printf(" %d", n_doc); 9531 printf(" %d", n_name); 9532 printf("\n"); 9533 } 9534 } 9535 } 9536 function_tests++; 9537 9538 return(test_ret); 9539 } 9540 9541 9542 static int 9543 test_xmlGetDtdEntity(void) { 9544 int test_ret = 0; 9545 9546 int mem_base; 9547 xmlEntityPtr ret_val; 9548 xmlDocPtr doc; /* the document referencing the entity */ 9549 int n_doc; 9550 xmlChar * name; /* the entity name */ 9551 int n_name; 9552 9553 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 9554 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 9555 mem_base = xmlMemBlocks(); 9556 doc = gen_xmlDocPtr(n_doc, 0); 9557 name = gen_const_xmlChar_ptr(n_name, 1); 9558 9559 ret_val = xmlGetDtdEntity(doc, (const xmlChar *)name); 9560 desret_xmlEntityPtr(ret_val); 9561 call_tests++; 9562 des_xmlDocPtr(n_doc, doc, 0); 9563 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 9564 xmlResetLastError(); 9565 if (mem_base != xmlMemBlocks()) { 9566 printf("Leak of %d blocks found in xmlGetDtdEntity", 9567 xmlMemBlocks() - mem_base); 9568 test_ret++; 9569 printf(" %d", n_doc); 9570 printf(" %d", n_name); 9571 printf("\n"); 9572 } 9573 } 9574 } 9575 function_tests++; 9576 9577 return(test_ret); 9578 } 9579 9580 9581 static int 9582 test_xmlGetParameterEntity(void) { 9583 int test_ret = 0; 9584 9585 int mem_base; 9586 xmlEntityPtr ret_val; 9587 xmlDocPtr doc; /* the document referencing the entity */ 9588 int n_doc; 9589 xmlChar * name; /* the entity name */ 9590 int n_name; 9591 9592 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 9593 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 9594 mem_base = xmlMemBlocks(); 9595 doc = gen_xmlDocPtr(n_doc, 0); 9596 name = gen_const_xmlChar_ptr(n_name, 1); 9597 9598 ret_val = xmlGetParameterEntity(doc, (const xmlChar *)name); 9599 desret_xmlEntityPtr(ret_val); 9600 call_tests++; 9601 des_xmlDocPtr(n_doc, doc, 0); 9602 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 9603 xmlResetLastError(); 9604 if (mem_base != xmlMemBlocks()) { 9605 printf("Leak of %d blocks found in xmlGetParameterEntity", 9606 xmlMemBlocks() - mem_base); 9607 test_ret++; 9608 printf(" %d", n_doc); 9609 printf(" %d", n_name); 9610 printf("\n"); 9611 } 9612 } 9613 } 9614 function_tests++; 9615 9616 return(test_ret); 9617 } 9618 9619 9620 static int 9621 test_xmlGetPredefinedEntity(void) { 9622 int test_ret = 0; 9623 9624 int mem_base; 9625 xmlEntityPtr ret_val; 9626 xmlChar * name; /* the entity name */ 9627 int n_name; 9628 9629 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 9630 mem_base = xmlMemBlocks(); 9631 name = gen_const_xmlChar_ptr(n_name, 0); 9632 9633 ret_val = xmlGetPredefinedEntity((const xmlChar *)name); 9634 desret_xmlEntityPtr(ret_val); 9635 call_tests++; 9636 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0); 9637 xmlResetLastError(); 9638 if (mem_base != xmlMemBlocks()) { 9639 printf("Leak of %d blocks found in xmlGetPredefinedEntity", 9640 xmlMemBlocks() - mem_base); 9641 test_ret++; 9642 printf(" %d", n_name); 9643 printf("\n"); 9644 } 9645 } 9646 function_tests++; 9647 9648 return(test_ret); 9649 } 9650 9651 9652 static int 9653 test_xmlInitializePredefinedEntities(void) { 9654 int test_ret = 0; 9655 9656 #if defined(LIBXML_LEGACY_ENABLED) 9657 #ifdef LIBXML_LEGACY_ENABLED 9658 int mem_base; 9659 9660 mem_base = xmlMemBlocks(); 9661 9662 xmlInitializePredefinedEntities(); 9663 call_tests++; 9664 xmlResetLastError(); 9665 if (mem_base != xmlMemBlocks()) { 9666 printf("Leak of %d blocks found in xmlInitializePredefinedEntities", 9667 xmlMemBlocks() - mem_base); 9668 test_ret++; 9669 printf("\n"); 9670 } 9671 function_tests++; 9672 #endif 9673 #endif 9674 9675 return(test_ret); 9676 } 9677 9678 9679 static int 9680 test_xmlNewEntity(void) { 9681 int test_ret = 0; 9682 9683 int mem_base; 9684 xmlEntityPtr ret_val; 9685 xmlDocPtr doc; /* the document */ 9686 int n_doc; 9687 xmlChar * name; /* the entity name */ 9688 int n_name; 9689 int type; /* the entity type XML_xxx_yyy_ENTITY */ 9690 int n_type; 9691 xmlChar * ExternalID; /* the entity external ID if available */ 9692 int n_ExternalID; 9693 xmlChar * SystemID; /* the entity system ID if available */ 9694 int n_SystemID; 9695 xmlChar * content; /* the entity content */ 9696 int n_content; 9697 9698 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 9699 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 9700 for (n_type = 0;n_type < gen_nb_int;n_type++) { 9701 for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) { 9702 for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) { 9703 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 9704 mem_base = xmlMemBlocks(); 9705 doc = gen_xmlDocPtr(n_doc, 0); 9706 name = gen_const_xmlChar_ptr(n_name, 1); 9707 type = gen_int(n_type, 2); 9708 ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3); 9709 SystemID = gen_const_xmlChar_ptr(n_SystemID, 4); 9710 content = gen_const_xmlChar_ptr(n_content, 5); 9711 9712 ret_val = xmlNewEntity(doc, (const xmlChar *)name, type, (const xmlChar *)ExternalID, (const xmlChar *)SystemID, (const xmlChar *)content); 9713 desret_xmlEntityPtr(ret_val); 9714 call_tests++; 9715 des_xmlDocPtr(n_doc, doc, 0); 9716 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 9717 des_int(n_type, type, 2); 9718 des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 3); 9719 des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 4); 9720 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 5); 9721 xmlResetLastError(); 9722 if (mem_base != xmlMemBlocks()) { 9723 printf("Leak of %d blocks found in xmlNewEntity", 9724 xmlMemBlocks() - mem_base); 9725 test_ret++; 9726 printf(" %d", n_doc); 9727 printf(" %d", n_name); 9728 printf(" %d", n_type); 9729 printf(" %d", n_ExternalID); 9730 printf(" %d", n_SystemID); 9731 printf(" %d", n_content); 9732 printf("\n"); 9733 } 9734 } 9735 } 9736 } 9737 } 9738 } 9739 } 9740 function_tests++; 9741 9742 return(test_ret); 9743 } 9744 9745 static int 9746 test_entities(void) { 9747 int test_ret = 0; 9748 9749 if (quiet == 0) printf("Testing entities : 13 of 17 functions ...\n"); 9750 test_ret += test_xmlAddDocEntity(); 9751 test_ret += test_xmlAddDtdEntity(); 9752 test_ret += test_xmlCleanupPredefinedEntities(); 9753 test_ret += test_xmlCopyEntitiesTable(); 9754 test_ret += test_xmlCreateEntitiesTable(); 9755 test_ret += test_xmlDumpEntitiesTable(); 9756 test_ret += test_xmlDumpEntityDecl(); 9757 test_ret += test_xmlEncodeEntitiesReentrant(); 9758 test_ret += test_xmlEncodeSpecialChars(); 9759 test_ret += test_xmlGetDocEntity(); 9760 test_ret += test_xmlGetDtdEntity(); 9761 test_ret += test_xmlGetParameterEntity(); 9762 test_ret += test_xmlGetPredefinedEntity(); 9763 test_ret += test_xmlInitializePredefinedEntities(); 9764 test_ret += test_xmlNewEntity(); 9765 9766 if (test_ret != 0) 9767 printf("Module entities: %d errors\n", test_ret); 9768 return(test_ret); 9769 } 9770 9771 static int 9772 test_xmlHashAddEntry(void) { 9773 int test_ret = 0; 9774 9775 int mem_base; 9776 int ret_val; 9777 xmlHashTablePtr table; /* the hash table */ 9778 int n_table; 9779 xmlChar * name; /* the name of the userdata */ 9780 int n_name; 9781 void * userdata; /* a pointer to the userdata */ 9782 int n_userdata; 9783 9784 for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) { 9785 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 9786 for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) { 9787 mem_base = xmlMemBlocks(); 9788 table = gen_xmlHashTablePtr(n_table, 0); 9789 name = gen_const_xmlChar_ptr(n_name, 1); 9790 userdata = gen_userdata(n_userdata, 2); 9791 9792 ret_val = xmlHashAddEntry(table, (const xmlChar *)name, userdata); 9793 desret_int(ret_val); 9794 call_tests++; 9795 des_xmlHashTablePtr(n_table, table, 0); 9796 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 9797 des_userdata(n_userdata, userdata, 2); 9798 xmlResetLastError(); 9799 if (mem_base != xmlMemBlocks()) { 9800 printf("Leak of %d blocks found in xmlHashAddEntry", 9801 xmlMemBlocks() - mem_base); 9802 test_ret++; 9803 printf(" %d", n_table); 9804 printf(" %d", n_name); 9805 printf(" %d", n_userdata); 9806 printf("\n"); 9807 } 9808 } 9809 } 9810 } 9811 function_tests++; 9812 9813 return(test_ret); 9814 } 9815 9816 9817 static int 9818 test_xmlHashAddEntry2(void) { 9819 int test_ret = 0; 9820 9821 int mem_base; 9822 int ret_val; 9823 xmlHashTablePtr table; /* the hash table */ 9824 int n_table; 9825 xmlChar * name; /* the name of the userdata */ 9826 int n_name; 9827 xmlChar * name2; /* a second name of the userdata */ 9828 int n_name2; 9829 void * userdata; /* a pointer to the userdata */ 9830 int n_userdata; 9831 9832 for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) { 9833 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 9834 for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) { 9835 for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) { 9836 mem_base = xmlMemBlocks(); 9837 table = gen_xmlHashTablePtr(n_table, 0); 9838 name = gen_const_xmlChar_ptr(n_name, 1); 9839 name2 = gen_const_xmlChar_ptr(n_name2, 2); 9840 userdata = gen_userdata(n_userdata, 3); 9841 9842 ret_val = xmlHashAddEntry2(table, (const xmlChar *)name, (const xmlChar *)name2, userdata); 9843 desret_int(ret_val); 9844 call_tests++; 9845 des_xmlHashTablePtr(n_table, table, 0); 9846 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 9847 des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2); 9848 des_userdata(n_userdata, userdata, 3); 9849 xmlResetLastError(); 9850 if (mem_base != xmlMemBlocks()) { 9851 printf("Leak of %d blocks found in xmlHashAddEntry2", 9852 xmlMemBlocks() - mem_base); 9853 test_ret++; 9854 printf(" %d", n_table); 9855 printf(" %d", n_name); 9856 printf(" %d", n_name2); 9857 printf(" %d", n_userdata); 9858 printf("\n"); 9859 } 9860 } 9861 } 9862 } 9863 } 9864 function_tests++; 9865 9866 return(test_ret); 9867 } 9868 9869 9870 static int 9871 test_xmlHashAddEntry3(void) { 9872 int test_ret = 0; 9873 9874 int mem_base; 9875 int ret_val; 9876 xmlHashTablePtr table; /* the hash table */ 9877 int n_table; 9878 xmlChar * name; /* the name of the userdata */ 9879 int n_name; 9880 xmlChar * name2; /* a second name of the userdata */ 9881 int n_name2; 9882 xmlChar * name3; /* a third name of the userdata */ 9883 int n_name3; 9884 void * userdata; /* a pointer to the userdata */ 9885 int n_userdata; 9886 9887 for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) { 9888 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 9889 for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) { 9890 for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) { 9891 for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) { 9892 mem_base = xmlMemBlocks(); 9893 table = gen_xmlHashTablePtr(n_table, 0); 9894 name = gen_const_xmlChar_ptr(n_name, 1); 9895 name2 = gen_const_xmlChar_ptr(n_name2, 2); 9896 name3 = gen_const_xmlChar_ptr(n_name3, 3); 9897 userdata = gen_userdata(n_userdata, 4); 9898 9899 ret_val = xmlHashAddEntry3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3, userdata); 9900 desret_int(ret_val); 9901 call_tests++; 9902 des_xmlHashTablePtr(n_table, table, 0); 9903 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 9904 des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2); 9905 des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3); 9906 des_userdata(n_userdata, userdata, 4); 9907 xmlResetLastError(); 9908 if (mem_base != xmlMemBlocks()) { 9909 printf("Leak of %d blocks found in xmlHashAddEntry3", 9910 xmlMemBlocks() - mem_base); 9911 test_ret++; 9912 printf(" %d", n_table); 9913 printf(" %d", n_name); 9914 printf(" %d", n_name2); 9915 printf(" %d", n_name3); 9916 printf(" %d", n_userdata); 9917 printf("\n"); 9918 } 9919 } 9920 } 9921 } 9922 } 9923 } 9924 function_tests++; 9925 9926 return(test_ret); 9927 } 9928 9929 9930 static int 9931 test_xmlHashCopy(void) { 9932 int test_ret = 0; 9933 9934 9935 /* missing type support */ 9936 return(test_ret); 9937 } 9938 9939 9940 static int 9941 test_xmlHashCreate(void) { 9942 int test_ret = 0; 9943 9944 9945 /* missing type support */ 9946 return(test_ret); 9947 } 9948 9949 9950 static int 9951 test_xmlHashCreateDict(void) { 9952 int test_ret = 0; 9953 9954 9955 /* missing type support */ 9956 return(test_ret); 9957 } 9958 9959 9960 static int 9961 test_xmlHashLookup(void) { 9962 int test_ret = 0; 9963 9964 int mem_base; 9965 void * ret_val; 9966 xmlHashTablePtr table; /* the hash table */ 9967 int n_table; 9968 xmlChar * name; /* the name of the userdata */ 9969 int n_name; 9970 9971 for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) { 9972 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 9973 mem_base = xmlMemBlocks(); 9974 table = gen_xmlHashTablePtr(n_table, 0); 9975 name = gen_const_xmlChar_ptr(n_name, 1); 9976 9977 ret_val = xmlHashLookup(table, (const xmlChar *)name); 9978 desret_void_ptr(ret_val); 9979 call_tests++; 9980 des_xmlHashTablePtr(n_table, table, 0); 9981 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 9982 xmlResetLastError(); 9983 if (mem_base != xmlMemBlocks()) { 9984 printf("Leak of %d blocks found in xmlHashLookup", 9985 xmlMemBlocks() - mem_base); 9986 test_ret++; 9987 printf(" %d", n_table); 9988 printf(" %d", n_name); 9989 printf("\n"); 9990 } 9991 } 9992 } 9993 function_tests++; 9994 9995 return(test_ret); 9996 } 9997 9998 9999 static int 10000 test_xmlHashLookup2(void) { 10001 int test_ret = 0; 10002 10003 int mem_base; 10004 void * ret_val; 10005 xmlHashTablePtr table; /* the hash table */ 10006 int n_table; 10007 xmlChar * name; /* the name of the userdata */ 10008 int n_name; 10009 xmlChar * name2; /* a second name of the userdata */ 10010 int n_name2; 10011 10012 for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) { 10013 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 10014 for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) { 10015 mem_base = xmlMemBlocks(); 10016 table = gen_xmlHashTablePtr(n_table, 0); 10017 name = gen_const_xmlChar_ptr(n_name, 1); 10018 name2 = gen_const_xmlChar_ptr(n_name2, 2); 10019 10020 ret_val = xmlHashLookup2(table, (const xmlChar *)name, (const xmlChar *)name2); 10021 desret_void_ptr(ret_val); 10022 call_tests++; 10023 des_xmlHashTablePtr(n_table, table, 0); 10024 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 10025 des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2); 10026 xmlResetLastError(); 10027 if (mem_base != xmlMemBlocks()) { 10028 printf("Leak of %d blocks found in xmlHashLookup2", 10029 xmlMemBlocks() - mem_base); 10030 test_ret++; 10031 printf(" %d", n_table); 10032 printf(" %d", n_name); 10033 printf(" %d", n_name2); 10034 printf("\n"); 10035 } 10036 } 10037 } 10038 } 10039 function_tests++; 10040 10041 return(test_ret); 10042 } 10043 10044 10045 static int 10046 test_xmlHashLookup3(void) { 10047 int test_ret = 0; 10048 10049 int mem_base; 10050 void * ret_val; 10051 xmlHashTablePtr table; /* the hash table */ 10052 int n_table; 10053 xmlChar * name; /* the name of the userdata */ 10054 int n_name; 10055 xmlChar * name2; /* a second name of the userdata */ 10056 int n_name2; 10057 xmlChar * name3; /* a third name of the userdata */ 10058 int n_name3; 10059 10060 for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) { 10061 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 10062 for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) { 10063 for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) { 10064 mem_base = xmlMemBlocks(); 10065 table = gen_xmlHashTablePtr(n_table, 0); 10066 name = gen_const_xmlChar_ptr(n_name, 1); 10067 name2 = gen_const_xmlChar_ptr(n_name2, 2); 10068 name3 = gen_const_xmlChar_ptr(n_name3, 3); 10069 10070 ret_val = xmlHashLookup3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3); 10071 desret_void_ptr(ret_val); 10072 call_tests++; 10073 des_xmlHashTablePtr(n_table, table, 0); 10074 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 10075 des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2); 10076 des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3); 10077 xmlResetLastError(); 10078 if (mem_base != xmlMemBlocks()) { 10079 printf("Leak of %d blocks found in xmlHashLookup3", 10080 xmlMemBlocks() - mem_base); 10081 test_ret++; 10082 printf(" %d", n_table); 10083 printf(" %d", n_name); 10084 printf(" %d", n_name2); 10085 printf(" %d", n_name3); 10086 printf("\n"); 10087 } 10088 } 10089 } 10090 } 10091 } 10092 function_tests++; 10093 10094 return(test_ret); 10095 } 10096 10097 10098 static int 10099 test_xmlHashQLookup(void) { 10100 int test_ret = 0; 10101 10102 int mem_base; 10103 void * ret_val; 10104 xmlHashTablePtr table; /* the hash table */ 10105 int n_table; 10106 xmlChar * prefix; /* the prefix of the userdata */ 10107 int n_prefix; 10108 xmlChar * name; /* the name of the userdata */ 10109 int n_name; 10110 10111 for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) { 10112 for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) { 10113 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 10114 mem_base = xmlMemBlocks(); 10115 table = gen_xmlHashTablePtr(n_table, 0); 10116 prefix = gen_const_xmlChar_ptr(n_prefix, 1); 10117 name = gen_const_xmlChar_ptr(n_name, 2); 10118 10119 ret_val = xmlHashQLookup(table, (const xmlChar *)prefix, (const xmlChar *)name); 10120 desret_void_ptr(ret_val); 10121 call_tests++; 10122 des_xmlHashTablePtr(n_table, table, 0); 10123 des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1); 10124 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 10125 xmlResetLastError(); 10126 if (mem_base != xmlMemBlocks()) { 10127 printf("Leak of %d blocks found in xmlHashQLookup", 10128 xmlMemBlocks() - mem_base); 10129 test_ret++; 10130 printf(" %d", n_table); 10131 printf(" %d", n_prefix); 10132 printf(" %d", n_name); 10133 printf("\n"); 10134 } 10135 } 10136 } 10137 } 10138 function_tests++; 10139 10140 return(test_ret); 10141 } 10142 10143 10144 static int 10145 test_xmlHashQLookup2(void) { 10146 int test_ret = 0; 10147 10148 int mem_base; 10149 void * ret_val; 10150 xmlHashTablePtr table; /* the hash table */ 10151 int n_table; 10152 xmlChar * prefix; /* the prefix of the userdata */ 10153 int n_prefix; 10154 xmlChar * name; /* the name of the userdata */ 10155 int n_name; 10156 xmlChar * prefix2; /* the second prefix of the userdata */ 10157 int n_prefix2; 10158 xmlChar * name2; /* a second name of the userdata */ 10159 int n_name2; 10160 10161 for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) { 10162 for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) { 10163 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 10164 for (n_prefix2 = 0;n_prefix2 < gen_nb_const_xmlChar_ptr;n_prefix2++) { 10165 for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) { 10166 mem_base = xmlMemBlocks(); 10167 table = gen_xmlHashTablePtr(n_table, 0); 10168 prefix = gen_const_xmlChar_ptr(n_prefix, 1); 10169 name = gen_const_xmlChar_ptr(n_name, 2); 10170 prefix2 = gen_const_xmlChar_ptr(n_prefix2, 3); 10171 name2 = gen_const_xmlChar_ptr(n_name2, 4); 10172 10173 ret_val = xmlHashQLookup2(table, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)prefix2, (const xmlChar *)name2); 10174 desret_void_ptr(ret_val); 10175 call_tests++; 10176 des_xmlHashTablePtr(n_table, table, 0); 10177 des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1); 10178 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 10179 des_const_xmlChar_ptr(n_prefix2, (const xmlChar *)prefix2, 3); 10180 des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 4); 10181 xmlResetLastError(); 10182 if (mem_base != xmlMemBlocks()) { 10183 printf("Leak of %d blocks found in xmlHashQLookup2", 10184 xmlMemBlocks() - mem_base); 10185 test_ret++; 10186 printf(" %d", n_table); 10187 printf(" %d", n_prefix); 10188 printf(" %d", n_name); 10189 printf(" %d", n_prefix2); 10190 printf(" %d", n_name2); 10191 printf("\n"); 10192 } 10193 } 10194 } 10195 } 10196 } 10197 } 10198 function_tests++; 10199 10200 return(test_ret); 10201 } 10202 10203 10204 static int 10205 test_xmlHashQLookup3(void) { 10206 int test_ret = 0; 10207 10208 int mem_base; 10209 void * ret_val; 10210 xmlHashTablePtr table; /* the hash table */ 10211 int n_table; 10212 xmlChar * prefix; /* the prefix of the userdata */ 10213 int n_prefix; 10214 xmlChar * name; /* the name of the userdata */ 10215 int n_name; 10216 xmlChar * prefix2; /* the second prefix of the userdata */ 10217 int n_prefix2; 10218 xmlChar * name2; /* a second name of the userdata */ 10219 int n_name2; 10220 xmlChar * prefix3; /* the third prefix of the userdata */ 10221 int n_prefix3; 10222 xmlChar * name3; /* a third name of the userdata */ 10223 int n_name3; 10224 10225 for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) { 10226 for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) { 10227 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 10228 for (n_prefix2 = 0;n_prefix2 < gen_nb_const_xmlChar_ptr;n_prefix2++) { 10229 for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) { 10230 for (n_prefix3 = 0;n_prefix3 < gen_nb_const_xmlChar_ptr;n_prefix3++) { 10231 for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) { 10232 mem_base = xmlMemBlocks(); 10233 table = gen_xmlHashTablePtr(n_table, 0); 10234 prefix = gen_const_xmlChar_ptr(n_prefix, 1); 10235 name = gen_const_xmlChar_ptr(n_name, 2); 10236 prefix2 = gen_const_xmlChar_ptr(n_prefix2, 3); 10237 name2 = gen_const_xmlChar_ptr(n_name2, 4); 10238 prefix3 = gen_const_xmlChar_ptr(n_prefix3, 5); 10239 name3 = gen_const_xmlChar_ptr(n_name3, 6); 10240 10241 ret_val = xmlHashQLookup3(table, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)prefix2, (const xmlChar *)name2, (const xmlChar *)prefix3, (const xmlChar *)name3); 10242 desret_void_ptr(ret_val); 10243 call_tests++; 10244 des_xmlHashTablePtr(n_table, table, 0); 10245 des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1); 10246 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 10247 des_const_xmlChar_ptr(n_prefix2, (const xmlChar *)prefix2, 3); 10248 des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 4); 10249 des_const_xmlChar_ptr(n_prefix3, (const xmlChar *)prefix3, 5); 10250 des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 6); 10251 xmlResetLastError(); 10252 if (mem_base != xmlMemBlocks()) { 10253 printf("Leak of %d blocks found in xmlHashQLookup3", 10254 xmlMemBlocks() - mem_base); 10255 test_ret++; 10256 printf(" %d", n_table); 10257 printf(" %d", n_prefix); 10258 printf(" %d", n_name); 10259 printf(" %d", n_prefix2); 10260 printf(" %d", n_name2); 10261 printf(" %d", n_prefix3); 10262 printf(" %d", n_name3); 10263 printf("\n"); 10264 } 10265 } 10266 } 10267 } 10268 } 10269 } 10270 } 10271 } 10272 function_tests++; 10273 10274 return(test_ret); 10275 } 10276 10277 10278 static int 10279 test_xmlHashRemoveEntry(void) { 10280 int test_ret = 0; 10281 10282 int mem_base; 10283 int ret_val; 10284 xmlHashTablePtr table; /* the hash table */ 10285 int n_table; 10286 xmlChar * name; /* the name of the userdata */ 10287 int n_name; 10288 xmlHashDeallocator f; /* the deallocator function for removed item (if any) */ 10289 int n_f; 10290 10291 for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) { 10292 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 10293 for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) { 10294 mem_base = xmlMemBlocks(); 10295 table = gen_xmlHashTablePtr(n_table, 0); 10296 name = gen_const_xmlChar_ptr(n_name, 1); 10297 f = gen_xmlHashDeallocator(n_f, 2); 10298 10299 ret_val = xmlHashRemoveEntry(table, (const xmlChar *)name, f); 10300 desret_int(ret_val); 10301 call_tests++; 10302 des_xmlHashTablePtr(n_table, table, 0); 10303 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 10304 des_xmlHashDeallocator(n_f, f, 2); 10305 xmlResetLastError(); 10306 if (mem_base != xmlMemBlocks()) { 10307 printf("Leak of %d blocks found in xmlHashRemoveEntry", 10308 xmlMemBlocks() - mem_base); 10309 test_ret++; 10310 printf(" %d", n_table); 10311 printf(" %d", n_name); 10312 printf(" %d", n_f); 10313 printf("\n"); 10314 } 10315 } 10316 } 10317 } 10318 function_tests++; 10319 10320 return(test_ret); 10321 } 10322 10323 10324 static int 10325 test_xmlHashRemoveEntry2(void) { 10326 int test_ret = 0; 10327 10328 int mem_base; 10329 int ret_val; 10330 xmlHashTablePtr table; /* the hash table */ 10331 int n_table; 10332 xmlChar * name; /* the name of the userdata */ 10333 int n_name; 10334 xmlChar * name2; /* a second name of the userdata */ 10335 int n_name2; 10336 xmlHashDeallocator f; /* the deallocator function for removed item (if any) */ 10337 int n_f; 10338 10339 for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) { 10340 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 10341 for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) { 10342 for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) { 10343 mem_base = xmlMemBlocks(); 10344 table = gen_xmlHashTablePtr(n_table, 0); 10345 name = gen_const_xmlChar_ptr(n_name, 1); 10346 name2 = gen_const_xmlChar_ptr(n_name2, 2); 10347 f = gen_xmlHashDeallocator(n_f, 3); 10348 10349 ret_val = xmlHashRemoveEntry2(table, (const xmlChar *)name, (const xmlChar *)name2, f); 10350 desret_int(ret_val); 10351 call_tests++; 10352 des_xmlHashTablePtr(n_table, table, 0); 10353 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 10354 des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2); 10355 des_xmlHashDeallocator(n_f, f, 3); 10356 xmlResetLastError(); 10357 if (mem_base != xmlMemBlocks()) { 10358 printf("Leak of %d blocks found in xmlHashRemoveEntry2", 10359 xmlMemBlocks() - mem_base); 10360 test_ret++; 10361 printf(" %d", n_table); 10362 printf(" %d", n_name); 10363 printf(" %d", n_name2); 10364 printf(" %d", n_f); 10365 printf("\n"); 10366 } 10367 } 10368 } 10369 } 10370 } 10371 function_tests++; 10372 10373 return(test_ret); 10374 } 10375 10376 10377 static int 10378 test_xmlHashRemoveEntry3(void) { 10379 int test_ret = 0; 10380 10381 int mem_base; 10382 int ret_val; 10383 xmlHashTablePtr table; /* the hash table */ 10384 int n_table; 10385 xmlChar * name; /* the name of the userdata */ 10386 int n_name; 10387 xmlChar * name2; /* a second name of the userdata */ 10388 int n_name2; 10389 xmlChar * name3; /* a third name of the userdata */ 10390 int n_name3; 10391 xmlHashDeallocator f; /* the deallocator function for removed item (if any) */ 10392 int n_f; 10393 10394 for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) { 10395 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 10396 for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) { 10397 for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) { 10398 for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) { 10399 mem_base = xmlMemBlocks(); 10400 table = gen_xmlHashTablePtr(n_table, 0); 10401 name = gen_const_xmlChar_ptr(n_name, 1); 10402 name2 = gen_const_xmlChar_ptr(n_name2, 2); 10403 name3 = gen_const_xmlChar_ptr(n_name3, 3); 10404 f = gen_xmlHashDeallocator(n_f, 4); 10405 10406 ret_val = xmlHashRemoveEntry3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3, f); 10407 desret_int(ret_val); 10408 call_tests++; 10409 des_xmlHashTablePtr(n_table, table, 0); 10410 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 10411 des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2); 10412 des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3); 10413 des_xmlHashDeallocator(n_f, f, 4); 10414 xmlResetLastError(); 10415 if (mem_base != xmlMemBlocks()) { 10416 printf("Leak of %d blocks found in xmlHashRemoveEntry3", 10417 xmlMemBlocks() - mem_base); 10418 test_ret++; 10419 printf(" %d", n_table); 10420 printf(" %d", n_name); 10421 printf(" %d", n_name2); 10422 printf(" %d", n_name3); 10423 printf(" %d", n_f); 10424 printf("\n"); 10425 } 10426 } 10427 } 10428 } 10429 } 10430 } 10431 function_tests++; 10432 10433 return(test_ret); 10434 } 10435 10436 10437 static int 10438 test_xmlHashScan(void) { 10439 int test_ret = 0; 10440 10441 10442 /* missing type support */ 10443 return(test_ret); 10444 } 10445 10446 10447 static int 10448 test_xmlHashScan3(void) { 10449 int test_ret = 0; 10450 10451 10452 /* missing type support */ 10453 return(test_ret); 10454 } 10455 10456 10457 static int 10458 test_xmlHashScanFull(void) { 10459 int test_ret = 0; 10460 10461 10462 /* missing type support */ 10463 return(test_ret); 10464 } 10465 10466 10467 static int 10468 test_xmlHashScanFull3(void) { 10469 int test_ret = 0; 10470 10471 10472 /* missing type support */ 10473 return(test_ret); 10474 } 10475 10476 10477 static int 10478 test_xmlHashSize(void) { 10479 int test_ret = 0; 10480 10481 int mem_base; 10482 int ret_val; 10483 xmlHashTablePtr table; /* the hash table */ 10484 int n_table; 10485 10486 for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) { 10487 mem_base = xmlMemBlocks(); 10488 table = gen_xmlHashTablePtr(n_table, 0); 10489 10490 ret_val = xmlHashSize(table); 10491 desret_int(ret_val); 10492 call_tests++; 10493 des_xmlHashTablePtr(n_table, table, 0); 10494 xmlResetLastError(); 10495 if (mem_base != xmlMemBlocks()) { 10496 printf("Leak of %d blocks found in xmlHashSize", 10497 xmlMemBlocks() - mem_base); 10498 test_ret++; 10499 printf(" %d", n_table); 10500 printf("\n"); 10501 } 10502 } 10503 function_tests++; 10504 10505 return(test_ret); 10506 } 10507 10508 10509 static int 10510 test_xmlHashUpdateEntry(void) { 10511 int test_ret = 0; 10512 10513 int mem_base; 10514 int ret_val; 10515 xmlHashTablePtr table; /* the hash table */ 10516 int n_table; 10517 xmlChar * name; /* the name of the userdata */ 10518 int n_name; 10519 void * userdata; /* a pointer to the userdata */ 10520 int n_userdata; 10521 xmlHashDeallocator f; /* the deallocator function for replaced item (if any) */ 10522 int n_f; 10523 10524 for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) { 10525 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 10526 for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) { 10527 for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) { 10528 mem_base = xmlMemBlocks(); 10529 table = gen_xmlHashTablePtr(n_table, 0); 10530 name = gen_const_xmlChar_ptr(n_name, 1); 10531 userdata = gen_userdata(n_userdata, 2); 10532 f = gen_xmlHashDeallocator(n_f, 3); 10533 10534 ret_val = xmlHashUpdateEntry(table, (const xmlChar *)name, userdata, f); 10535 desret_int(ret_val); 10536 call_tests++; 10537 des_xmlHashTablePtr(n_table, table, 0); 10538 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 10539 des_userdata(n_userdata, userdata, 2); 10540 des_xmlHashDeallocator(n_f, f, 3); 10541 xmlResetLastError(); 10542 if (mem_base != xmlMemBlocks()) { 10543 printf("Leak of %d blocks found in xmlHashUpdateEntry", 10544 xmlMemBlocks() - mem_base); 10545 test_ret++; 10546 printf(" %d", n_table); 10547 printf(" %d", n_name); 10548 printf(" %d", n_userdata); 10549 printf(" %d", n_f); 10550 printf("\n"); 10551 } 10552 } 10553 } 10554 } 10555 } 10556 function_tests++; 10557 10558 return(test_ret); 10559 } 10560 10561 10562 static int 10563 test_xmlHashUpdateEntry2(void) { 10564 int test_ret = 0; 10565 10566 int mem_base; 10567 int ret_val; 10568 xmlHashTablePtr table; /* the hash table */ 10569 int n_table; 10570 xmlChar * name; /* the name of the userdata */ 10571 int n_name; 10572 xmlChar * name2; /* a second name of the userdata */ 10573 int n_name2; 10574 void * userdata; /* a pointer to the userdata */ 10575 int n_userdata; 10576 xmlHashDeallocator f; /* the deallocator function for replaced item (if any) */ 10577 int n_f; 10578 10579 for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) { 10580 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 10581 for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) { 10582 for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) { 10583 for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) { 10584 mem_base = xmlMemBlocks(); 10585 table = gen_xmlHashTablePtr(n_table, 0); 10586 name = gen_const_xmlChar_ptr(n_name, 1); 10587 name2 = gen_const_xmlChar_ptr(n_name2, 2); 10588 userdata = gen_userdata(n_userdata, 3); 10589 f = gen_xmlHashDeallocator(n_f, 4); 10590 10591 ret_val = xmlHashUpdateEntry2(table, (const xmlChar *)name, (const xmlChar *)name2, userdata, f); 10592 desret_int(ret_val); 10593 call_tests++; 10594 des_xmlHashTablePtr(n_table, table, 0); 10595 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 10596 des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2); 10597 des_userdata(n_userdata, userdata, 3); 10598 des_xmlHashDeallocator(n_f, f, 4); 10599 xmlResetLastError(); 10600 if (mem_base != xmlMemBlocks()) { 10601 printf("Leak of %d blocks found in xmlHashUpdateEntry2", 10602 xmlMemBlocks() - mem_base); 10603 test_ret++; 10604 printf(" %d", n_table); 10605 printf(" %d", n_name); 10606 printf(" %d", n_name2); 10607 printf(" %d", n_userdata); 10608 printf(" %d", n_f); 10609 printf("\n"); 10610 } 10611 } 10612 } 10613 } 10614 } 10615 } 10616 function_tests++; 10617 10618 return(test_ret); 10619 } 10620 10621 10622 static int 10623 test_xmlHashUpdateEntry3(void) { 10624 int test_ret = 0; 10625 10626 int mem_base; 10627 int ret_val; 10628 xmlHashTablePtr table; /* the hash table */ 10629 int n_table; 10630 xmlChar * name; /* the name of the userdata */ 10631 int n_name; 10632 xmlChar * name2; /* a second name of the userdata */ 10633 int n_name2; 10634 xmlChar * name3; /* a third name of the userdata */ 10635 int n_name3; 10636 void * userdata; /* a pointer to the userdata */ 10637 int n_userdata; 10638 xmlHashDeallocator f; /* the deallocator function for replaced item (if any) */ 10639 int n_f; 10640 10641 for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) { 10642 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 10643 for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) { 10644 for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) { 10645 for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) { 10646 for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) { 10647 mem_base = xmlMemBlocks(); 10648 table = gen_xmlHashTablePtr(n_table, 0); 10649 name = gen_const_xmlChar_ptr(n_name, 1); 10650 name2 = gen_const_xmlChar_ptr(n_name2, 2); 10651 name3 = gen_const_xmlChar_ptr(n_name3, 3); 10652 userdata = gen_userdata(n_userdata, 4); 10653 f = gen_xmlHashDeallocator(n_f, 5); 10654 10655 ret_val = xmlHashUpdateEntry3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3, userdata, f); 10656 desret_int(ret_val); 10657 call_tests++; 10658 des_xmlHashTablePtr(n_table, table, 0); 10659 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 10660 des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2); 10661 des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3); 10662 des_userdata(n_userdata, userdata, 4); 10663 des_xmlHashDeallocator(n_f, f, 5); 10664 xmlResetLastError(); 10665 if (mem_base != xmlMemBlocks()) { 10666 printf("Leak of %d blocks found in xmlHashUpdateEntry3", 10667 xmlMemBlocks() - mem_base); 10668 test_ret++; 10669 printf(" %d", n_table); 10670 printf(" %d", n_name); 10671 printf(" %d", n_name2); 10672 printf(" %d", n_name3); 10673 printf(" %d", n_userdata); 10674 printf(" %d", n_f); 10675 printf("\n"); 10676 } 10677 } 10678 } 10679 } 10680 } 10681 } 10682 } 10683 function_tests++; 10684 10685 return(test_ret); 10686 } 10687 10688 static int 10689 test_hash(void) { 10690 int test_ret = 0; 10691 10692 if (quiet == 0) printf("Testing hash : 16 of 24 functions ...\n"); 10693 test_ret += test_xmlHashAddEntry(); 10694 test_ret += test_xmlHashAddEntry2(); 10695 test_ret += test_xmlHashAddEntry3(); 10696 test_ret += test_xmlHashCopy(); 10697 test_ret += test_xmlHashCreate(); 10698 test_ret += test_xmlHashCreateDict(); 10699 test_ret += test_xmlHashLookup(); 10700 test_ret += test_xmlHashLookup2(); 10701 test_ret += test_xmlHashLookup3(); 10702 test_ret += test_xmlHashQLookup(); 10703 test_ret += test_xmlHashQLookup2(); 10704 test_ret += test_xmlHashQLookup3(); 10705 test_ret += test_xmlHashRemoveEntry(); 10706 test_ret += test_xmlHashRemoveEntry2(); 10707 test_ret += test_xmlHashRemoveEntry3(); 10708 test_ret += test_xmlHashScan(); 10709 test_ret += test_xmlHashScan3(); 10710 test_ret += test_xmlHashScanFull(); 10711 test_ret += test_xmlHashScanFull3(); 10712 test_ret += test_xmlHashSize(); 10713 test_ret += test_xmlHashUpdateEntry(); 10714 test_ret += test_xmlHashUpdateEntry2(); 10715 test_ret += test_xmlHashUpdateEntry3(); 10716 10717 if (test_ret != 0) 10718 printf("Module hash: %d errors\n", test_ret); 10719 return(test_ret); 10720 } 10721 10722 #define gen_nb_xmlLinkPtr 1 10723 static xmlLinkPtr gen_xmlLinkPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 10724 return(NULL); 10725 } 10726 static void des_xmlLinkPtr(int no ATTRIBUTE_UNUSED, xmlLinkPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 10727 } 10728 10729 static int 10730 test_xmlLinkGetData(void) { 10731 int test_ret = 0; 10732 10733 int mem_base; 10734 void * ret_val; 10735 xmlLinkPtr lk; /* a link */ 10736 int n_lk; 10737 10738 for (n_lk = 0;n_lk < gen_nb_xmlLinkPtr;n_lk++) { 10739 mem_base = xmlMemBlocks(); 10740 lk = gen_xmlLinkPtr(n_lk, 0); 10741 10742 ret_val = xmlLinkGetData(lk); 10743 desret_void_ptr(ret_val); 10744 call_tests++; 10745 des_xmlLinkPtr(n_lk, lk, 0); 10746 xmlResetLastError(); 10747 if (mem_base != xmlMemBlocks()) { 10748 printf("Leak of %d blocks found in xmlLinkGetData", 10749 xmlMemBlocks() - mem_base); 10750 test_ret++; 10751 printf(" %d", n_lk); 10752 printf("\n"); 10753 } 10754 } 10755 function_tests++; 10756 10757 return(test_ret); 10758 } 10759 10760 10761 static int 10762 test_xmlListAppend(void) { 10763 int test_ret = 0; 10764 10765 int mem_base; 10766 int ret_val; 10767 xmlListPtr l; /* a list */ 10768 int n_l; 10769 void * data; /* the data */ 10770 int n_data; 10771 10772 for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) { 10773 for (n_data = 0;n_data < gen_nb_userdata;n_data++) { 10774 mem_base = xmlMemBlocks(); 10775 l = gen_xmlListPtr(n_l, 0); 10776 data = gen_userdata(n_data, 1); 10777 10778 ret_val = xmlListAppend(l, data); 10779 desret_int(ret_val); 10780 call_tests++; 10781 des_xmlListPtr(n_l, l, 0); 10782 des_userdata(n_data, data, 1); 10783 xmlResetLastError(); 10784 if (mem_base != xmlMemBlocks()) { 10785 printf("Leak of %d blocks found in xmlListAppend", 10786 xmlMemBlocks() - mem_base); 10787 test_ret++; 10788 printf(" %d", n_l); 10789 printf(" %d", n_data); 10790 printf("\n"); 10791 } 10792 } 10793 } 10794 function_tests++; 10795 10796 return(test_ret); 10797 } 10798 10799 10800 static int 10801 test_xmlListClear(void) { 10802 int test_ret = 0; 10803 10804 int mem_base; 10805 xmlListPtr l; /* a list */ 10806 int n_l; 10807 10808 for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) { 10809 mem_base = xmlMemBlocks(); 10810 l = gen_xmlListPtr(n_l, 0); 10811 10812 xmlListClear(l); 10813 call_tests++; 10814 des_xmlListPtr(n_l, l, 0); 10815 xmlResetLastError(); 10816 if (mem_base != xmlMemBlocks()) { 10817 printf("Leak of %d blocks found in xmlListClear", 10818 xmlMemBlocks() - mem_base); 10819 test_ret++; 10820 printf(" %d", n_l); 10821 printf("\n"); 10822 } 10823 } 10824 function_tests++; 10825 10826 return(test_ret); 10827 } 10828 10829 10830 #define gen_nb_const_xmlListPtr 1 10831 static xmlListPtr gen_const_xmlListPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 10832 return(NULL); 10833 } 10834 static void des_const_xmlListPtr(int no ATTRIBUTE_UNUSED, const xmlListPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 10835 } 10836 10837 static int 10838 test_xmlListCopy(void) { 10839 int test_ret = 0; 10840 10841 int mem_base; 10842 int ret_val; 10843 xmlListPtr cur; /* the new list */ 10844 int n_cur; 10845 xmlListPtr old; /* the old list */ 10846 int n_old; 10847 10848 for (n_cur = 0;n_cur < gen_nb_xmlListPtr;n_cur++) { 10849 for (n_old = 0;n_old < gen_nb_const_xmlListPtr;n_old++) { 10850 mem_base = xmlMemBlocks(); 10851 cur = gen_xmlListPtr(n_cur, 0); 10852 old = gen_const_xmlListPtr(n_old, 1); 10853 10854 ret_val = xmlListCopy(cur, (const xmlListPtr)old); 10855 desret_int(ret_val); 10856 call_tests++; 10857 des_xmlListPtr(n_cur, cur, 0); 10858 des_const_xmlListPtr(n_old, (const xmlListPtr)old, 1); 10859 xmlResetLastError(); 10860 if (mem_base != xmlMemBlocks()) { 10861 printf("Leak of %d blocks found in xmlListCopy", 10862 xmlMemBlocks() - mem_base); 10863 test_ret++; 10864 printf(" %d", n_cur); 10865 printf(" %d", n_old); 10866 printf("\n"); 10867 } 10868 } 10869 } 10870 function_tests++; 10871 10872 return(test_ret); 10873 } 10874 10875 10876 static int 10877 test_xmlListCreate(void) { 10878 int test_ret = 0; 10879 10880 10881 /* missing type support */ 10882 return(test_ret); 10883 } 10884 10885 10886 static int 10887 test_xmlListDup(void) { 10888 int test_ret = 0; 10889 10890 10891 /* missing type support */ 10892 return(test_ret); 10893 } 10894 10895 10896 static int 10897 test_xmlListEmpty(void) { 10898 int test_ret = 0; 10899 10900 int mem_base; 10901 int ret_val; 10902 xmlListPtr l; /* a list */ 10903 int n_l; 10904 10905 for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) { 10906 mem_base = xmlMemBlocks(); 10907 l = gen_xmlListPtr(n_l, 0); 10908 10909 ret_val = xmlListEmpty(l); 10910 desret_int(ret_val); 10911 call_tests++; 10912 des_xmlListPtr(n_l, l, 0); 10913 xmlResetLastError(); 10914 if (mem_base != xmlMemBlocks()) { 10915 printf("Leak of %d blocks found in xmlListEmpty", 10916 xmlMemBlocks() - mem_base); 10917 test_ret++; 10918 printf(" %d", n_l); 10919 printf("\n"); 10920 } 10921 } 10922 function_tests++; 10923 10924 return(test_ret); 10925 } 10926 10927 10928 static int 10929 test_xmlListEnd(void) { 10930 int test_ret = 0; 10931 10932 10933 /* missing type support */ 10934 return(test_ret); 10935 } 10936 10937 10938 static int 10939 test_xmlListFront(void) { 10940 int test_ret = 0; 10941 10942 10943 /* missing type support */ 10944 return(test_ret); 10945 } 10946 10947 10948 static int 10949 test_xmlListInsert(void) { 10950 int test_ret = 0; 10951 10952 int mem_base; 10953 int ret_val; 10954 xmlListPtr l; /* a list */ 10955 int n_l; 10956 void * data; /* the data */ 10957 int n_data; 10958 10959 for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) { 10960 for (n_data = 0;n_data < gen_nb_userdata;n_data++) { 10961 mem_base = xmlMemBlocks(); 10962 l = gen_xmlListPtr(n_l, 0); 10963 data = gen_userdata(n_data, 1); 10964 10965 ret_val = xmlListInsert(l, data); 10966 desret_int(ret_val); 10967 call_tests++; 10968 des_xmlListPtr(n_l, l, 0); 10969 des_userdata(n_data, data, 1); 10970 xmlResetLastError(); 10971 if (mem_base != xmlMemBlocks()) { 10972 printf("Leak of %d blocks found in xmlListInsert", 10973 xmlMemBlocks() - mem_base); 10974 test_ret++; 10975 printf(" %d", n_l); 10976 printf(" %d", n_data); 10977 printf("\n"); 10978 } 10979 } 10980 } 10981 function_tests++; 10982 10983 return(test_ret); 10984 } 10985 10986 10987 static int 10988 test_xmlListMerge(void) { 10989 int test_ret = 0; 10990 10991 int mem_base; 10992 xmlListPtr l1; /* the original list */ 10993 int n_l1; 10994 xmlListPtr l2; /* the new list */ 10995 int n_l2; 10996 10997 for (n_l1 = 0;n_l1 < gen_nb_xmlListPtr;n_l1++) { 10998 for (n_l2 = 0;n_l2 < gen_nb_xmlListPtr;n_l2++) { 10999 mem_base = xmlMemBlocks(); 11000 l1 = gen_xmlListPtr(n_l1, 0); 11001 l2 = gen_xmlListPtr(n_l2, 1); 11002 11003 xmlListMerge(l1, l2); 11004 call_tests++; 11005 des_xmlListPtr(n_l1, l1, 0); 11006 des_xmlListPtr(n_l2, l2, 1); 11007 xmlResetLastError(); 11008 if (mem_base != xmlMemBlocks()) { 11009 printf("Leak of %d blocks found in xmlListMerge", 11010 xmlMemBlocks() - mem_base); 11011 test_ret++; 11012 printf(" %d", n_l1); 11013 printf(" %d", n_l2); 11014 printf("\n"); 11015 } 11016 } 11017 } 11018 function_tests++; 11019 11020 return(test_ret); 11021 } 11022 11023 11024 static int 11025 test_xmlListPopBack(void) { 11026 int test_ret = 0; 11027 11028 int mem_base; 11029 xmlListPtr l; /* a list */ 11030 int n_l; 11031 11032 for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) { 11033 mem_base = xmlMemBlocks(); 11034 l = gen_xmlListPtr(n_l, 0); 11035 11036 xmlListPopBack(l); 11037 call_tests++; 11038 des_xmlListPtr(n_l, l, 0); 11039 xmlResetLastError(); 11040 if (mem_base != xmlMemBlocks()) { 11041 printf("Leak of %d blocks found in xmlListPopBack", 11042 xmlMemBlocks() - mem_base); 11043 test_ret++; 11044 printf(" %d", n_l); 11045 printf("\n"); 11046 } 11047 } 11048 function_tests++; 11049 11050 return(test_ret); 11051 } 11052 11053 11054 static int 11055 test_xmlListPopFront(void) { 11056 int test_ret = 0; 11057 11058 int mem_base; 11059 xmlListPtr l; /* a list */ 11060 int n_l; 11061 11062 for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) { 11063 mem_base = xmlMemBlocks(); 11064 l = gen_xmlListPtr(n_l, 0); 11065 11066 xmlListPopFront(l); 11067 call_tests++; 11068 des_xmlListPtr(n_l, l, 0); 11069 xmlResetLastError(); 11070 if (mem_base != xmlMemBlocks()) { 11071 printf("Leak of %d blocks found in xmlListPopFront", 11072 xmlMemBlocks() - mem_base); 11073 test_ret++; 11074 printf(" %d", n_l); 11075 printf("\n"); 11076 } 11077 } 11078 function_tests++; 11079 11080 return(test_ret); 11081 } 11082 11083 11084 static int 11085 test_xmlListPushBack(void) { 11086 int test_ret = 0; 11087 11088 int mem_base; 11089 int ret_val; 11090 xmlListPtr l; /* a list */ 11091 int n_l; 11092 void * data; /* new data */ 11093 int n_data; 11094 11095 for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) { 11096 for (n_data = 0;n_data < gen_nb_userdata;n_data++) { 11097 mem_base = xmlMemBlocks(); 11098 l = gen_xmlListPtr(n_l, 0); 11099 data = gen_userdata(n_data, 1); 11100 11101 ret_val = xmlListPushBack(l, data); 11102 desret_int(ret_val); 11103 call_tests++; 11104 des_xmlListPtr(n_l, l, 0); 11105 des_userdata(n_data, data, 1); 11106 xmlResetLastError(); 11107 if (mem_base != xmlMemBlocks()) { 11108 printf("Leak of %d blocks found in xmlListPushBack", 11109 xmlMemBlocks() - mem_base); 11110 test_ret++; 11111 printf(" %d", n_l); 11112 printf(" %d", n_data); 11113 printf("\n"); 11114 } 11115 } 11116 } 11117 function_tests++; 11118 11119 return(test_ret); 11120 } 11121 11122 11123 static int 11124 test_xmlListPushFront(void) { 11125 int test_ret = 0; 11126 11127 int mem_base; 11128 int ret_val; 11129 xmlListPtr l; /* a list */ 11130 int n_l; 11131 void * data; /* new data */ 11132 int n_data; 11133 11134 for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) { 11135 for (n_data = 0;n_data < gen_nb_userdata;n_data++) { 11136 mem_base = xmlMemBlocks(); 11137 l = gen_xmlListPtr(n_l, 0); 11138 data = gen_userdata(n_data, 1); 11139 11140 ret_val = xmlListPushFront(l, data); 11141 desret_int(ret_val); 11142 call_tests++; 11143 des_xmlListPtr(n_l, l, 0); 11144 des_userdata(n_data, data, 1); 11145 xmlResetLastError(); 11146 if (mem_base != xmlMemBlocks()) { 11147 printf("Leak of %d blocks found in xmlListPushFront", 11148 xmlMemBlocks() - mem_base); 11149 test_ret++; 11150 printf(" %d", n_l); 11151 printf(" %d", n_data); 11152 printf("\n"); 11153 } 11154 } 11155 } 11156 function_tests++; 11157 11158 return(test_ret); 11159 } 11160 11161 11162 static int 11163 test_xmlListRemoveAll(void) { 11164 int test_ret = 0; 11165 11166 int mem_base; 11167 int ret_val; 11168 xmlListPtr l; /* a list */ 11169 int n_l; 11170 void * data; /* list data */ 11171 int n_data; 11172 11173 for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) { 11174 for (n_data = 0;n_data < gen_nb_userdata;n_data++) { 11175 mem_base = xmlMemBlocks(); 11176 l = gen_xmlListPtr(n_l, 0); 11177 data = gen_userdata(n_data, 1); 11178 11179 ret_val = xmlListRemoveAll(l, data); 11180 desret_int(ret_val); 11181 call_tests++; 11182 des_xmlListPtr(n_l, l, 0); 11183 des_userdata(n_data, data, 1); 11184 xmlResetLastError(); 11185 if (mem_base != xmlMemBlocks()) { 11186 printf("Leak of %d blocks found in xmlListRemoveAll", 11187 xmlMemBlocks() - mem_base); 11188 test_ret++; 11189 printf(" %d", n_l); 11190 printf(" %d", n_data); 11191 printf("\n"); 11192 } 11193 } 11194 } 11195 function_tests++; 11196 11197 return(test_ret); 11198 } 11199 11200 11201 static int 11202 test_xmlListRemoveFirst(void) { 11203 int test_ret = 0; 11204 11205 int mem_base; 11206 int ret_val; 11207 xmlListPtr l; /* a list */ 11208 int n_l; 11209 void * data; /* list data */ 11210 int n_data; 11211 11212 for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) { 11213 for (n_data = 0;n_data < gen_nb_userdata;n_data++) { 11214 mem_base = xmlMemBlocks(); 11215 l = gen_xmlListPtr(n_l, 0); 11216 data = gen_userdata(n_data, 1); 11217 11218 ret_val = xmlListRemoveFirst(l, data); 11219 desret_int(ret_val); 11220 call_tests++; 11221 des_xmlListPtr(n_l, l, 0); 11222 des_userdata(n_data, data, 1); 11223 xmlResetLastError(); 11224 if (mem_base != xmlMemBlocks()) { 11225 printf("Leak of %d blocks found in xmlListRemoveFirst", 11226 xmlMemBlocks() - mem_base); 11227 test_ret++; 11228 printf(" %d", n_l); 11229 printf(" %d", n_data); 11230 printf("\n"); 11231 } 11232 } 11233 } 11234 function_tests++; 11235 11236 return(test_ret); 11237 } 11238 11239 11240 static int 11241 test_xmlListRemoveLast(void) { 11242 int test_ret = 0; 11243 11244 int mem_base; 11245 int ret_val; 11246 xmlListPtr l; /* a list */ 11247 int n_l; 11248 void * data; /* list data */ 11249 int n_data; 11250 11251 for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) { 11252 for (n_data = 0;n_data < gen_nb_userdata;n_data++) { 11253 mem_base = xmlMemBlocks(); 11254 l = gen_xmlListPtr(n_l, 0); 11255 data = gen_userdata(n_data, 1); 11256 11257 ret_val = xmlListRemoveLast(l, data); 11258 desret_int(ret_val); 11259 call_tests++; 11260 des_xmlListPtr(n_l, l, 0); 11261 des_userdata(n_data, data, 1); 11262 xmlResetLastError(); 11263 if (mem_base != xmlMemBlocks()) { 11264 printf("Leak of %d blocks found in xmlListRemoveLast", 11265 xmlMemBlocks() - mem_base); 11266 test_ret++; 11267 printf(" %d", n_l); 11268 printf(" %d", n_data); 11269 printf("\n"); 11270 } 11271 } 11272 } 11273 function_tests++; 11274 11275 return(test_ret); 11276 } 11277 11278 11279 static int 11280 test_xmlListReverse(void) { 11281 int test_ret = 0; 11282 11283 int mem_base; 11284 xmlListPtr l; /* a list */ 11285 int n_l; 11286 11287 for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) { 11288 mem_base = xmlMemBlocks(); 11289 l = gen_xmlListPtr(n_l, 0); 11290 11291 xmlListReverse(l); 11292 call_tests++; 11293 des_xmlListPtr(n_l, l, 0); 11294 xmlResetLastError(); 11295 if (mem_base != xmlMemBlocks()) { 11296 printf("Leak of %d blocks found in xmlListReverse", 11297 xmlMemBlocks() - mem_base); 11298 test_ret++; 11299 printf(" %d", n_l); 11300 printf("\n"); 11301 } 11302 } 11303 function_tests++; 11304 11305 return(test_ret); 11306 } 11307 11308 11309 static int 11310 test_xmlListReverseSearch(void) { 11311 int test_ret = 0; 11312 11313 int mem_base; 11314 void * ret_val; 11315 xmlListPtr l; /* a list */ 11316 int n_l; 11317 void * data; /* a search value */ 11318 int n_data; 11319 11320 for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) { 11321 for (n_data = 0;n_data < gen_nb_userdata;n_data++) { 11322 mem_base = xmlMemBlocks(); 11323 l = gen_xmlListPtr(n_l, 0); 11324 data = gen_userdata(n_data, 1); 11325 11326 ret_val = xmlListReverseSearch(l, data); 11327 desret_void_ptr(ret_val); 11328 call_tests++; 11329 des_xmlListPtr(n_l, l, 0); 11330 des_userdata(n_data, data, 1); 11331 xmlResetLastError(); 11332 if (mem_base != xmlMemBlocks()) { 11333 printf("Leak of %d blocks found in xmlListReverseSearch", 11334 xmlMemBlocks() - mem_base); 11335 test_ret++; 11336 printf(" %d", n_l); 11337 printf(" %d", n_data); 11338 printf("\n"); 11339 } 11340 } 11341 } 11342 function_tests++; 11343 11344 return(test_ret); 11345 } 11346 11347 11348 static int 11349 test_xmlListReverseWalk(void) { 11350 int test_ret = 0; 11351 11352 11353 /* missing type support */ 11354 return(test_ret); 11355 } 11356 11357 11358 static int 11359 test_xmlListSearch(void) { 11360 int test_ret = 0; 11361 11362 int mem_base; 11363 void * ret_val; 11364 xmlListPtr l; /* a list */ 11365 int n_l; 11366 void * data; /* a search value */ 11367 int n_data; 11368 11369 for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) { 11370 for (n_data = 0;n_data < gen_nb_userdata;n_data++) { 11371 mem_base = xmlMemBlocks(); 11372 l = gen_xmlListPtr(n_l, 0); 11373 data = gen_userdata(n_data, 1); 11374 11375 ret_val = xmlListSearch(l, data); 11376 desret_void_ptr(ret_val); 11377 call_tests++; 11378 des_xmlListPtr(n_l, l, 0); 11379 des_userdata(n_data, data, 1); 11380 xmlResetLastError(); 11381 if (mem_base != xmlMemBlocks()) { 11382 printf("Leak of %d blocks found in xmlListSearch", 11383 xmlMemBlocks() - mem_base); 11384 test_ret++; 11385 printf(" %d", n_l); 11386 printf(" %d", n_data); 11387 printf("\n"); 11388 } 11389 } 11390 } 11391 function_tests++; 11392 11393 return(test_ret); 11394 } 11395 11396 11397 static int 11398 test_xmlListSize(void) { 11399 int test_ret = 0; 11400 11401 int mem_base; 11402 int ret_val; 11403 xmlListPtr l; /* a list */ 11404 int n_l; 11405 11406 for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) { 11407 mem_base = xmlMemBlocks(); 11408 l = gen_xmlListPtr(n_l, 0); 11409 11410 ret_val = xmlListSize(l); 11411 desret_int(ret_val); 11412 call_tests++; 11413 des_xmlListPtr(n_l, l, 0); 11414 xmlResetLastError(); 11415 if (mem_base != xmlMemBlocks()) { 11416 printf("Leak of %d blocks found in xmlListSize", 11417 xmlMemBlocks() - mem_base); 11418 test_ret++; 11419 printf(" %d", n_l); 11420 printf("\n"); 11421 } 11422 } 11423 function_tests++; 11424 11425 return(test_ret); 11426 } 11427 11428 11429 static int 11430 test_xmlListSort(void) { 11431 int test_ret = 0; 11432 11433 int mem_base; 11434 xmlListPtr l; /* a list */ 11435 int n_l; 11436 11437 for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) { 11438 mem_base = xmlMemBlocks(); 11439 l = gen_xmlListPtr(n_l, 0); 11440 11441 xmlListSort(l); 11442 call_tests++; 11443 des_xmlListPtr(n_l, l, 0); 11444 xmlResetLastError(); 11445 if (mem_base != xmlMemBlocks()) { 11446 printf("Leak of %d blocks found in xmlListSort", 11447 xmlMemBlocks() - mem_base); 11448 test_ret++; 11449 printf(" %d", n_l); 11450 printf("\n"); 11451 } 11452 } 11453 function_tests++; 11454 11455 return(test_ret); 11456 } 11457 11458 11459 static int 11460 test_xmlListWalk(void) { 11461 int test_ret = 0; 11462 11463 11464 /* missing type support */ 11465 return(test_ret); 11466 } 11467 11468 static int 11469 test_list(void) { 11470 int test_ret = 0; 11471 11472 if (quiet == 0) printf("Testing list : 19 of 26 functions ...\n"); 11473 test_ret += test_xmlLinkGetData(); 11474 test_ret += test_xmlListAppend(); 11475 test_ret += test_xmlListClear(); 11476 test_ret += test_xmlListCopy(); 11477 test_ret += test_xmlListCreate(); 11478 test_ret += test_xmlListDup(); 11479 test_ret += test_xmlListEmpty(); 11480 test_ret += test_xmlListEnd(); 11481 test_ret += test_xmlListFront(); 11482 test_ret += test_xmlListInsert(); 11483 test_ret += test_xmlListMerge(); 11484 test_ret += test_xmlListPopBack(); 11485 test_ret += test_xmlListPopFront(); 11486 test_ret += test_xmlListPushBack(); 11487 test_ret += test_xmlListPushFront(); 11488 test_ret += test_xmlListRemoveAll(); 11489 test_ret += test_xmlListRemoveFirst(); 11490 test_ret += test_xmlListRemoveLast(); 11491 test_ret += test_xmlListReverse(); 11492 test_ret += test_xmlListReverseSearch(); 11493 test_ret += test_xmlListReverseWalk(); 11494 test_ret += test_xmlListSearch(); 11495 test_ret += test_xmlListSize(); 11496 test_ret += test_xmlListSort(); 11497 test_ret += test_xmlListWalk(); 11498 11499 if (test_ret != 0) 11500 printf("Module list: %d errors\n", test_ret); 11501 return(test_ret); 11502 } 11503 11504 static int 11505 test_xmlNanoFTPCheckResponse(void) { 11506 int test_ret = 0; 11507 11508 #if defined(LIBXML_FTP_ENABLED) 11509 int mem_base; 11510 int ret_val; 11511 void * ctx; /* an FTP context */ 11512 int n_ctx; 11513 11514 for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) { 11515 mem_base = xmlMemBlocks(); 11516 ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0); 11517 11518 ret_val = xmlNanoFTPCheckResponse(ctx); 11519 desret_int(ret_val); 11520 call_tests++; 11521 des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0); 11522 xmlResetLastError(); 11523 if (mem_base != xmlMemBlocks()) { 11524 printf("Leak of %d blocks found in xmlNanoFTPCheckResponse", 11525 xmlMemBlocks() - mem_base); 11526 test_ret++; 11527 printf(" %d", n_ctx); 11528 printf("\n"); 11529 } 11530 } 11531 function_tests++; 11532 #endif 11533 11534 return(test_ret); 11535 } 11536 11537 11538 static int 11539 test_xmlNanoFTPCleanup(void) { 11540 int test_ret = 0; 11541 11542 #if defined(LIBXML_FTP_ENABLED) 11543 int mem_base; 11544 11545 mem_base = xmlMemBlocks(); 11546 11547 xmlNanoFTPCleanup(); 11548 call_tests++; 11549 xmlResetLastError(); 11550 if (mem_base != xmlMemBlocks()) { 11551 printf("Leak of %d blocks found in xmlNanoFTPCleanup", 11552 xmlMemBlocks() - mem_base); 11553 test_ret++; 11554 printf("\n"); 11555 } 11556 function_tests++; 11557 #endif 11558 11559 return(test_ret); 11560 } 11561 11562 11563 static int 11564 test_xmlNanoFTPCloseConnection(void) { 11565 int test_ret = 0; 11566 11567 #if defined(LIBXML_FTP_ENABLED) 11568 int mem_base; 11569 int ret_val; 11570 void * ctx; /* an FTP context */ 11571 int n_ctx; 11572 11573 for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) { 11574 mem_base = xmlMemBlocks(); 11575 ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0); 11576 11577 ret_val = xmlNanoFTPCloseConnection(ctx); 11578 desret_int(ret_val); 11579 call_tests++; 11580 des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0); 11581 xmlResetLastError(); 11582 if (mem_base != xmlMemBlocks()) { 11583 printf("Leak of %d blocks found in xmlNanoFTPCloseConnection", 11584 xmlMemBlocks() - mem_base); 11585 test_ret++; 11586 printf(" %d", n_ctx); 11587 printf("\n"); 11588 } 11589 } 11590 function_tests++; 11591 #endif 11592 11593 return(test_ret); 11594 } 11595 11596 11597 static int 11598 test_xmlNanoFTPCwd(void) { 11599 int test_ret = 0; 11600 11601 #if defined(LIBXML_FTP_ENABLED) 11602 int mem_base; 11603 int ret_val; 11604 void * ctx; /* an FTP context */ 11605 int n_ctx; 11606 char * directory; /* a directory on the server */ 11607 int n_directory; 11608 11609 for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) { 11610 for (n_directory = 0;n_directory < gen_nb_const_char_ptr;n_directory++) { 11611 mem_base = xmlMemBlocks(); 11612 ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0); 11613 directory = gen_const_char_ptr(n_directory, 1); 11614 11615 ret_val = xmlNanoFTPCwd(ctx, (const char *)directory); 11616 desret_int(ret_val); 11617 call_tests++; 11618 des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0); 11619 des_const_char_ptr(n_directory, (const char *)directory, 1); 11620 xmlResetLastError(); 11621 if (mem_base != xmlMemBlocks()) { 11622 printf("Leak of %d blocks found in xmlNanoFTPCwd", 11623 xmlMemBlocks() - mem_base); 11624 test_ret++; 11625 printf(" %d", n_ctx); 11626 printf(" %d", n_directory); 11627 printf("\n"); 11628 } 11629 } 11630 } 11631 function_tests++; 11632 #endif 11633 11634 return(test_ret); 11635 } 11636 11637 11638 static int 11639 test_xmlNanoFTPDele(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 const char * file; /* a file or directory on the server */ 11648 int n_file; 11649 11650 for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) { 11651 for (n_file = 0;n_file < gen_nb_filepath;n_file++) { 11652 mem_base = xmlMemBlocks(); 11653 ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0); 11654 file = gen_filepath(n_file, 1); 11655 11656 ret_val = xmlNanoFTPDele(ctx, file); 11657 desret_int(ret_val); 11658 call_tests++; 11659 des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0); 11660 des_filepath(n_file, file, 1); 11661 xmlResetLastError(); 11662 if (mem_base != xmlMemBlocks()) { 11663 printf("Leak of %d blocks found in xmlNanoFTPDele", 11664 xmlMemBlocks() - mem_base); 11665 test_ret++; 11666 printf(" %d", n_ctx); 11667 printf(" %d", n_file); 11668 printf("\n"); 11669 } 11670 } 11671 } 11672 function_tests++; 11673 #endif 11674 11675 return(test_ret); 11676 } 11677 11678 11679 static int 11680 test_xmlNanoFTPGet(void) { 11681 int test_ret = 0; 11682 11683 11684 /* missing type support */ 11685 return(test_ret); 11686 } 11687 11688 11689 static int 11690 test_xmlNanoFTPGetConnection(void) { 11691 int test_ret = 0; 11692 11693 11694 /* missing type support */ 11695 return(test_ret); 11696 } 11697 11698 11699 static int 11700 test_xmlNanoFTPGetResponse(void) { 11701 int test_ret = 0; 11702 11703 #if defined(LIBXML_FTP_ENABLED) 11704 int mem_base; 11705 int ret_val; 11706 void * ctx; /* an FTP context */ 11707 int n_ctx; 11708 11709 for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) { 11710 mem_base = xmlMemBlocks(); 11711 ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0); 11712 11713 ret_val = xmlNanoFTPGetResponse(ctx); 11714 desret_int(ret_val); 11715 call_tests++; 11716 des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0); 11717 xmlResetLastError(); 11718 if (mem_base != xmlMemBlocks()) { 11719 printf("Leak of %d blocks found in xmlNanoFTPGetResponse", 11720 xmlMemBlocks() - mem_base); 11721 test_ret++; 11722 printf(" %d", n_ctx); 11723 printf("\n"); 11724 } 11725 } 11726 function_tests++; 11727 #endif 11728 11729 return(test_ret); 11730 } 11731 11732 11733 static int 11734 test_xmlNanoFTPGetSocket(void) { 11735 int test_ret = 0; 11736 11737 11738 /* missing type support */ 11739 return(test_ret); 11740 } 11741 11742 11743 static int 11744 test_xmlNanoFTPInit(void) { 11745 int test_ret = 0; 11746 11747 #if defined(LIBXML_FTP_ENABLED) 11748 int mem_base; 11749 11750 mem_base = xmlMemBlocks(); 11751 11752 xmlNanoFTPInit(); 11753 call_tests++; 11754 xmlResetLastError(); 11755 if (mem_base != xmlMemBlocks()) { 11756 printf("Leak of %d blocks found in xmlNanoFTPInit", 11757 xmlMemBlocks() - mem_base); 11758 test_ret++; 11759 printf("\n"); 11760 } 11761 function_tests++; 11762 #endif 11763 11764 return(test_ret); 11765 } 11766 11767 11768 static int 11769 test_xmlNanoFTPList(void) { 11770 int test_ret = 0; 11771 11772 11773 /* missing type support */ 11774 return(test_ret); 11775 } 11776 11777 11778 static int 11779 test_xmlNanoFTPNewCtxt(void) { 11780 int test_ret = 0; 11781 11782 #if defined(LIBXML_FTP_ENABLED) 11783 int mem_base; 11784 void * ret_val; 11785 const char * URL; /* The URL used to initialize the context */ 11786 int n_URL; 11787 11788 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 11789 mem_base = xmlMemBlocks(); 11790 URL = gen_filepath(n_URL, 0); 11791 11792 ret_val = xmlNanoFTPNewCtxt(URL); 11793 desret_xmlNanoFTPCtxtPtr(ret_val); 11794 call_tests++; 11795 des_filepath(n_URL, URL, 0); 11796 xmlResetLastError(); 11797 if (mem_base != xmlMemBlocks()) { 11798 printf("Leak of %d blocks found in xmlNanoFTPNewCtxt", 11799 xmlMemBlocks() - mem_base); 11800 test_ret++; 11801 printf(" %d", n_URL); 11802 printf("\n"); 11803 } 11804 } 11805 function_tests++; 11806 #endif 11807 11808 return(test_ret); 11809 } 11810 11811 11812 static int 11813 test_xmlNanoFTPOpen(void) { 11814 int test_ret = 0; 11815 11816 #if defined(LIBXML_FTP_ENABLED) 11817 int mem_base; 11818 void * ret_val; 11819 const char * URL; /* the URL to the resource */ 11820 int n_URL; 11821 11822 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 11823 mem_base = xmlMemBlocks(); 11824 URL = gen_filepath(n_URL, 0); 11825 11826 ret_val = xmlNanoFTPOpen(URL); 11827 desret_xmlNanoFTPCtxtPtr(ret_val); 11828 call_tests++; 11829 des_filepath(n_URL, URL, 0); 11830 xmlResetLastError(); 11831 if (mem_base != xmlMemBlocks()) { 11832 printf("Leak of %d blocks found in xmlNanoFTPOpen", 11833 xmlMemBlocks() - mem_base); 11834 test_ret++; 11835 printf(" %d", n_URL); 11836 printf("\n"); 11837 } 11838 } 11839 function_tests++; 11840 #endif 11841 11842 return(test_ret); 11843 } 11844 11845 11846 static int 11847 test_xmlNanoFTPProxy(void) { 11848 int test_ret = 0; 11849 11850 #if defined(LIBXML_FTP_ENABLED) 11851 char * host; /* the proxy host name */ 11852 int n_host; 11853 int port; /* the proxy port */ 11854 int n_port; 11855 char * user; /* the proxy user name */ 11856 int n_user; 11857 char * passwd; /* the proxy password */ 11858 int n_passwd; 11859 int type; /* the type of proxy 1 for using SITE, 2 for USER a@b */ 11860 int n_type; 11861 11862 for (n_host = 0;n_host < gen_nb_const_char_ptr;n_host++) { 11863 for (n_port = 0;n_port < gen_nb_int;n_port++) { 11864 for (n_user = 0;n_user < gen_nb_const_char_ptr;n_user++) { 11865 for (n_passwd = 0;n_passwd < gen_nb_const_char_ptr;n_passwd++) { 11866 for (n_type = 0;n_type < gen_nb_int;n_type++) { 11867 host = gen_const_char_ptr(n_host, 0); 11868 port = gen_int(n_port, 1); 11869 user = gen_const_char_ptr(n_user, 2); 11870 passwd = gen_const_char_ptr(n_passwd, 3); 11871 type = gen_int(n_type, 4); 11872 11873 xmlNanoFTPProxy((const char *)host, port, (const char *)user, (const char *)passwd, type); 11874 call_tests++; 11875 des_const_char_ptr(n_host, (const char *)host, 0); 11876 des_int(n_port, port, 1); 11877 des_const_char_ptr(n_user, (const char *)user, 2); 11878 des_const_char_ptr(n_passwd, (const char *)passwd, 3); 11879 des_int(n_type, type, 4); 11880 xmlResetLastError(); 11881 } 11882 } 11883 } 11884 } 11885 } 11886 function_tests++; 11887 #endif 11888 11889 return(test_ret); 11890 } 11891 11892 11893 static int 11894 test_xmlNanoFTPQuit(void) { 11895 int test_ret = 0; 11896 11897 #if defined(LIBXML_FTP_ENABLED) 11898 int mem_base; 11899 int ret_val; 11900 void * ctx; /* an FTP context */ 11901 int n_ctx; 11902 11903 for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) { 11904 mem_base = xmlMemBlocks(); 11905 ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0); 11906 11907 ret_val = xmlNanoFTPQuit(ctx); 11908 desret_int(ret_val); 11909 call_tests++; 11910 des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0); 11911 xmlResetLastError(); 11912 if (mem_base != xmlMemBlocks()) { 11913 printf("Leak of %d blocks found in xmlNanoFTPQuit", 11914 xmlMemBlocks() - mem_base); 11915 test_ret++; 11916 printf(" %d", n_ctx); 11917 printf("\n"); 11918 } 11919 } 11920 function_tests++; 11921 #endif 11922 11923 return(test_ret); 11924 } 11925 11926 11927 static int 11928 test_xmlNanoFTPRead(void) { 11929 int test_ret = 0; 11930 11931 #if defined(LIBXML_FTP_ENABLED) 11932 int mem_base; 11933 int ret_val; 11934 void * ctx; /* the FTP context */ 11935 int n_ctx; 11936 void * dest; /* a buffer */ 11937 int n_dest; 11938 int len; /* the buffer length */ 11939 int n_len; 11940 11941 for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) { 11942 for (n_dest = 0;n_dest < gen_nb_void_ptr;n_dest++) { 11943 for (n_len = 0;n_len < gen_nb_int;n_len++) { 11944 mem_base = xmlMemBlocks(); 11945 ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0); 11946 dest = gen_void_ptr(n_dest, 1); 11947 len = gen_int(n_len, 2); 11948 11949 ret_val = xmlNanoFTPRead(ctx, dest, len); 11950 desret_int(ret_val); 11951 call_tests++; 11952 des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0); 11953 des_void_ptr(n_dest, dest, 1); 11954 des_int(n_len, len, 2); 11955 xmlResetLastError(); 11956 if (mem_base != xmlMemBlocks()) { 11957 printf("Leak of %d blocks found in xmlNanoFTPRead", 11958 xmlMemBlocks() - mem_base); 11959 test_ret++; 11960 printf(" %d", n_ctx); 11961 printf(" %d", n_dest); 11962 printf(" %d", n_len); 11963 printf("\n"); 11964 } 11965 } 11966 } 11967 } 11968 function_tests++; 11969 #endif 11970 11971 return(test_ret); 11972 } 11973 11974 11975 static int 11976 test_xmlNanoFTPScanProxy(void) { 11977 int test_ret = 0; 11978 11979 #if defined(LIBXML_FTP_ENABLED) 11980 const char * URL; /* The proxy URL used to initialize the proxy context */ 11981 int n_URL; 11982 11983 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 11984 URL = gen_filepath(n_URL, 0); 11985 11986 xmlNanoFTPScanProxy(URL); 11987 call_tests++; 11988 des_filepath(n_URL, URL, 0); 11989 xmlResetLastError(); 11990 } 11991 function_tests++; 11992 #endif 11993 11994 return(test_ret); 11995 } 11996 11997 11998 static int 11999 test_xmlNanoFTPUpdateURL(void) { 12000 int test_ret = 0; 12001 12002 #if defined(LIBXML_FTP_ENABLED) 12003 int mem_base; 12004 int ret_val; 12005 void * ctx; /* an FTP context */ 12006 int n_ctx; 12007 const char * URL; /* The URL used to update the context */ 12008 int n_URL; 12009 12010 for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) { 12011 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 12012 mem_base = xmlMemBlocks(); 12013 ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0); 12014 URL = gen_filepath(n_URL, 1); 12015 12016 ret_val = xmlNanoFTPUpdateURL(ctx, URL); 12017 desret_int(ret_val); 12018 call_tests++; 12019 des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0); 12020 des_filepath(n_URL, URL, 1); 12021 xmlResetLastError(); 12022 if (mem_base != xmlMemBlocks()) { 12023 printf("Leak of %d blocks found in xmlNanoFTPUpdateURL", 12024 xmlMemBlocks() - mem_base); 12025 test_ret++; 12026 printf(" %d", n_ctx); 12027 printf(" %d", n_URL); 12028 printf("\n"); 12029 } 12030 } 12031 } 12032 function_tests++; 12033 #endif 12034 12035 return(test_ret); 12036 } 12037 12038 static int 12039 test_nanoftp(void) { 12040 int test_ret = 0; 12041 12042 if (quiet == 0) printf("Testing nanoftp : 14 of 22 functions ...\n"); 12043 test_ret += test_xmlNanoFTPCheckResponse(); 12044 test_ret += test_xmlNanoFTPCleanup(); 12045 test_ret += test_xmlNanoFTPCloseConnection(); 12046 test_ret += test_xmlNanoFTPCwd(); 12047 test_ret += test_xmlNanoFTPDele(); 12048 test_ret += test_xmlNanoFTPGet(); 12049 test_ret += test_xmlNanoFTPGetConnection(); 12050 test_ret += test_xmlNanoFTPGetResponse(); 12051 test_ret += test_xmlNanoFTPGetSocket(); 12052 test_ret += test_xmlNanoFTPInit(); 12053 test_ret += test_xmlNanoFTPList(); 12054 test_ret += test_xmlNanoFTPNewCtxt(); 12055 test_ret += test_xmlNanoFTPOpen(); 12056 test_ret += test_xmlNanoFTPProxy(); 12057 test_ret += test_xmlNanoFTPQuit(); 12058 test_ret += test_xmlNanoFTPRead(); 12059 test_ret += test_xmlNanoFTPScanProxy(); 12060 test_ret += test_xmlNanoFTPUpdateURL(); 12061 12062 if (test_ret != 0) 12063 printf("Module nanoftp: %d errors\n", test_ret); 12064 return(test_ret); 12065 } 12066 12067 static int 12068 test_xmlNanoHTTPAuthHeader(void) { 12069 int test_ret = 0; 12070 12071 #if defined(LIBXML_HTTP_ENABLED) 12072 int mem_base; 12073 const char * ret_val; 12074 void * ctx; /* the HTTP context */ 12075 int n_ctx; 12076 12077 for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) { 12078 mem_base = xmlMemBlocks(); 12079 ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0); 12080 12081 ret_val = xmlNanoHTTPAuthHeader(ctx); 12082 desret_const_char_ptr(ret_val); 12083 call_tests++; 12084 des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0); 12085 xmlResetLastError(); 12086 if (mem_base != xmlMemBlocks()) { 12087 printf("Leak of %d blocks found in xmlNanoHTTPAuthHeader", 12088 xmlMemBlocks() - mem_base); 12089 test_ret++; 12090 printf(" %d", n_ctx); 12091 printf("\n"); 12092 } 12093 } 12094 function_tests++; 12095 #endif 12096 12097 return(test_ret); 12098 } 12099 12100 12101 static int 12102 test_xmlNanoHTTPCleanup(void) { 12103 int test_ret = 0; 12104 12105 #if defined(LIBXML_HTTP_ENABLED) 12106 int mem_base; 12107 12108 mem_base = xmlMemBlocks(); 12109 12110 xmlNanoHTTPCleanup(); 12111 call_tests++; 12112 xmlResetLastError(); 12113 if (mem_base != xmlMemBlocks()) { 12114 printf("Leak of %d blocks found in xmlNanoHTTPCleanup", 12115 xmlMemBlocks() - mem_base); 12116 test_ret++; 12117 printf("\n"); 12118 } 12119 function_tests++; 12120 #endif 12121 12122 return(test_ret); 12123 } 12124 12125 12126 static int 12127 test_xmlNanoHTTPContentLength(void) { 12128 int test_ret = 0; 12129 12130 #if defined(LIBXML_HTTP_ENABLED) 12131 int mem_base; 12132 int ret_val; 12133 void * ctx; /* the HTTP context */ 12134 int n_ctx; 12135 12136 for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) { 12137 mem_base = xmlMemBlocks(); 12138 ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0); 12139 12140 ret_val = xmlNanoHTTPContentLength(ctx); 12141 desret_int(ret_val); 12142 call_tests++; 12143 des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0); 12144 xmlResetLastError(); 12145 if (mem_base != xmlMemBlocks()) { 12146 printf("Leak of %d blocks found in xmlNanoHTTPContentLength", 12147 xmlMemBlocks() - mem_base); 12148 test_ret++; 12149 printf(" %d", n_ctx); 12150 printf("\n"); 12151 } 12152 } 12153 function_tests++; 12154 #endif 12155 12156 return(test_ret); 12157 } 12158 12159 12160 static int 12161 test_xmlNanoHTTPEncoding(void) { 12162 int test_ret = 0; 12163 12164 #if defined(LIBXML_HTTP_ENABLED) 12165 int mem_base; 12166 const char * ret_val; 12167 void * ctx; /* the HTTP context */ 12168 int n_ctx; 12169 12170 for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) { 12171 mem_base = xmlMemBlocks(); 12172 ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0); 12173 12174 ret_val = xmlNanoHTTPEncoding(ctx); 12175 desret_const_char_ptr(ret_val); 12176 call_tests++; 12177 des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0); 12178 xmlResetLastError(); 12179 if (mem_base != xmlMemBlocks()) { 12180 printf("Leak of %d blocks found in xmlNanoHTTPEncoding", 12181 xmlMemBlocks() - mem_base); 12182 test_ret++; 12183 printf(" %d", n_ctx); 12184 printf("\n"); 12185 } 12186 } 12187 function_tests++; 12188 #endif 12189 12190 return(test_ret); 12191 } 12192 12193 12194 #define gen_nb_char_ptr_ptr 1 12195 static char ** gen_char_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 12196 return(NULL); 12197 } 12198 static void des_char_ptr_ptr(int no ATTRIBUTE_UNUSED, char ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 12199 } 12200 12201 static int 12202 test_xmlNanoHTTPFetch(void) { 12203 int test_ret = 0; 12204 12205 #if defined(LIBXML_HTTP_ENABLED) 12206 int mem_base; 12207 int ret_val; 12208 const char * URL; /* The URL to load */ 12209 int n_URL; 12210 const char * filename; /* the filename where the content should be saved */ 12211 int n_filename; 12212 char ** contentType; /* if available the Content-Type information will be returned at that location */ 12213 int n_contentType; 12214 12215 for (n_URL = 0;n_URL < gen_nb_fileoutput;n_URL++) { 12216 for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) { 12217 for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) { 12218 mem_base = xmlMemBlocks(); 12219 URL = gen_fileoutput(n_URL, 0); 12220 filename = gen_fileoutput(n_filename, 1); 12221 contentType = gen_char_ptr_ptr(n_contentType, 2); 12222 12223 ret_val = xmlNanoHTTPFetch(URL, filename, contentType); 12224 desret_int(ret_val); 12225 call_tests++; 12226 des_fileoutput(n_URL, URL, 0); 12227 des_fileoutput(n_filename, filename, 1); 12228 des_char_ptr_ptr(n_contentType, contentType, 2); 12229 xmlResetLastError(); 12230 if (mem_base != xmlMemBlocks()) { 12231 printf("Leak of %d blocks found in xmlNanoHTTPFetch", 12232 xmlMemBlocks() - mem_base); 12233 test_ret++; 12234 printf(" %d", n_URL); 12235 printf(" %d", n_filename); 12236 printf(" %d", n_contentType); 12237 printf("\n"); 12238 } 12239 } 12240 } 12241 } 12242 function_tests++; 12243 #endif 12244 12245 return(test_ret); 12246 } 12247 12248 12249 static int 12250 test_xmlNanoHTTPInit(void) { 12251 int test_ret = 0; 12252 12253 #if defined(LIBXML_HTTP_ENABLED) 12254 int mem_base; 12255 12256 mem_base = xmlMemBlocks(); 12257 12258 xmlNanoHTTPInit(); 12259 call_tests++; 12260 xmlResetLastError(); 12261 if (mem_base != xmlMemBlocks()) { 12262 printf("Leak of %d blocks found in xmlNanoHTTPInit", 12263 xmlMemBlocks() - mem_base); 12264 test_ret++; 12265 printf("\n"); 12266 } 12267 function_tests++; 12268 #endif 12269 12270 return(test_ret); 12271 } 12272 12273 12274 static int 12275 test_xmlNanoHTTPMimeType(void) { 12276 int test_ret = 0; 12277 12278 #if defined(LIBXML_HTTP_ENABLED) 12279 int mem_base; 12280 const char * ret_val; 12281 void * ctx; /* the HTTP context */ 12282 int n_ctx; 12283 12284 for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) { 12285 mem_base = xmlMemBlocks(); 12286 ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0); 12287 12288 ret_val = xmlNanoHTTPMimeType(ctx); 12289 desret_const_char_ptr(ret_val); 12290 call_tests++; 12291 des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0); 12292 xmlResetLastError(); 12293 if (mem_base != xmlMemBlocks()) { 12294 printf("Leak of %d blocks found in xmlNanoHTTPMimeType", 12295 xmlMemBlocks() - mem_base); 12296 test_ret++; 12297 printf(" %d", n_ctx); 12298 printf("\n"); 12299 } 12300 } 12301 function_tests++; 12302 #endif 12303 12304 return(test_ret); 12305 } 12306 12307 12308 static int 12309 test_xmlNanoHTTPOpen(void) { 12310 int test_ret = 0; 12311 12312 #if defined(LIBXML_HTTP_ENABLED) 12313 int mem_base; 12314 void * ret_val; 12315 const char * URL; /* The URL to load */ 12316 int n_URL; 12317 char ** contentType; /* if available the Content-Type information will be returned at that location */ 12318 int n_contentType; 12319 12320 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 12321 for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) { 12322 mem_base = xmlMemBlocks(); 12323 URL = gen_filepath(n_URL, 0); 12324 contentType = gen_char_ptr_ptr(n_contentType, 1); 12325 12326 ret_val = xmlNanoHTTPOpen(URL, contentType); 12327 desret_xmlNanoHTTPCtxtPtr(ret_val); 12328 call_tests++; 12329 des_filepath(n_URL, URL, 0); 12330 des_char_ptr_ptr(n_contentType, contentType, 1); 12331 xmlResetLastError(); 12332 if (mem_base != xmlMemBlocks()) { 12333 printf("Leak of %d blocks found in xmlNanoHTTPOpen", 12334 xmlMemBlocks() - mem_base); 12335 test_ret++; 12336 printf(" %d", n_URL); 12337 printf(" %d", n_contentType); 12338 printf("\n"); 12339 } 12340 } 12341 } 12342 function_tests++; 12343 #endif 12344 12345 return(test_ret); 12346 } 12347 12348 12349 static int 12350 test_xmlNanoHTTPOpenRedir(void) { 12351 int test_ret = 0; 12352 12353 #if defined(LIBXML_HTTP_ENABLED) 12354 int mem_base; 12355 void * ret_val; 12356 const char * URL; /* The URL to load */ 12357 int n_URL; 12358 char ** contentType; /* if available the Content-Type information will be returned at that location */ 12359 int n_contentType; 12360 char ** redir; /* if available the redirected URL will be returned */ 12361 int n_redir; 12362 12363 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 12364 for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) { 12365 for (n_redir = 0;n_redir < gen_nb_char_ptr_ptr;n_redir++) { 12366 mem_base = xmlMemBlocks(); 12367 URL = gen_filepath(n_URL, 0); 12368 contentType = gen_char_ptr_ptr(n_contentType, 1); 12369 redir = gen_char_ptr_ptr(n_redir, 2); 12370 12371 ret_val = xmlNanoHTTPOpenRedir(URL, contentType, redir); 12372 desret_xmlNanoHTTPCtxtPtr(ret_val); 12373 call_tests++; 12374 des_filepath(n_URL, URL, 0); 12375 des_char_ptr_ptr(n_contentType, contentType, 1); 12376 des_char_ptr_ptr(n_redir, redir, 2); 12377 xmlResetLastError(); 12378 if (mem_base != xmlMemBlocks()) { 12379 printf("Leak of %d blocks found in xmlNanoHTTPOpenRedir", 12380 xmlMemBlocks() - mem_base); 12381 test_ret++; 12382 printf(" %d", n_URL); 12383 printf(" %d", n_contentType); 12384 printf(" %d", n_redir); 12385 printf("\n"); 12386 } 12387 } 12388 } 12389 } 12390 function_tests++; 12391 #endif 12392 12393 return(test_ret); 12394 } 12395 12396 12397 static int 12398 test_xmlNanoHTTPRead(void) { 12399 int test_ret = 0; 12400 12401 #if defined(LIBXML_HTTP_ENABLED) 12402 int mem_base; 12403 int ret_val; 12404 void * ctx; /* the HTTP context */ 12405 int n_ctx; 12406 void * dest; /* a buffer */ 12407 int n_dest; 12408 int len; /* the buffer length */ 12409 int n_len; 12410 12411 for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) { 12412 for (n_dest = 0;n_dest < gen_nb_void_ptr;n_dest++) { 12413 for (n_len = 0;n_len < gen_nb_int;n_len++) { 12414 mem_base = xmlMemBlocks(); 12415 ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0); 12416 dest = gen_void_ptr(n_dest, 1); 12417 len = gen_int(n_len, 2); 12418 12419 ret_val = xmlNanoHTTPRead(ctx, dest, len); 12420 desret_int(ret_val); 12421 call_tests++; 12422 des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0); 12423 des_void_ptr(n_dest, dest, 1); 12424 des_int(n_len, len, 2); 12425 xmlResetLastError(); 12426 if (mem_base != xmlMemBlocks()) { 12427 printf("Leak of %d blocks found in xmlNanoHTTPRead", 12428 xmlMemBlocks() - mem_base); 12429 test_ret++; 12430 printf(" %d", n_ctx); 12431 printf(" %d", n_dest); 12432 printf(" %d", n_len); 12433 printf("\n"); 12434 } 12435 } 12436 } 12437 } 12438 function_tests++; 12439 #endif 12440 12441 return(test_ret); 12442 } 12443 12444 12445 static int 12446 test_xmlNanoHTTPRedir(void) { 12447 int test_ret = 0; 12448 12449 12450 /* missing type support */ 12451 return(test_ret); 12452 } 12453 12454 12455 static int 12456 test_xmlNanoHTTPReturnCode(void) { 12457 int test_ret = 0; 12458 12459 #if defined(LIBXML_HTTP_ENABLED) 12460 int mem_base; 12461 int ret_val; 12462 void * ctx; /* the HTTP context */ 12463 int n_ctx; 12464 12465 for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) { 12466 mem_base = xmlMemBlocks(); 12467 ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0); 12468 12469 ret_val = xmlNanoHTTPReturnCode(ctx); 12470 desret_int(ret_val); 12471 call_tests++; 12472 des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0); 12473 xmlResetLastError(); 12474 if (mem_base != xmlMemBlocks()) { 12475 printf("Leak of %d blocks found in xmlNanoHTTPReturnCode", 12476 xmlMemBlocks() - mem_base); 12477 test_ret++; 12478 printf(" %d", n_ctx); 12479 printf("\n"); 12480 } 12481 } 12482 function_tests++; 12483 #endif 12484 12485 return(test_ret); 12486 } 12487 12488 12489 static int 12490 test_xmlNanoHTTPSave(void) { 12491 int test_ret = 0; 12492 12493 #if defined(LIBXML_HTTP_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 12494 int mem_base; 12495 int ret_val; 12496 void * ctxt; /* the HTTP context */ 12497 int n_ctxt; 12498 const char * filename; /* the filename where the content should be saved */ 12499 int n_filename; 12500 12501 for (n_ctxt = 0;n_ctxt < gen_nb_void_ptr;n_ctxt++) { 12502 for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) { 12503 mem_base = xmlMemBlocks(); 12504 ctxt = gen_void_ptr(n_ctxt, 0); 12505 filename = gen_fileoutput(n_filename, 1); 12506 12507 ret_val = xmlNanoHTTPSave(ctxt, filename); 12508 desret_int(ret_val); 12509 call_tests++; 12510 des_void_ptr(n_ctxt, ctxt, 0); 12511 des_fileoutput(n_filename, filename, 1); 12512 xmlResetLastError(); 12513 if (mem_base != xmlMemBlocks()) { 12514 printf("Leak of %d blocks found in xmlNanoHTTPSave", 12515 xmlMemBlocks() - mem_base); 12516 test_ret++; 12517 printf(" %d", n_ctxt); 12518 printf(" %d", n_filename); 12519 printf("\n"); 12520 } 12521 } 12522 } 12523 function_tests++; 12524 #endif 12525 12526 return(test_ret); 12527 } 12528 12529 12530 static int 12531 test_xmlNanoHTTPScanProxy(void) { 12532 int test_ret = 0; 12533 12534 #if defined(LIBXML_HTTP_ENABLED) 12535 const char * URL; /* The proxy URL used to initialize the proxy context */ 12536 int n_URL; 12537 12538 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 12539 URL = gen_filepath(n_URL, 0); 12540 12541 xmlNanoHTTPScanProxy(URL); 12542 call_tests++; 12543 des_filepath(n_URL, URL, 0); 12544 xmlResetLastError(); 12545 } 12546 function_tests++; 12547 #endif 12548 12549 return(test_ret); 12550 } 12551 12552 static int 12553 test_nanohttp(void) { 12554 int test_ret = 0; 12555 12556 if (quiet == 0) printf("Testing nanohttp : 13 of 17 functions ...\n"); 12557 test_ret += test_xmlNanoHTTPAuthHeader(); 12558 test_ret += test_xmlNanoHTTPCleanup(); 12559 test_ret += test_xmlNanoHTTPContentLength(); 12560 test_ret += test_xmlNanoHTTPEncoding(); 12561 test_ret += test_xmlNanoHTTPFetch(); 12562 test_ret += test_xmlNanoHTTPInit(); 12563 test_ret += test_xmlNanoHTTPMimeType(); 12564 test_ret += test_xmlNanoHTTPOpen(); 12565 test_ret += test_xmlNanoHTTPOpenRedir(); 12566 test_ret += test_xmlNanoHTTPRead(); 12567 test_ret += test_xmlNanoHTTPRedir(); 12568 test_ret += test_xmlNanoHTTPReturnCode(); 12569 test_ret += test_xmlNanoHTTPSave(); 12570 test_ret += test_xmlNanoHTTPScanProxy(); 12571 12572 if (test_ret != 0) 12573 printf("Module nanohttp: %d errors\n", test_ret); 12574 return(test_ret); 12575 } 12576 12577 static int 12578 test_xmlByteConsumed(void) { 12579 int test_ret = 0; 12580 12581 int mem_base; 12582 long ret_val; 12583 xmlParserCtxtPtr ctxt; /* an XML parser context */ 12584 int n_ctxt; 12585 12586 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 12587 mem_base = xmlMemBlocks(); 12588 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 12589 12590 ret_val = xmlByteConsumed(ctxt); 12591 desret_long(ret_val); 12592 call_tests++; 12593 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 12594 xmlResetLastError(); 12595 if (mem_base != xmlMemBlocks()) { 12596 printf("Leak of %d blocks found in xmlByteConsumed", 12597 xmlMemBlocks() - mem_base); 12598 test_ret++; 12599 printf(" %d", n_ctxt); 12600 printf("\n"); 12601 } 12602 } 12603 function_tests++; 12604 12605 return(test_ret); 12606 } 12607 12608 12609 static int 12610 test_xmlClearNodeInfoSeq(void) { 12611 int test_ret = 0; 12612 12613 int mem_base; 12614 xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */ 12615 int n_seq; 12616 12617 for (n_seq = 0;n_seq < gen_nb_xmlParserNodeInfoSeqPtr;n_seq++) { 12618 mem_base = xmlMemBlocks(); 12619 seq = gen_xmlParserNodeInfoSeqPtr(n_seq, 0); 12620 12621 xmlClearNodeInfoSeq(seq); 12622 call_tests++; 12623 des_xmlParserNodeInfoSeqPtr(n_seq, seq, 0); 12624 xmlResetLastError(); 12625 if (mem_base != xmlMemBlocks()) { 12626 printf("Leak of %d blocks found in xmlClearNodeInfoSeq", 12627 xmlMemBlocks() - mem_base); 12628 test_ret++; 12629 printf(" %d", n_seq); 12630 printf("\n"); 12631 } 12632 } 12633 function_tests++; 12634 12635 return(test_ret); 12636 } 12637 12638 12639 static int 12640 test_xmlClearParserCtxt(void) { 12641 int test_ret = 0; 12642 12643 int mem_base; 12644 xmlParserCtxtPtr ctxt; /* an XML parser context */ 12645 int n_ctxt; 12646 12647 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 12648 mem_base = xmlMemBlocks(); 12649 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 12650 12651 xmlClearParserCtxt(ctxt); 12652 call_tests++; 12653 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 12654 xmlResetLastError(); 12655 if (mem_base != xmlMemBlocks()) { 12656 printf("Leak of %d blocks found in xmlClearParserCtxt", 12657 xmlMemBlocks() - mem_base); 12658 test_ret++; 12659 printf(" %d", n_ctxt); 12660 printf("\n"); 12661 } 12662 } 12663 function_tests++; 12664 12665 return(test_ret); 12666 } 12667 12668 12669 static int 12670 test_xmlCreateDocParserCtxt(void) { 12671 int test_ret = 0; 12672 12673 int mem_base; 12674 xmlParserCtxtPtr ret_val; 12675 xmlChar * cur; /* a pointer to an array of xmlChar */ 12676 int n_cur; 12677 12678 for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) { 12679 mem_base = xmlMemBlocks(); 12680 cur = gen_const_xmlChar_ptr(n_cur, 0); 12681 12682 ret_val = xmlCreateDocParserCtxt((const xmlChar *)cur); 12683 desret_xmlParserCtxtPtr(ret_val); 12684 call_tests++; 12685 des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0); 12686 xmlResetLastError(); 12687 if (mem_base != xmlMemBlocks()) { 12688 printf("Leak of %d blocks found in xmlCreateDocParserCtxt", 12689 xmlMemBlocks() - mem_base); 12690 test_ret++; 12691 printf(" %d", n_cur); 12692 printf("\n"); 12693 } 12694 } 12695 function_tests++; 12696 12697 return(test_ret); 12698 } 12699 12700 12701 static int 12702 test_xmlCreatePushParserCtxt(void) { 12703 int test_ret = 0; 12704 12705 #if defined(LIBXML_PUSH_ENABLED) 12706 int mem_base; 12707 xmlParserCtxtPtr ret_val; 12708 xmlSAXHandlerPtr sax; /* a SAX handler */ 12709 int n_sax; 12710 void * user_data; /* The user data returned on SAX callbacks */ 12711 int n_user_data; 12712 char * chunk; /* a pointer to an array of chars */ 12713 int n_chunk; 12714 int size; /* number of chars in the array */ 12715 int n_size; 12716 const char * filename; /* an optional file name or URI */ 12717 int n_filename; 12718 12719 for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) { 12720 for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) { 12721 for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) { 12722 for (n_size = 0;n_size < gen_nb_int;n_size++) { 12723 for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) { 12724 mem_base = xmlMemBlocks(); 12725 sax = gen_xmlSAXHandlerPtr(n_sax, 0); 12726 user_data = gen_userdata(n_user_data, 1); 12727 chunk = gen_const_char_ptr(n_chunk, 2); 12728 size = gen_int(n_size, 3); 12729 filename = gen_fileoutput(n_filename, 4); 12730 12731 ret_val = xmlCreatePushParserCtxt(sax, user_data, (const char *)chunk, size, filename); 12732 desret_xmlParserCtxtPtr(ret_val); 12733 call_tests++; 12734 des_xmlSAXHandlerPtr(n_sax, sax, 0); 12735 des_userdata(n_user_data, user_data, 1); 12736 des_const_char_ptr(n_chunk, (const char *)chunk, 2); 12737 des_int(n_size, size, 3); 12738 des_fileoutput(n_filename, filename, 4); 12739 xmlResetLastError(); 12740 if (mem_base != xmlMemBlocks()) { 12741 printf("Leak of %d blocks found in xmlCreatePushParserCtxt", 12742 xmlMemBlocks() - mem_base); 12743 test_ret++; 12744 printf(" %d", n_sax); 12745 printf(" %d", n_user_data); 12746 printf(" %d", n_chunk); 12747 printf(" %d", n_size); 12748 printf(" %d", n_filename); 12749 printf("\n"); 12750 } 12751 } 12752 } 12753 } 12754 } 12755 } 12756 function_tests++; 12757 #endif 12758 12759 return(test_ret); 12760 } 12761 12762 12763 static int 12764 test_xmlCtxtReadDoc(void) { 12765 int test_ret = 0; 12766 12767 int mem_base; 12768 xmlDocPtr ret_val; 12769 xmlParserCtxtPtr ctxt; /* an XML parser context */ 12770 int n_ctxt; 12771 xmlChar * cur; /* a pointer to a zero terminated string */ 12772 int n_cur; 12773 const char * URL; /* the base URL to use for the document */ 12774 int n_URL; 12775 char * encoding; /* the document encoding, or NULL */ 12776 int n_encoding; 12777 int options; /* a combination of xmlParserOption */ 12778 int n_options; 12779 12780 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 12781 for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) { 12782 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 12783 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 12784 for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) { 12785 mem_base = xmlMemBlocks(); 12786 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 12787 cur = gen_const_xmlChar_ptr(n_cur, 1); 12788 URL = gen_filepath(n_URL, 2); 12789 encoding = gen_const_char_ptr(n_encoding, 3); 12790 options = gen_parseroptions(n_options, 4); 12791 12792 ret_val = xmlCtxtReadDoc(ctxt, (const xmlChar *)cur, URL, (const char *)encoding, options); 12793 desret_xmlDocPtr(ret_val); 12794 call_tests++; 12795 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 12796 des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1); 12797 des_filepath(n_URL, URL, 2); 12798 des_const_char_ptr(n_encoding, (const char *)encoding, 3); 12799 des_parseroptions(n_options, options, 4); 12800 xmlResetLastError(); 12801 if (mem_base != xmlMemBlocks()) { 12802 printf("Leak of %d blocks found in xmlCtxtReadDoc", 12803 xmlMemBlocks() - mem_base); 12804 test_ret++; 12805 printf(" %d", n_ctxt); 12806 printf(" %d", n_cur); 12807 printf(" %d", n_URL); 12808 printf(" %d", n_encoding); 12809 printf(" %d", n_options); 12810 printf("\n"); 12811 } 12812 } 12813 } 12814 } 12815 } 12816 } 12817 function_tests++; 12818 12819 return(test_ret); 12820 } 12821 12822 12823 static int 12824 test_xmlCtxtReadFile(void) { 12825 int test_ret = 0; 12826 12827 int mem_base; 12828 xmlDocPtr ret_val; 12829 xmlParserCtxtPtr ctxt; /* an XML parser context */ 12830 int n_ctxt; 12831 const char * filename; /* a file or URL */ 12832 int n_filename; 12833 char * encoding; /* the document encoding, or NULL */ 12834 int n_encoding; 12835 int options; /* a combination of xmlParserOption */ 12836 int n_options; 12837 12838 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 12839 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 12840 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 12841 for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) { 12842 mem_base = xmlMemBlocks(); 12843 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 12844 filename = gen_filepath(n_filename, 1); 12845 encoding = gen_const_char_ptr(n_encoding, 2); 12846 options = gen_parseroptions(n_options, 3); 12847 12848 ret_val = xmlCtxtReadFile(ctxt, filename, (const char *)encoding, options); 12849 desret_xmlDocPtr(ret_val); 12850 call_tests++; 12851 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 12852 des_filepath(n_filename, filename, 1); 12853 des_const_char_ptr(n_encoding, (const char *)encoding, 2); 12854 des_parseroptions(n_options, options, 3); 12855 xmlResetLastError(); 12856 if (mem_base != xmlMemBlocks()) { 12857 printf("Leak of %d blocks found in xmlCtxtReadFile", 12858 xmlMemBlocks() - mem_base); 12859 test_ret++; 12860 printf(" %d", n_ctxt); 12861 printf(" %d", n_filename); 12862 printf(" %d", n_encoding); 12863 printf(" %d", n_options); 12864 printf("\n"); 12865 } 12866 } 12867 } 12868 } 12869 } 12870 function_tests++; 12871 12872 return(test_ret); 12873 } 12874 12875 12876 static int 12877 test_xmlCtxtReadMemory(void) { 12878 int test_ret = 0; 12879 12880 int mem_base; 12881 xmlDocPtr ret_val; 12882 xmlParserCtxtPtr ctxt; /* an XML parser context */ 12883 int n_ctxt; 12884 char * buffer; /* a pointer to a char array */ 12885 int n_buffer; 12886 int size; /* the size of the array */ 12887 int n_size; 12888 const char * URL; /* the base URL to use for the document */ 12889 int n_URL; 12890 char * encoding; /* the document encoding, or NULL */ 12891 int n_encoding; 12892 int options; /* a combination of xmlParserOption */ 12893 int n_options; 12894 12895 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 12896 for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) { 12897 for (n_size = 0;n_size < gen_nb_int;n_size++) { 12898 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 12899 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 12900 for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) { 12901 mem_base = xmlMemBlocks(); 12902 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 12903 buffer = gen_const_char_ptr(n_buffer, 1); 12904 size = gen_int(n_size, 2); 12905 URL = gen_filepath(n_URL, 3); 12906 encoding = gen_const_char_ptr(n_encoding, 4); 12907 options = gen_parseroptions(n_options, 5); 12908 12909 ret_val = xmlCtxtReadMemory(ctxt, (const char *)buffer, size, URL, (const char *)encoding, options); 12910 desret_xmlDocPtr(ret_val); 12911 call_tests++; 12912 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 12913 des_const_char_ptr(n_buffer, (const char *)buffer, 1); 12914 des_int(n_size, size, 2); 12915 des_filepath(n_URL, URL, 3); 12916 des_const_char_ptr(n_encoding, (const char *)encoding, 4); 12917 des_parseroptions(n_options, options, 5); 12918 xmlResetLastError(); 12919 if (mem_base != xmlMemBlocks()) { 12920 printf("Leak of %d blocks found in xmlCtxtReadMemory", 12921 xmlMemBlocks() - mem_base); 12922 test_ret++; 12923 printf(" %d", n_ctxt); 12924 printf(" %d", n_buffer); 12925 printf(" %d", n_size); 12926 printf(" %d", n_URL); 12927 printf(" %d", n_encoding); 12928 printf(" %d", n_options); 12929 printf("\n"); 12930 } 12931 } 12932 } 12933 } 12934 } 12935 } 12936 } 12937 function_tests++; 12938 12939 return(test_ret); 12940 } 12941 12942 12943 static int 12944 test_xmlCtxtReset(void) { 12945 int test_ret = 0; 12946 12947 int mem_base; 12948 xmlParserCtxtPtr ctxt; /* an XML parser context */ 12949 int n_ctxt; 12950 12951 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 12952 mem_base = xmlMemBlocks(); 12953 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 12954 12955 xmlCtxtReset(ctxt); 12956 call_tests++; 12957 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 12958 xmlResetLastError(); 12959 if (mem_base != xmlMemBlocks()) { 12960 printf("Leak of %d blocks found in xmlCtxtReset", 12961 xmlMemBlocks() - mem_base); 12962 test_ret++; 12963 printf(" %d", n_ctxt); 12964 printf("\n"); 12965 } 12966 } 12967 function_tests++; 12968 12969 return(test_ret); 12970 } 12971 12972 12973 static int 12974 test_xmlCtxtResetPush(void) { 12975 int test_ret = 0; 12976 12977 int mem_base; 12978 int ret_val; 12979 xmlParserCtxtPtr ctxt; /* an XML parser context */ 12980 int n_ctxt; 12981 char * chunk; /* a pointer to an array of chars */ 12982 int n_chunk; 12983 int size; /* number of chars in the array */ 12984 int n_size; 12985 const char * filename; /* an optional file name or URI */ 12986 int n_filename; 12987 char * encoding; /* the document encoding, or NULL */ 12988 int n_encoding; 12989 12990 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 12991 for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) { 12992 for (n_size = 0;n_size < gen_nb_int;n_size++) { 12993 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 12994 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 12995 mem_base = xmlMemBlocks(); 12996 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 12997 chunk = gen_const_char_ptr(n_chunk, 1); 12998 size = gen_int(n_size, 2); 12999 filename = gen_filepath(n_filename, 3); 13000 encoding = gen_const_char_ptr(n_encoding, 4); 13001 13002 ret_val = xmlCtxtResetPush(ctxt, (const char *)chunk, size, filename, (const char *)encoding); 13003 desret_int(ret_val); 13004 call_tests++; 13005 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 13006 des_const_char_ptr(n_chunk, (const char *)chunk, 1); 13007 des_int(n_size, size, 2); 13008 des_filepath(n_filename, filename, 3); 13009 des_const_char_ptr(n_encoding, (const char *)encoding, 4); 13010 xmlResetLastError(); 13011 if (mem_base != xmlMemBlocks()) { 13012 printf("Leak of %d blocks found in xmlCtxtResetPush", 13013 xmlMemBlocks() - mem_base); 13014 test_ret++; 13015 printf(" %d", n_ctxt); 13016 printf(" %d", n_chunk); 13017 printf(" %d", n_size); 13018 printf(" %d", n_filename); 13019 printf(" %d", n_encoding); 13020 printf("\n"); 13021 } 13022 } 13023 } 13024 } 13025 } 13026 } 13027 function_tests++; 13028 13029 return(test_ret); 13030 } 13031 13032 13033 static int 13034 test_xmlCtxtUseOptions(void) { 13035 int test_ret = 0; 13036 13037 int mem_base; 13038 int ret_val; 13039 xmlParserCtxtPtr ctxt; /* an XML parser context */ 13040 int n_ctxt; 13041 int options; /* a combination of xmlParserOption */ 13042 int n_options; 13043 13044 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 13045 for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) { 13046 mem_base = xmlMemBlocks(); 13047 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 13048 options = gen_parseroptions(n_options, 1); 13049 13050 ret_val = xmlCtxtUseOptions(ctxt, options); 13051 desret_int(ret_val); 13052 call_tests++; 13053 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 13054 des_parseroptions(n_options, options, 1); 13055 xmlResetLastError(); 13056 if (mem_base != xmlMemBlocks()) { 13057 printf("Leak of %d blocks found in xmlCtxtUseOptions", 13058 xmlMemBlocks() - mem_base); 13059 test_ret++; 13060 printf(" %d", n_ctxt); 13061 printf(" %d", n_options); 13062 printf("\n"); 13063 } 13064 } 13065 } 13066 function_tests++; 13067 13068 return(test_ret); 13069 } 13070 13071 13072 static int 13073 test_xmlGetExternalEntityLoader(void) { 13074 int test_ret = 0; 13075 13076 13077 /* missing type support */ 13078 return(test_ret); 13079 } 13080 13081 13082 static int 13083 test_xmlGetFeature(void) { 13084 int test_ret = 0; 13085 13086 #if defined(LIBXML_LEGACY_ENABLED) 13087 #ifdef LIBXML_LEGACY_ENABLED 13088 int mem_base; 13089 int ret_val; 13090 xmlParserCtxtPtr ctxt; /* an XML/HTML parser context */ 13091 int n_ctxt; 13092 char * name; /* the feature name */ 13093 int n_name; 13094 void * result; /* location to store the result */ 13095 int n_result; 13096 13097 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 13098 for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) { 13099 for (n_result = 0;n_result < gen_nb_void_ptr;n_result++) { 13100 mem_base = xmlMemBlocks(); 13101 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 13102 name = gen_const_char_ptr(n_name, 1); 13103 result = gen_void_ptr(n_result, 2); 13104 13105 ret_val = xmlGetFeature(ctxt, (const char *)name, result); 13106 desret_int(ret_val); 13107 call_tests++; 13108 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 13109 des_const_char_ptr(n_name, (const char *)name, 1); 13110 des_void_ptr(n_result, result, 2); 13111 xmlResetLastError(); 13112 if (mem_base != xmlMemBlocks()) { 13113 printf("Leak of %d blocks found in xmlGetFeature", 13114 xmlMemBlocks() - mem_base); 13115 test_ret++; 13116 printf(" %d", n_ctxt); 13117 printf(" %d", n_name); 13118 printf(" %d", n_result); 13119 printf("\n"); 13120 } 13121 } 13122 } 13123 } 13124 function_tests++; 13125 #endif 13126 #endif 13127 13128 return(test_ret); 13129 } 13130 13131 13132 #define gen_nb_const_char_ptr_ptr 1 13133 static char ** gen_const_char_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 13134 return(NULL); 13135 } 13136 static void des_const_char_ptr_ptr(int no ATTRIBUTE_UNUSED, const char ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 13137 } 13138 13139 static int 13140 test_xmlGetFeaturesList(void) { 13141 int test_ret = 0; 13142 13143 #if defined(LIBXML_LEGACY_ENABLED) 13144 #ifdef LIBXML_LEGACY_ENABLED 13145 int mem_base; 13146 int ret_val; 13147 int * len; /* the length of the features name array (input/output) */ 13148 int n_len; 13149 char ** result; /* an array of string to be filled with the features name. */ 13150 int n_result; 13151 13152 for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) { 13153 for (n_result = 0;n_result < gen_nb_const_char_ptr_ptr;n_result++) { 13154 mem_base = xmlMemBlocks(); 13155 len = gen_int_ptr(n_len, 0); 13156 result = gen_const_char_ptr_ptr(n_result, 1); 13157 13158 ret_val = xmlGetFeaturesList(len, (const char **)result); 13159 desret_int(ret_val); 13160 call_tests++; 13161 des_int_ptr(n_len, len, 0); 13162 des_const_char_ptr_ptr(n_result, (const char **)result, 1); 13163 xmlResetLastError(); 13164 if (mem_base != xmlMemBlocks()) { 13165 printf("Leak of %d blocks found in xmlGetFeaturesList", 13166 xmlMemBlocks() - mem_base); 13167 test_ret++; 13168 printf(" %d", n_len); 13169 printf(" %d", n_result); 13170 printf("\n"); 13171 } 13172 } 13173 } 13174 function_tests++; 13175 #endif 13176 #endif 13177 13178 return(test_ret); 13179 } 13180 13181 13182 static int 13183 test_xmlHasFeature(void) { 13184 int test_ret = 0; 13185 13186 int mem_base; 13187 int ret_val; 13188 xmlFeature feature; /* the feature to be examined */ 13189 int n_feature; 13190 13191 for (n_feature = 0;n_feature < gen_nb_xmlFeature;n_feature++) { 13192 mem_base = xmlMemBlocks(); 13193 feature = gen_xmlFeature(n_feature, 0); 13194 13195 ret_val = xmlHasFeature(feature); 13196 desret_int(ret_val); 13197 call_tests++; 13198 des_xmlFeature(n_feature, feature, 0); 13199 xmlResetLastError(); 13200 if (mem_base != xmlMemBlocks()) { 13201 printf("Leak of %d blocks found in xmlHasFeature", 13202 xmlMemBlocks() - mem_base); 13203 test_ret++; 13204 printf(" %d", n_feature); 13205 printf("\n"); 13206 } 13207 } 13208 function_tests++; 13209 13210 return(test_ret); 13211 } 13212 13213 13214 static int 13215 test_xmlIOParseDTD(void) { 13216 int test_ret = 0; 13217 13218 #if defined(LIBXML_VALID_ENABLED) 13219 #ifdef LIBXML_VALID_ENABLED 13220 xmlDtdPtr ret_val; 13221 xmlSAXHandlerPtr sax; /* the SAX handler block or NULL */ 13222 int n_sax; 13223 xmlParserInputBufferPtr input; /* an Input Buffer */ 13224 int n_input; 13225 xmlCharEncoding enc; /* the charset encoding if known */ 13226 int n_enc; 13227 13228 for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) { 13229 for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) { 13230 for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) { 13231 sax = gen_xmlSAXHandlerPtr(n_sax, 0); 13232 input = gen_xmlParserInputBufferPtr(n_input, 1); 13233 enc = gen_xmlCharEncoding(n_enc, 2); 13234 13235 ret_val = xmlIOParseDTD(sax, input, enc); 13236 input = NULL; 13237 desret_xmlDtdPtr(ret_val); 13238 call_tests++; 13239 des_xmlSAXHandlerPtr(n_sax, sax, 0); 13240 des_xmlParserInputBufferPtr(n_input, input, 1); 13241 des_xmlCharEncoding(n_enc, enc, 2); 13242 xmlResetLastError(); 13243 } 13244 } 13245 } 13246 function_tests++; 13247 #endif 13248 #endif 13249 13250 return(test_ret); 13251 } 13252 13253 13254 static int 13255 test_xmlInitNodeInfoSeq(void) { 13256 int test_ret = 0; 13257 13258 int mem_base; 13259 xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */ 13260 int n_seq; 13261 13262 for (n_seq = 0;n_seq < gen_nb_xmlParserNodeInfoSeqPtr;n_seq++) { 13263 mem_base = xmlMemBlocks(); 13264 seq = gen_xmlParserNodeInfoSeqPtr(n_seq, 0); 13265 13266 xmlInitNodeInfoSeq(seq); 13267 call_tests++; 13268 des_xmlParserNodeInfoSeqPtr(n_seq, seq, 0); 13269 xmlResetLastError(); 13270 if (mem_base != xmlMemBlocks()) { 13271 printf("Leak of %d blocks found in xmlInitNodeInfoSeq", 13272 xmlMemBlocks() - mem_base); 13273 test_ret++; 13274 printf(" %d", n_seq); 13275 printf("\n"); 13276 } 13277 } 13278 function_tests++; 13279 13280 return(test_ret); 13281 } 13282 13283 13284 static int 13285 test_xmlInitParser(void) { 13286 int test_ret = 0; 13287 13288 int mem_base; 13289 13290 mem_base = xmlMemBlocks(); 13291 13292 xmlInitParser(); 13293 call_tests++; 13294 xmlResetLastError(); 13295 if (mem_base != xmlMemBlocks()) { 13296 printf("Leak of %d blocks found in xmlInitParser", 13297 xmlMemBlocks() - mem_base); 13298 test_ret++; 13299 printf("\n"); 13300 } 13301 function_tests++; 13302 13303 return(test_ret); 13304 } 13305 13306 13307 static int 13308 test_xmlInitParserCtxt(void) { 13309 int test_ret = 0; 13310 13311 int mem_base; 13312 int ret_val; 13313 xmlParserCtxtPtr ctxt; /* an XML parser context */ 13314 int n_ctxt; 13315 13316 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 13317 mem_base = xmlMemBlocks(); 13318 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 13319 13320 ret_val = xmlInitParserCtxt(ctxt); 13321 desret_int(ret_val); 13322 call_tests++; 13323 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 13324 xmlResetLastError(); 13325 if (mem_base != xmlMemBlocks()) { 13326 printf("Leak of %d blocks found in xmlInitParserCtxt", 13327 xmlMemBlocks() - mem_base); 13328 test_ret++; 13329 printf(" %d", n_ctxt); 13330 printf("\n"); 13331 } 13332 } 13333 function_tests++; 13334 13335 return(test_ret); 13336 } 13337 13338 13339 static int 13340 test_xmlKeepBlanksDefault(void) { 13341 int test_ret = 0; 13342 13343 int mem_base; 13344 int ret_val; 13345 int val; /* int 0 or 1 */ 13346 int n_val; 13347 13348 for (n_val = 0;n_val < gen_nb_int;n_val++) { 13349 mem_base = xmlMemBlocks(); 13350 val = gen_int(n_val, 0); 13351 13352 ret_val = xmlKeepBlanksDefault(val); 13353 desret_int(ret_val); 13354 call_tests++; 13355 des_int(n_val, val, 0); 13356 xmlResetLastError(); 13357 if (mem_base != xmlMemBlocks()) { 13358 printf("Leak of %d blocks found in xmlKeepBlanksDefault", 13359 xmlMemBlocks() - mem_base); 13360 test_ret++; 13361 printf(" %d", n_val); 13362 printf("\n"); 13363 } 13364 } 13365 function_tests++; 13366 13367 return(test_ret); 13368 } 13369 13370 13371 static int 13372 test_xmlLineNumbersDefault(void) { 13373 int test_ret = 0; 13374 13375 int mem_base; 13376 int ret_val; 13377 int val; /* int 0 or 1 */ 13378 int n_val; 13379 13380 for (n_val = 0;n_val < gen_nb_int;n_val++) { 13381 mem_base = xmlMemBlocks(); 13382 val = gen_int(n_val, 0); 13383 13384 ret_val = xmlLineNumbersDefault(val); 13385 desret_int(ret_val); 13386 call_tests++; 13387 des_int(n_val, val, 0); 13388 xmlResetLastError(); 13389 if (mem_base != xmlMemBlocks()) { 13390 printf("Leak of %d blocks found in xmlLineNumbersDefault", 13391 xmlMemBlocks() - mem_base); 13392 test_ret++; 13393 printf(" %d", n_val); 13394 printf("\n"); 13395 } 13396 } 13397 function_tests++; 13398 13399 return(test_ret); 13400 } 13401 13402 13403 static int 13404 test_xmlLoadExternalEntity(void) { 13405 int test_ret = 0; 13406 13407 int mem_base; 13408 xmlParserInputPtr ret_val; 13409 const char * URL; /* the URL for the entity to load */ 13410 int n_URL; 13411 char * ID; /* the Public ID for the entity to load */ 13412 int n_ID; 13413 xmlParserCtxtPtr ctxt; /* the context in which the entity is called or NULL */ 13414 int n_ctxt; 13415 13416 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 13417 for (n_ID = 0;n_ID < gen_nb_const_char_ptr;n_ID++) { 13418 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 13419 mem_base = xmlMemBlocks(); 13420 URL = gen_filepath(n_URL, 0); 13421 ID = gen_const_char_ptr(n_ID, 1); 13422 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 2); 13423 13424 ret_val = xmlLoadExternalEntity(URL, (const char *)ID, ctxt); 13425 desret_xmlParserInputPtr(ret_val); 13426 call_tests++; 13427 des_filepath(n_URL, URL, 0); 13428 des_const_char_ptr(n_ID, (const char *)ID, 1); 13429 des_xmlParserCtxtPtr(n_ctxt, ctxt, 2); 13430 xmlResetLastError(); 13431 if (mem_base != xmlMemBlocks()) { 13432 printf("Leak of %d blocks found in xmlLoadExternalEntity", 13433 xmlMemBlocks() - mem_base); 13434 test_ret++; 13435 printf(" %d", n_URL); 13436 printf(" %d", n_ID); 13437 printf(" %d", n_ctxt); 13438 printf("\n"); 13439 } 13440 } 13441 } 13442 } 13443 function_tests++; 13444 13445 return(test_ret); 13446 } 13447 13448 13449 static int 13450 test_xmlNewIOInputStream(void) { 13451 int test_ret = 0; 13452 13453 int mem_base; 13454 xmlParserInputPtr ret_val; 13455 xmlParserCtxtPtr ctxt; /* an XML parser context */ 13456 int n_ctxt; 13457 xmlParserInputBufferPtr input; /* an I/O Input */ 13458 int n_input; 13459 xmlCharEncoding enc; /* the charset encoding if known */ 13460 int n_enc; 13461 13462 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 13463 for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) { 13464 for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) { 13465 mem_base = xmlMemBlocks(); 13466 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 13467 input = gen_xmlParserInputBufferPtr(n_input, 1); 13468 enc = gen_xmlCharEncoding(n_enc, 2); 13469 13470 ret_val = xmlNewIOInputStream(ctxt, input, enc); 13471 if (ret_val != NULL) input = NULL; 13472 desret_xmlParserInputPtr(ret_val); 13473 call_tests++; 13474 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 13475 des_xmlParserInputBufferPtr(n_input, input, 1); 13476 des_xmlCharEncoding(n_enc, enc, 2); 13477 xmlResetLastError(); 13478 if (mem_base != xmlMemBlocks()) { 13479 printf("Leak of %d blocks found in xmlNewIOInputStream", 13480 xmlMemBlocks() - mem_base); 13481 test_ret++; 13482 printf(" %d", n_ctxt); 13483 printf(" %d", n_input); 13484 printf(" %d", n_enc); 13485 printf("\n"); 13486 } 13487 } 13488 } 13489 } 13490 function_tests++; 13491 13492 return(test_ret); 13493 } 13494 13495 13496 static int 13497 test_xmlNewParserCtxt(void) { 13498 int test_ret = 0; 13499 13500 int mem_base; 13501 xmlParserCtxtPtr ret_val; 13502 13503 mem_base = xmlMemBlocks(); 13504 13505 ret_val = xmlNewParserCtxt(); 13506 desret_xmlParserCtxtPtr(ret_val); 13507 call_tests++; 13508 xmlResetLastError(); 13509 if (mem_base != xmlMemBlocks()) { 13510 printf("Leak of %d blocks found in xmlNewParserCtxt", 13511 xmlMemBlocks() - mem_base); 13512 test_ret++; 13513 printf("\n"); 13514 } 13515 function_tests++; 13516 13517 return(test_ret); 13518 } 13519 13520 13521 #define gen_nb_xmlNodePtr_ptr 1 13522 static xmlNodePtr * gen_xmlNodePtr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 13523 return(NULL); 13524 } 13525 static void des_xmlNodePtr_ptr(int no ATTRIBUTE_UNUSED, xmlNodePtr * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 13526 } 13527 13528 static int 13529 test_xmlParseBalancedChunkMemory(void) { 13530 int test_ret = 0; 13531 13532 #if defined(LIBXML_SAX1_ENABLED) 13533 #ifdef LIBXML_SAX1_ENABLED 13534 int mem_base; 13535 int ret_val; 13536 xmlDocPtr doc; /* the document the chunk pertains to */ 13537 int n_doc; 13538 xmlSAXHandlerPtr sax; /* the SAX handler bloc (possibly NULL) */ 13539 int n_sax; 13540 void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */ 13541 int n_user_data; 13542 int depth; /* Used for loop detection, use 0 */ 13543 int n_depth; 13544 xmlChar * string; /* the input string in UTF8 or ISO-Latin (zero terminated) */ 13545 int n_string; 13546 xmlNodePtr * lst; /* the return value for the set of parsed nodes */ 13547 int n_lst; 13548 13549 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 13550 for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) { 13551 for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) { 13552 for (n_depth = 0;n_depth < gen_nb_int;n_depth++) { 13553 for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) { 13554 for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) { 13555 mem_base = xmlMemBlocks(); 13556 doc = gen_xmlDocPtr(n_doc, 0); 13557 sax = gen_xmlSAXHandlerPtr(n_sax, 1); 13558 user_data = gen_userdata(n_user_data, 2); 13559 depth = gen_int(n_depth, 3); 13560 string = gen_const_xmlChar_ptr(n_string, 4); 13561 lst = gen_xmlNodePtr_ptr(n_lst, 5); 13562 13563 #ifdef LIBXML_SAX1_ENABLED 13564 if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL; 13565 #endif 13566 13567 13568 ret_val = xmlParseBalancedChunkMemory(doc, sax, user_data, depth, (const xmlChar *)string, lst); 13569 desret_int(ret_val); 13570 call_tests++; 13571 des_xmlDocPtr(n_doc, doc, 0); 13572 des_xmlSAXHandlerPtr(n_sax, sax, 1); 13573 des_userdata(n_user_data, user_data, 2); 13574 des_int(n_depth, depth, 3); 13575 des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 4); 13576 des_xmlNodePtr_ptr(n_lst, lst, 5); 13577 xmlResetLastError(); 13578 if (mem_base != xmlMemBlocks()) { 13579 printf("Leak of %d blocks found in xmlParseBalancedChunkMemory", 13580 xmlMemBlocks() - mem_base); 13581 test_ret++; 13582 printf(" %d", n_doc); 13583 printf(" %d", n_sax); 13584 printf(" %d", n_user_data); 13585 printf(" %d", n_depth); 13586 printf(" %d", n_string); 13587 printf(" %d", n_lst); 13588 printf("\n"); 13589 } 13590 } 13591 } 13592 } 13593 } 13594 } 13595 } 13596 function_tests++; 13597 #endif 13598 #endif 13599 13600 return(test_ret); 13601 } 13602 13603 13604 static int 13605 test_xmlParseBalancedChunkMemoryRecover(void) { 13606 int test_ret = 0; 13607 13608 #if defined(LIBXML_SAX1_ENABLED) 13609 #ifdef LIBXML_SAX1_ENABLED 13610 int mem_base; 13611 int ret_val; 13612 xmlDocPtr doc; /* the document the chunk pertains to */ 13613 int n_doc; 13614 xmlSAXHandlerPtr sax; /* the SAX handler bloc (possibly NULL) */ 13615 int n_sax; 13616 void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */ 13617 int n_user_data; 13618 int depth; /* Used for loop detection, use 0 */ 13619 int n_depth; 13620 xmlChar * string; /* the input string in UTF8 or ISO-Latin (zero terminated) */ 13621 int n_string; 13622 xmlNodePtr * lst; /* the return value for the set of parsed nodes */ 13623 int n_lst; 13624 int recover; /* return nodes even if the data is broken (use 0) */ 13625 int n_recover; 13626 13627 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 13628 for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) { 13629 for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) { 13630 for (n_depth = 0;n_depth < gen_nb_int;n_depth++) { 13631 for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) { 13632 for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) { 13633 for (n_recover = 0;n_recover < gen_nb_int;n_recover++) { 13634 mem_base = xmlMemBlocks(); 13635 doc = gen_xmlDocPtr(n_doc, 0); 13636 sax = gen_xmlSAXHandlerPtr(n_sax, 1); 13637 user_data = gen_userdata(n_user_data, 2); 13638 depth = gen_int(n_depth, 3); 13639 string = gen_const_xmlChar_ptr(n_string, 4); 13640 lst = gen_xmlNodePtr_ptr(n_lst, 5); 13641 recover = gen_int(n_recover, 6); 13642 13643 #ifdef LIBXML_SAX1_ENABLED 13644 if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL; 13645 #endif 13646 13647 13648 ret_val = xmlParseBalancedChunkMemoryRecover(doc, sax, user_data, depth, (const xmlChar *)string, lst, recover); 13649 desret_int(ret_val); 13650 call_tests++; 13651 des_xmlDocPtr(n_doc, doc, 0); 13652 des_xmlSAXHandlerPtr(n_sax, sax, 1); 13653 des_userdata(n_user_data, user_data, 2); 13654 des_int(n_depth, depth, 3); 13655 des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 4); 13656 des_xmlNodePtr_ptr(n_lst, lst, 5); 13657 des_int(n_recover, recover, 6); 13658 xmlResetLastError(); 13659 if (mem_base != xmlMemBlocks()) { 13660 printf("Leak of %d blocks found in xmlParseBalancedChunkMemoryRecover", 13661 xmlMemBlocks() - mem_base); 13662 test_ret++; 13663 printf(" %d", n_doc); 13664 printf(" %d", n_sax); 13665 printf(" %d", n_user_data); 13666 printf(" %d", n_depth); 13667 printf(" %d", n_string); 13668 printf(" %d", n_lst); 13669 printf(" %d", n_recover); 13670 printf("\n"); 13671 } 13672 } 13673 } 13674 } 13675 } 13676 } 13677 } 13678 } 13679 function_tests++; 13680 #endif 13681 #endif 13682 13683 return(test_ret); 13684 } 13685 13686 13687 static int 13688 test_xmlParseChunk(void) { 13689 int test_ret = 0; 13690 13691 #if defined(LIBXML_PUSH_ENABLED) 13692 int mem_base; 13693 int ret_val; 13694 xmlParserCtxtPtr ctxt; /* an XML parser context */ 13695 int n_ctxt; 13696 char * chunk; /* an char array */ 13697 int n_chunk; 13698 int size; /* the size in byte of the chunk */ 13699 int n_size; 13700 int terminate; /* last chunk indicator */ 13701 int n_terminate; 13702 13703 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 13704 for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) { 13705 for (n_size = 0;n_size < gen_nb_int;n_size++) { 13706 for (n_terminate = 0;n_terminate < gen_nb_int;n_terminate++) { 13707 mem_base = xmlMemBlocks(); 13708 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 13709 chunk = gen_const_char_ptr(n_chunk, 1); 13710 size = gen_int(n_size, 2); 13711 terminate = gen_int(n_terminate, 3); 13712 13713 ret_val = xmlParseChunk(ctxt, (const char *)chunk, size, terminate); 13714 if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;} 13715 desret_int(ret_val); 13716 call_tests++; 13717 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 13718 des_const_char_ptr(n_chunk, (const char *)chunk, 1); 13719 des_int(n_size, size, 2); 13720 des_int(n_terminate, terminate, 3); 13721 xmlResetLastError(); 13722 if (mem_base != xmlMemBlocks()) { 13723 printf("Leak of %d blocks found in xmlParseChunk", 13724 xmlMemBlocks() - mem_base); 13725 test_ret++; 13726 printf(" %d", n_ctxt); 13727 printf(" %d", n_chunk); 13728 printf(" %d", n_size); 13729 printf(" %d", n_terminate); 13730 printf("\n"); 13731 } 13732 } 13733 } 13734 } 13735 } 13736 function_tests++; 13737 #endif 13738 13739 return(test_ret); 13740 } 13741 13742 13743 static int 13744 test_xmlParseCtxtExternalEntity(void) { 13745 int test_ret = 0; 13746 13747 int mem_base; 13748 int ret_val; 13749 xmlParserCtxtPtr ctx; /* the existing parsing context */ 13750 int n_ctx; 13751 xmlChar * URL; /* the URL for the entity to load */ 13752 int n_URL; 13753 xmlChar * ID; /* the System ID for the entity to load */ 13754 int n_ID; 13755 xmlNodePtr * lst; /* the return value for the set of parsed nodes */ 13756 int n_lst; 13757 13758 for (n_ctx = 0;n_ctx < gen_nb_xmlParserCtxtPtr;n_ctx++) { 13759 for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) { 13760 for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) { 13761 for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) { 13762 mem_base = xmlMemBlocks(); 13763 ctx = gen_xmlParserCtxtPtr(n_ctx, 0); 13764 URL = gen_const_xmlChar_ptr(n_URL, 1); 13765 ID = gen_const_xmlChar_ptr(n_ID, 2); 13766 lst = gen_xmlNodePtr_ptr(n_lst, 3); 13767 13768 ret_val = xmlParseCtxtExternalEntity(ctx, (const xmlChar *)URL, (const xmlChar *)ID, lst); 13769 desret_int(ret_val); 13770 call_tests++; 13771 des_xmlParserCtxtPtr(n_ctx, ctx, 0); 13772 des_const_xmlChar_ptr(n_URL, (const xmlChar *)URL, 1); 13773 des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 2); 13774 des_xmlNodePtr_ptr(n_lst, lst, 3); 13775 xmlResetLastError(); 13776 if (mem_base != xmlMemBlocks()) { 13777 printf("Leak of %d blocks found in xmlParseCtxtExternalEntity", 13778 xmlMemBlocks() - mem_base); 13779 test_ret++; 13780 printf(" %d", n_ctx); 13781 printf(" %d", n_URL); 13782 printf(" %d", n_ID); 13783 printf(" %d", n_lst); 13784 printf("\n"); 13785 } 13786 } 13787 } 13788 } 13789 } 13790 function_tests++; 13791 13792 return(test_ret); 13793 } 13794 13795 13796 static int 13797 test_xmlParseDTD(void) { 13798 int test_ret = 0; 13799 13800 #if defined(LIBXML_VALID_ENABLED) 13801 #ifdef LIBXML_VALID_ENABLED 13802 int mem_base; 13803 xmlDtdPtr ret_val; 13804 xmlChar * ExternalID; /* a NAME* containing the External ID of the DTD */ 13805 int n_ExternalID; 13806 xmlChar * SystemID; /* a NAME* containing the URL to the DTD */ 13807 int n_SystemID; 13808 13809 for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) { 13810 for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) { 13811 mem_base = xmlMemBlocks(); 13812 ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 0); 13813 SystemID = gen_const_xmlChar_ptr(n_SystemID, 1); 13814 13815 ret_val = xmlParseDTD((const xmlChar *)ExternalID, (const xmlChar *)SystemID); 13816 desret_xmlDtdPtr(ret_val); 13817 call_tests++; 13818 des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 0); 13819 des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 1); 13820 xmlResetLastError(); 13821 if (mem_base != xmlMemBlocks()) { 13822 printf("Leak of %d blocks found in xmlParseDTD", 13823 xmlMemBlocks() - mem_base); 13824 test_ret++; 13825 printf(" %d", n_ExternalID); 13826 printf(" %d", n_SystemID); 13827 printf("\n"); 13828 } 13829 } 13830 } 13831 function_tests++; 13832 #endif 13833 #endif 13834 13835 return(test_ret); 13836 } 13837 13838 13839 static int 13840 test_xmlParseDoc(void) { 13841 int test_ret = 0; 13842 13843 #if defined(LIBXML_SAX1_ENABLED) 13844 #ifdef LIBXML_SAX1_ENABLED 13845 int mem_base; 13846 xmlDocPtr ret_val; 13847 xmlChar * cur; /* a pointer to an array of xmlChar */ 13848 int n_cur; 13849 13850 for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) { 13851 mem_base = xmlMemBlocks(); 13852 cur = gen_const_xmlChar_ptr(n_cur, 0); 13853 13854 ret_val = xmlParseDoc((const xmlChar *)cur); 13855 desret_xmlDocPtr(ret_val); 13856 call_tests++; 13857 des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0); 13858 xmlResetLastError(); 13859 if (mem_base != xmlMemBlocks()) { 13860 printf("Leak of %d blocks found in xmlParseDoc", 13861 xmlMemBlocks() - mem_base); 13862 test_ret++; 13863 printf(" %d", n_cur); 13864 printf("\n"); 13865 } 13866 } 13867 function_tests++; 13868 #endif 13869 #endif 13870 13871 return(test_ret); 13872 } 13873 13874 13875 static int 13876 test_xmlParseDocument(void) { 13877 int test_ret = 0; 13878 13879 int mem_base; 13880 int ret_val; 13881 xmlParserCtxtPtr ctxt; /* an XML parser context */ 13882 int n_ctxt; 13883 13884 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 13885 mem_base = xmlMemBlocks(); 13886 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 13887 13888 ret_val = xmlParseDocument(ctxt); 13889 if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;} 13890 desret_int(ret_val); 13891 call_tests++; 13892 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 13893 xmlResetLastError(); 13894 if (mem_base != xmlMemBlocks()) { 13895 printf("Leak of %d blocks found in xmlParseDocument", 13896 xmlMemBlocks() - mem_base); 13897 test_ret++; 13898 printf(" %d", n_ctxt); 13899 printf("\n"); 13900 } 13901 } 13902 function_tests++; 13903 13904 return(test_ret); 13905 } 13906 13907 13908 static int 13909 test_xmlParseEntity(void) { 13910 int test_ret = 0; 13911 13912 #if defined(LIBXML_SAX1_ENABLED) 13913 #ifdef LIBXML_SAX1_ENABLED 13914 int mem_base; 13915 xmlDocPtr ret_val; 13916 const char * filename; /* the filename */ 13917 int n_filename; 13918 13919 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 13920 mem_base = xmlMemBlocks(); 13921 filename = gen_filepath(n_filename, 0); 13922 13923 ret_val = xmlParseEntity(filename); 13924 desret_xmlDocPtr(ret_val); 13925 call_tests++; 13926 des_filepath(n_filename, filename, 0); 13927 xmlResetLastError(); 13928 if (mem_base != xmlMemBlocks()) { 13929 printf("Leak of %d blocks found in xmlParseEntity", 13930 xmlMemBlocks() - mem_base); 13931 test_ret++; 13932 printf(" %d", n_filename); 13933 printf("\n"); 13934 } 13935 } 13936 function_tests++; 13937 #endif 13938 #endif 13939 13940 return(test_ret); 13941 } 13942 13943 13944 static int 13945 test_xmlParseExtParsedEnt(void) { 13946 int test_ret = 0; 13947 13948 int mem_base; 13949 int ret_val; 13950 xmlParserCtxtPtr ctxt; /* an XML parser context */ 13951 int n_ctxt; 13952 13953 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 13954 mem_base = xmlMemBlocks(); 13955 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 13956 13957 ret_val = xmlParseExtParsedEnt(ctxt); 13958 if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;} 13959 desret_int(ret_val); 13960 call_tests++; 13961 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 13962 xmlResetLastError(); 13963 if (mem_base != xmlMemBlocks()) { 13964 printf("Leak of %d blocks found in xmlParseExtParsedEnt", 13965 xmlMemBlocks() - mem_base); 13966 test_ret++; 13967 printf(" %d", n_ctxt); 13968 printf("\n"); 13969 } 13970 } 13971 function_tests++; 13972 13973 return(test_ret); 13974 } 13975 13976 13977 static int 13978 test_xmlParseExternalEntity(void) { 13979 int test_ret = 0; 13980 13981 #if defined(LIBXML_SAX1_ENABLED) 13982 #ifdef LIBXML_SAX1_ENABLED 13983 int mem_base; 13984 int ret_val; 13985 xmlDocPtr doc; /* the document the chunk pertains to */ 13986 int n_doc; 13987 xmlSAXHandlerPtr sax; /* the SAX handler bloc (possibly NULL) */ 13988 int n_sax; 13989 void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */ 13990 int n_user_data; 13991 int depth; /* Used for loop detection, use 0 */ 13992 int n_depth; 13993 xmlChar * URL; /* the URL for the entity to load */ 13994 int n_URL; 13995 xmlChar * ID; /* the System ID for the entity to load */ 13996 int n_ID; 13997 xmlNodePtr * lst; /* the return value for the set of parsed nodes */ 13998 int n_lst; 13999 14000 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 14001 for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) { 14002 for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) { 14003 for (n_depth = 0;n_depth < gen_nb_int;n_depth++) { 14004 for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) { 14005 for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) { 14006 for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) { 14007 mem_base = xmlMemBlocks(); 14008 doc = gen_xmlDocPtr(n_doc, 0); 14009 sax = gen_xmlSAXHandlerPtr(n_sax, 1); 14010 user_data = gen_userdata(n_user_data, 2); 14011 depth = gen_int(n_depth, 3); 14012 URL = gen_const_xmlChar_ptr(n_URL, 4); 14013 ID = gen_const_xmlChar_ptr(n_ID, 5); 14014 lst = gen_xmlNodePtr_ptr(n_lst, 6); 14015 14016 ret_val = xmlParseExternalEntity(doc, sax, user_data, depth, (const xmlChar *)URL, (const xmlChar *)ID, lst); 14017 desret_int(ret_val); 14018 call_tests++; 14019 des_xmlDocPtr(n_doc, doc, 0); 14020 des_xmlSAXHandlerPtr(n_sax, sax, 1); 14021 des_userdata(n_user_data, user_data, 2); 14022 des_int(n_depth, depth, 3); 14023 des_const_xmlChar_ptr(n_URL, (const xmlChar *)URL, 4); 14024 des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 5); 14025 des_xmlNodePtr_ptr(n_lst, lst, 6); 14026 xmlResetLastError(); 14027 if (mem_base != xmlMemBlocks()) { 14028 printf("Leak of %d blocks found in xmlParseExternalEntity", 14029 xmlMemBlocks() - mem_base); 14030 test_ret++; 14031 printf(" %d", n_doc); 14032 printf(" %d", n_sax); 14033 printf(" %d", n_user_data); 14034 printf(" %d", n_depth); 14035 printf(" %d", n_URL); 14036 printf(" %d", n_ID); 14037 printf(" %d", n_lst); 14038 printf("\n"); 14039 } 14040 } 14041 } 14042 } 14043 } 14044 } 14045 } 14046 } 14047 function_tests++; 14048 #endif 14049 #endif 14050 14051 return(test_ret); 14052 } 14053 14054 14055 static int 14056 test_xmlParseFile(void) { 14057 int test_ret = 0; 14058 14059 #if defined(LIBXML_SAX1_ENABLED) 14060 #ifdef LIBXML_SAX1_ENABLED 14061 int mem_base; 14062 xmlDocPtr ret_val; 14063 const char * filename; /* the filename */ 14064 int n_filename; 14065 14066 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 14067 mem_base = xmlMemBlocks(); 14068 filename = gen_filepath(n_filename, 0); 14069 14070 ret_val = xmlParseFile(filename); 14071 desret_xmlDocPtr(ret_val); 14072 call_tests++; 14073 des_filepath(n_filename, filename, 0); 14074 xmlResetLastError(); 14075 if (mem_base != xmlMemBlocks()) { 14076 printf("Leak of %d blocks found in xmlParseFile", 14077 xmlMemBlocks() - mem_base); 14078 test_ret++; 14079 printf(" %d", n_filename); 14080 printf("\n"); 14081 } 14082 } 14083 function_tests++; 14084 #endif 14085 #endif 14086 14087 return(test_ret); 14088 } 14089 14090 14091 static int 14092 test_xmlParseInNodeContext(void) { 14093 int test_ret = 0; 14094 14095 int mem_base; 14096 xmlParserErrors ret_val; 14097 xmlNodePtr node; /* the context node */ 14098 int n_node; 14099 char * data; /* the input string */ 14100 int n_data; 14101 int datalen; /* the input string length in bytes */ 14102 int n_datalen; 14103 int options; /* a combination of xmlParserOption */ 14104 int n_options; 14105 xmlNodePtr * lst; /* the return value for the set of parsed nodes */ 14106 int n_lst; 14107 14108 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 14109 for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) { 14110 for (n_datalen = 0;n_datalen < gen_nb_int;n_datalen++) { 14111 for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) { 14112 for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) { 14113 mem_base = xmlMemBlocks(); 14114 node = gen_xmlNodePtr(n_node, 0); 14115 data = gen_const_char_ptr(n_data, 1); 14116 datalen = gen_int(n_datalen, 2); 14117 options = gen_parseroptions(n_options, 3); 14118 lst = gen_xmlNodePtr_ptr(n_lst, 4); 14119 14120 ret_val = xmlParseInNodeContext(node, (const char *)data, datalen, options, lst); 14121 desret_xmlParserErrors(ret_val); 14122 call_tests++; 14123 des_xmlNodePtr(n_node, node, 0); 14124 des_const_char_ptr(n_data, (const char *)data, 1); 14125 des_int(n_datalen, datalen, 2); 14126 des_parseroptions(n_options, options, 3); 14127 des_xmlNodePtr_ptr(n_lst, lst, 4); 14128 xmlResetLastError(); 14129 if (mem_base != xmlMemBlocks()) { 14130 printf("Leak of %d blocks found in xmlParseInNodeContext", 14131 xmlMemBlocks() - mem_base); 14132 test_ret++; 14133 printf(" %d", n_node); 14134 printf(" %d", n_data); 14135 printf(" %d", n_datalen); 14136 printf(" %d", n_options); 14137 printf(" %d", n_lst); 14138 printf("\n"); 14139 } 14140 } 14141 } 14142 } 14143 } 14144 } 14145 function_tests++; 14146 14147 return(test_ret); 14148 } 14149 14150 14151 static int 14152 test_xmlParseMemory(void) { 14153 int test_ret = 0; 14154 14155 #if defined(LIBXML_SAX1_ENABLED) 14156 #ifdef LIBXML_SAX1_ENABLED 14157 int mem_base; 14158 xmlDocPtr ret_val; 14159 char * buffer; /* an pointer to a char array */ 14160 int n_buffer; 14161 int size; /* the size of the array */ 14162 int n_size; 14163 14164 for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) { 14165 for (n_size = 0;n_size < gen_nb_int;n_size++) { 14166 mem_base = xmlMemBlocks(); 14167 buffer = gen_const_char_ptr(n_buffer, 0); 14168 size = gen_int(n_size, 1); 14169 14170 ret_val = xmlParseMemory((const char *)buffer, size); 14171 desret_xmlDocPtr(ret_val); 14172 call_tests++; 14173 des_const_char_ptr(n_buffer, (const char *)buffer, 0); 14174 des_int(n_size, size, 1); 14175 xmlResetLastError(); 14176 if (mem_base != xmlMemBlocks()) { 14177 printf("Leak of %d blocks found in xmlParseMemory", 14178 xmlMemBlocks() - mem_base); 14179 test_ret++; 14180 printf(" %d", n_buffer); 14181 printf(" %d", n_size); 14182 printf("\n"); 14183 } 14184 } 14185 } 14186 function_tests++; 14187 #endif 14188 #endif 14189 14190 return(test_ret); 14191 } 14192 14193 14194 #define gen_nb_const_xmlParserNodeInfoPtr 1 14195 static xmlParserNodeInfoPtr gen_const_xmlParserNodeInfoPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 14196 return(NULL); 14197 } 14198 static void des_const_xmlParserNodeInfoPtr(int no ATTRIBUTE_UNUSED, const xmlParserNodeInfoPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 14199 } 14200 14201 static int 14202 test_xmlParserAddNodeInfo(void) { 14203 int test_ret = 0; 14204 14205 int mem_base; 14206 xmlParserCtxtPtr ctxt; /* an XML parser context */ 14207 int n_ctxt; 14208 xmlParserNodeInfoPtr info; /* a node info sequence pointer */ 14209 int n_info; 14210 14211 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 14212 for (n_info = 0;n_info < gen_nb_const_xmlParserNodeInfoPtr;n_info++) { 14213 mem_base = xmlMemBlocks(); 14214 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 14215 info = gen_const_xmlParserNodeInfoPtr(n_info, 1); 14216 14217 xmlParserAddNodeInfo(ctxt, (const xmlParserNodeInfoPtr)info); 14218 call_tests++; 14219 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 14220 des_const_xmlParserNodeInfoPtr(n_info, (const xmlParserNodeInfoPtr)info, 1); 14221 xmlResetLastError(); 14222 if (mem_base != xmlMemBlocks()) { 14223 printf("Leak of %d blocks found in xmlParserAddNodeInfo", 14224 xmlMemBlocks() - mem_base); 14225 test_ret++; 14226 printf(" %d", n_ctxt); 14227 printf(" %d", n_info); 14228 printf("\n"); 14229 } 14230 } 14231 } 14232 function_tests++; 14233 14234 return(test_ret); 14235 } 14236 14237 14238 #define gen_nb_const_xmlParserCtxtPtr 1 14239 static xmlParserCtxtPtr gen_const_xmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 14240 return(NULL); 14241 } 14242 static void des_const_xmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, const xmlParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 14243 } 14244 14245 #define gen_nb_const_xmlNodePtr 1 14246 static xmlNodePtr gen_const_xmlNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 14247 return(NULL); 14248 } 14249 static void des_const_xmlNodePtr(int no ATTRIBUTE_UNUSED, const xmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 14250 } 14251 14252 static int 14253 test_xmlParserFindNodeInfo(void) { 14254 int test_ret = 0; 14255 14256 int mem_base; 14257 const xmlParserNodeInfo * ret_val; 14258 xmlParserCtxtPtr ctx; /* an XML parser context */ 14259 int n_ctx; 14260 xmlNodePtr node; /* an XML node within the tree */ 14261 int n_node; 14262 14263 for (n_ctx = 0;n_ctx < gen_nb_const_xmlParserCtxtPtr;n_ctx++) { 14264 for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) { 14265 mem_base = xmlMemBlocks(); 14266 ctx = gen_const_xmlParserCtxtPtr(n_ctx, 0); 14267 node = gen_const_xmlNodePtr(n_node, 1); 14268 14269 ret_val = xmlParserFindNodeInfo((const xmlParserCtxtPtr)ctx, (const xmlNodePtr)node); 14270 desret_const_xmlParserNodeInfo_ptr(ret_val); 14271 call_tests++; 14272 des_const_xmlParserCtxtPtr(n_ctx, (const xmlParserCtxtPtr)ctx, 0); 14273 des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 1); 14274 xmlResetLastError(); 14275 if (mem_base != xmlMemBlocks()) { 14276 printf("Leak of %d blocks found in xmlParserFindNodeInfo", 14277 xmlMemBlocks() - mem_base); 14278 test_ret++; 14279 printf(" %d", n_ctx); 14280 printf(" %d", n_node); 14281 printf("\n"); 14282 } 14283 } 14284 } 14285 function_tests++; 14286 14287 return(test_ret); 14288 } 14289 14290 14291 #define gen_nb_const_xmlParserNodeInfoSeqPtr 1 14292 static xmlParserNodeInfoSeqPtr gen_const_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 14293 return(NULL); 14294 } 14295 static void des_const_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, const xmlParserNodeInfoSeqPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 14296 } 14297 14298 static int 14299 test_xmlParserFindNodeInfoIndex(void) { 14300 int test_ret = 0; 14301 14302 int mem_base; 14303 unsigned long ret_val; 14304 xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */ 14305 int n_seq; 14306 xmlNodePtr node; /* an XML node pointer */ 14307 int n_node; 14308 14309 for (n_seq = 0;n_seq < gen_nb_const_xmlParserNodeInfoSeqPtr;n_seq++) { 14310 for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) { 14311 mem_base = xmlMemBlocks(); 14312 seq = gen_const_xmlParserNodeInfoSeqPtr(n_seq, 0); 14313 node = gen_const_xmlNodePtr(n_node, 1); 14314 14315 ret_val = xmlParserFindNodeInfoIndex((const xmlParserNodeInfoSeqPtr)seq, (const xmlNodePtr)node); 14316 desret_unsigned_long(ret_val); 14317 call_tests++; 14318 des_const_xmlParserNodeInfoSeqPtr(n_seq, (const xmlParserNodeInfoSeqPtr)seq, 0); 14319 des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 1); 14320 xmlResetLastError(); 14321 if (mem_base != xmlMemBlocks()) { 14322 printf("Leak of %d blocks found in xmlParserFindNodeInfoIndex", 14323 xmlMemBlocks() - mem_base); 14324 test_ret++; 14325 printf(" %d", n_seq); 14326 printf(" %d", n_node); 14327 printf("\n"); 14328 } 14329 } 14330 } 14331 function_tests++; 14332 14333 return(test_ret); 14334 } 14335 14336 14337 #define gen_nb_xmlParserInputPtr 1 14338 static xmlParserInputPtr gen_xmlParserInputPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 14339 return(NULL); 14340 } 14341 static void des_xmlParserInputPtr(int no ATTRIBUTE_UNUSED, xmlParserInputPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 14342 } 14343 14344 static int 14345 test_xmlParserInputGrow(void) { 14346 int test_ret = 0; 14347 14348 int mem_base; 14349 int ret_val; 14350 xmlParserInputPtr in; /* an XML parser input */ 14351 int n_in; 14352 int len; /* an indicative size for the lookahead */ 14353 int n_len; 14354 14355 for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) { 14356 for (n_len = 0;n_len < gen_nb_int;n_len++) { 14357 mem_base = xmlMemBlocks(); 14358 in = gen_xmlParserInputPtr(n_in, 0); 14359 len = gen_int(n_len, 1); 14360 14361 ret_val = xmlParserInputGrow(in, len); 14362 desret_int(ret_val); 14363 call_tests++; 14364 des_xmlParserInputPtr(n_in, in, 0); 14365 des_int(n_len, len, 1); 14366 xmlResetLastError(); 14367 if (mem_base != xmlMemBlocks()) { 14368 printf("Leak of %d blocks found in xmlParserInputGrow", 14369 xmlMemBlocks() - mem_base); 14370 test_ret++; 14371 printf(" %d", n_in); 14372 printf(" %d", n_len); 14373 printf("\n"); 14374 } 14375 } 14376 } 14377 function_tests++; 14378 14379 return(test_ret); 14380 } 14381 14382 14383 static int 14384 test_xmlParserInputRead(void) { 14385 int test_ret = 0; 14386 14387 int mem_base; 14388 int ret_val; 14389 xmlParserInputPtr in; /* an XML parser input */ 14390 int n_in; 14391 int len; /* an indicative size for the lookahead */ 14392 int n_len; 14393 14394 for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) { 14395 for (n_len = 0;n_len < gen_nb_int;n_len++) { 14396 mem_base = xmlMemBlocks(); 14397 in = gen_xmlParserInputPtr(n_in, 0); 14398 len = gen_int(n_len, 1); 14399 14400 ret_val = xmlParserInputRead(in, len); 14401 desret_int(ret_val); 14402 call_tests++; 14403 des_xmlParserInputPtr(n_in, in, 0); 14404 des_int(n_len, len, 1); 14405 xmlResetLastError(); 14406 if (mem_base != xmlMemBlocks()) { 14407 printf("Leak of %d blocks found in xmlParserInputRead", 14408 xmlMemBlocks() - mem_base); 14409 test_ret++; 14410 printf(" %d", n_in); 14411 printf(" %d", n_len); 14412 printf("\n"); 14413 } 14414 } 14415 } 14416 function_tests++; 14417 14418 return(test_ret); 14419 } 14420 14421 14422 static int 14423 test_xmlPedanticParserDefault(void) { 14424 int test_ret = 0; 14425 14426 int mem_base; 14427 int ret_val; 14428 int val; /* int 0 or 1 */ 14429 int n_val; 14430 14431 for (n_val = 0;n_val < gen_nb_int;n_val++) { 14432 mem_base = xmlMemBlocks(); 14433 val = gen_int(n_val, 0); 14434 14435 ret_val = xmlPedanticParserDefault(val); 14436 desret_int(ret_val); 14437 call_tests++; 14438 des_int(n_val, val, 0); 14439 xmlResetLastError(); 14440 if (mem_base != xmlMemBlocks()) { 14441 printf("Leak of %d blocks found in xmlPedanticParserDefault", 14442 xmlMemBlocks() - mem_base); 14443 test_ret++; 14444 printf(" %d", n_val); 14445 printf("\n"); 14446 } 14447 } 14448 function_tests++; 14449 14450 return(test_ret); 14451 } 14452 14453 14454 static int 14455 test_xmlReadDoc(void) { 14456 int test_ret = 0; 14457 14458 int mem_base; 14459 xmlDocPtr ret_val; 14460 xmlChar * cur; /* a pointer to a zero terminated string */ 14461 int n_cur; 14462 const char * URL; /* the base URL to use for the document */ 14463 int n_URL; 14464 char * encoding; /* the document encoding, or NULL */ 14465 int n_encoding; 14466 int options; /* a combination of xmlParserOption */ 14467 int n_options; 14468 14469 for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) { 14470 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 14471 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 14472 for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) { 14473 mem_base = xmlMemBlocks(); 14474 cur = gen_const_xmlChar_ptr(n_cur, 0); 14475 URL = gen_filepath(n_URL, 1); 14476 encoding = gen_const_char_ptr(n_encoding, 2); 14477 options = gen_parseroptions(n_options, 3); 14478 14479 ret_val = xmlReadDoc((const xmlChar *)cur, URL, (const char *)encoding, options); 14480 desret_xmlDocPtr(ret_val); 14481 call_tests++; 14482 des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0); 14483 des_filepath(n_URL, URL, 1); 14484 des_const_char_ptr(n_encoding, (const char *)encoding, 2); 14485 des_parseroptions(n_options, options, 3); 14486 xmlResetLastError(); 14487 if (mem_base != xmlMemBlocks()) { 14488 printf("Leak of %d blocks found in xmlReadDoc", 14489 xmlMemBlocks() - mem_base); 14490 test_ret++; 14491 printf(" %d", n_cur); 14492 printf(" %d", n_URL); 14493 printf(" %d", n_encoding); 14494 printf(" %d", n_options); 14495 printf("\n"); 14496 } 14497 } 14498 } 14499 } 14500 } 14501 function_tests++; 14502 14503 return(test_ret); 14504 } 14505 14506 14507 static int 14508 test_xmlReadFile(void) { 14509 int test_ret = 0; 14510 14511 int mem_base; 14512 xmlDocPtr ret_val; 14513 const char * filename; /* a file or URL */ 14514 int n_filename; 14515 char * encoding; /* the document encoding, or NULL */ 14516 int n_encoding; 14517 int options; /* a combination of xmlParserOption */ 14518 int n_options; 14519 14520 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 14521 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 14522 for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) { 14523 mem_base = xmlMemBlocks(); 14524 filename = gen_filepath(n_filename, 0); 14525 encoding = gen_const_char_ptr(n_encoding, 1); 14526 options = gen_parseroptions(n_options, 2); 14527 14528 ret_val = xmlReadFile(filename, (const char *)encoding, options); 14529 desret_xmlDocPtr(ret_val); 14530 call_tests++; 14531 des_filepath(n_filename, filename, 0); 14532 des_const_char_ptr(n_encoding, (const char *)encoding, 1); 14533 des_parseroptions(n_options, options, 2); 14534 xmlResetLastError(); 14535 if (mem_base != xmlMemBlocks()) { 14536 printf("Leak of %d blocks found in xmlReadFile", 14537 xmlMemBlocks() - mem_base); 14538 test_ret++; 14539 printf(" %d", n_filename); 14540 printf(" %d", n_encoding); 14541 printf(" %d", n_options); 14542 printf("\n"); 14543 } 14544 } 14545 } 14546 } 14547 function_tests++; 14548 14549 return(test_ret); 14550 } 14551 14552 14553 static int 14554 test_xmlReadMemory(void) { 14555 int test_ret = 0; 14556 14557 int mem_base; 14558 xmlDocPtr ret_val; 14559 char * buffer; /* a pointer to a char array */ 14560 int n_buffer; 14561 int size; /* the size of the array */ 14562 int n_size; 14563 const char * URL; /* the base URL to use for the document */ 14564 int n_URL; 14565 char * encoding; /* the document encoding, or NULL */ 14566 int n_encoding; 14567 int options; /* a combination of xmlParserOption */ 14568 int n_options; 14569 14570 for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) { 14571 for (n_size = 0;n_size < gen_nb_int;n_size++) { 14572 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 14573 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 14574 for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) { 14575 mem_base = xmlMemBlocks(); 14576 buffer = gen_const_char_ptr(n_buffer, 0); 14577 size = gen_int(n_size, 1); 14578 URL = gen_filepath(n_URL, 2); 14579 encoding = gen_const_char_ptr(n_encoding, 3); 14580 options = gen_parseroptions(n_options, 4); 14581 14582 ret_val = xmlReadMemory((const char *)buffer, size, URL, (const char *)encoding, options); 14583 desret_xmlDocPtr(ret_val); 14584 call_tests++; 14585 des_const_char_ptr(n_buffer, (const char *)buffer, 0); 14586 des_int(n_size, size, 1); 14587 des_filepath(n_URL, URL, 2); 14588 des_const_char_ptr(n_encoding, (const char *)encoding, 3); 14589 des_parseroptions(n_options, options, 4); 14590 xmlResetLastError(); 14591 if (mem_base != xmlMemBlocks()) { 14592 printf("Leak of %d blocks found in xmlReadMemory", 14593 xmlMemBlocks() - mem_base); 14594 test_ret++; 14595 printf(" %d", n_buffer); 14596 printf(" %d", n_size); 14597 printf(" %d", n_URL); 14598 printf(" %d", n_encoding); 14599 printf(" %d", n_options); 14600 printf("\n"); 14601 } 14602 } 14603 } 14604 } 14605 } 14606 } 14607 function_tests++; 14608 14609 return(test_ret); 14610 } 14611 14612 14613 static int 14614 test_xmlRecoverDoc(void) { 14615 int test_ret = 0; 14616 14617 #if defined(LIBXML_SAX1_ENABLED) 14618 #ifdef LIBXML_SAX1_ENABLED 14619 int mem_base; 14620 xmlDocPtr ret_val; 14621 xmlChar * cur; /* a pointer to an array of xmlChar */ 14622 int n_cur; 14623 14624 for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) { 14625 mem_base = xmlMemBlocks(); 14626 cur = gen_const_xmlChar_ptr(n_cur, 0); 14627 14628 ret_val = xmlRecoverDoc((const xmlChar *)cur); 14629 desret_xmlDocPtr(ret_val); 14630 call_tests++; 14631 des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0); 14632 xmlResetLastError(); 14633 if (mem_base != xmlMemBlocks()) { 14634 printf("Leak of %d blocks found in xmlRecoverDoc", 14635 xmlMemBlocks() - mem_base); 14636 test_ret++; 14637 printf(" %d", n_cur); 14638 printf("\n"); 14639 } 14640 } 14641 function_tests++; 14642 #endif 14643 #endif 14644 14645 return(test_ret); 14646 } 14647 14648 14649 static int 14650 test_xmlRecoverFile(void) { 14651 int test_ret = 0; 14652 14653 #if defined(LIBXML_SAX1_ENABLED) 14654 #ifdef LIBXML_SAX1_ENABLED 14655 int mem_base; 14656 xmlDocPtr ret_val; 14657 const char * filename; /* the filename */ 14658 int n_filename; 14659 14660 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 14661 mem_base = xmlMemBlocks(); 14662 filename = gen_filepath(n_filename, 0); 14663 14664 ret_val = xmlRecoverFile(filename); 14665 desret_xmlDocPtr(ret_val); 14666 call_tests++; 14667 des_filepath(n_filename, filename, 0); 14668 xmlResetLastError(); 14669 if (mem_base != xmlMemBlocks()) { 14670 printf("Leak of %d blocks found in xmlRecoverFile", 14671 xmlMemBlocks() - mem_base); 14672 test_ret++; 14673 printf(" %d", n_filename); 14674 printf("\n"); 14675 } 14676 } 14677 function_tests++; 14678 #endif 14679 #endif 14680 14681 return(test_ret); 14682 } 14683 14684 14685 static int 14686 test_xmlRecoverMemory(void) { 14687 int test_ret = 0; 14688 14689 #if defined(LIBXML_SAX1_ENABLED) 14690 #ifdef LIBXML_SAX1_ENABLED 14691 int mem_base; 14692 xmlDocPtr ret_val; 14693 char * buffer; /* an pointer to a char array */ 14694 int n_buffer; 14695 int size; /* the size of the array */ 14696 int n_size; 14697 14698 for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) { 14699 for (n_size = 0;n_size < gen_nb_int;n_size++) { 14700 mem_base = xmlMemBlocks(); 14701 buffer = gen_const_char_ptr(n_buffer, 0); 14702 size = gen_int(n_size, 1); 14703 14704 ret_val = xmlRecoverMemory((const char *)buffer, size); 14705 desret_xmlDocPtr(ret_val); 14706 call_tests++; 14707 des_const_char_ptr(n_buffer, (const char *)buffer, 0); 14708 des_int(n_size, size, 1); 14709 xmlResetLastError(); 14710 if (mem_base != xmlMemBlocks()) { 14711 printf("Leak of %d blocks found in xmlRecoverMemory", 14712 xmlMemBlocks() - mem_base); 14713 test_ret++; 14714 printf(" %d", n_buffer); 14715 printf(" %d", n_size); 14716 printf("\n"); 14717 } 14718 } 14719 } 14720 function_tests++; 14721 #endif 14722 #endif 14723 14724 return(test_ret); 14725 } 14726 14727 14728 static int 14729 test_xmlSAXParseDTD(void) { 14730 int test_ret = 0; 14731 14732 #if defined(LIBXML_VALID_ENABLED) 14733 #ifdef LIBXML_SAX1_ENABLED 14734 int mem_base; 14735 xmlDtdPtr ret_val; 14736 xmlSAXHandlerPtr sax; /* the SAX handler block */ 14737 int n_sax; 14738 xmlChar * ExternalID; /* a NAME* containing the External ID of the DTD */ 14739 int n_ExternalID; 14740 xmlChar * SystemID; /* a NAME* containing the URL to the DTD */ 14741 int n_SystemID; 14742 14743 for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) { 14744 for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) { 14745 for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) { 14746 mem_base = xmlMemBlocks(); 14747 sax = gen_xmlSAXHandlerPtr(n_sax, 0); 14748 ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 1); 14749 SystemID = gen_const_xmlChar_ptr(n_SystemID, 2); 14750 14751 ret_val = xmlSAXParseDTD(sax, (const xmlChar *)ExternalID, (const xmlChar *)SystemID); 14752 desret_xmlDtdPtr(ret_val); 14753 call_tests++; 14754 des_xmlSAXHandlerPtr(n_sax, sax, 0); 14755 des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 1); 14756 des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 2); 14757 xmlResetLastError(); 14758 if (mem_base != xmlMemBlocks()) { 14759 printf("Leak of %d blocks found in xmlSAXParseDTD", 14760 xmlMemBlocks() - mem_base); 14761 test_ret++; 14762 printf(" %d", n_sax); 14763 printf(" %d", n_ExternalID); 14764 printf(" %d", n_SystemID); 14765 printf("\n"); 14766 } 14767 } 14768 } 14769 } 14770 function_tests++; 14771 #endif 14772 #endif 14773 14774 return(test_ret); 14775 } 14776 14777 14778 static int 14779 test_xmlSAXParseDoc(void) { 14780 int test_ret = 0; 14781 14782 #if defined(LIBXML_SAX1_ENABLED) 14783 #ifdef LIBXML_SAX1_ENABLED 14784 int mem_base; 14785 xmlDocPtr ret_val; 14786 xmlSAXHandlerPtr sax; /* the SAX handler block */ 14787 int n_sax; 14788 xmlChar * cur; /* a pointer to an array of xmlChar */ 14789 int n_cur; 14790 int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */ 14791 int n_recovery; 14792 14793 for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) { 14794 for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) { 14795 for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) { 14796 mem_base = xmlMemBlocks(); 14797 sax = gen_xmlSAXHandlerPtr(n_sax, 0); 14798 cur = gen_const_xmlChar_ptr(n_cur, 1); 14799 recovery = gen_int(n_recovery, 2); 14800 14801 ret_val = xmlSAXParseDoc(sax, (const xmlChar *)cur, recovery); 14802 desret_xmlDocPtr(ret_val); 14803 call_tests++; 14804 des_xmlSAXHandlerPtr(n_sax, sax, 0); 14805 des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1); 14806 des_int(n_recovery, recovery, 2); 14807 xmlResetLastError(); 14808 if (mem_base != xmlMemBlocks()) { 14809 printf("Leak of %d blocks found in xmlSAXParseDoc", 14810 xmlMemBlocks() - mem_base); 14811 test_ret++; 14812 printf(" %d", n_sax); 14813 printf(" %d", n_cur); 14814 printf(" %d", n_recovery); 14815 printf("\n"); 14816 } 14817 } 14818 } 14819 } 14820 function_tests++; 14821 #endif 14822 #endif 14823 14824 return(test_ret); 14825 } 14826 14827 14828 static int 14829 test_xmlSAXParseEntity(void) { 14830 int test_ret = 0; 14831 14832 #if defined(LIBXML_SAX1_ENABLED) 14833 #ifdef LIBXML_SAX1_ENABLED 14834 int mem_base; 14835 xmlDocPtr ret_val; 14836 xmlSAXHandlerPtr sax; /* the SAX handler block */ 14837 int n_sax; 14838 const char * filename; /* the filename */ 14839 int n_filename; 14840 14841 for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) { 14842 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 14843 mem_base = xmlMemBlocks(); 14844 sax = gen_xmlSAXHandlerPtr(n_sax, 0); 14845 filename = gen_filepath(n_filename, 1); 14846 14847 ret_val = xmlSAXParseEntity(sax, filename); 14848 desret_xmlDocPtr(ret_val); 14849 call_tests++; 14850 des_xmlSAXHandlerPtr(n_sax, sax, 0); 14851 des_filepath(n_filename, filename, 1); 14852 xmlResetLastError(); 14853 if (mem_base != xmlMemBlocks()) { 14854 printf("Leak of %d blocks found in xmlSAXParseEntity", 14855 xmlMemBlocks() - mem_base); 14856 test_ret++; 14857 printf(" %d", n_sax); 14858 printf(" %d", n_filename); 14859 printf("\n"); 14860 } 14861 } 14862 } 14863 function_tests++; 14864 #endif 14865 #endif 14866 14867 return(test_ret); 14868 } 14869 14870 14871 static int 14872 test_xmlSAXParseFile(void) { 14873 int test_ret = 0; 14874 14875 #if defined(LIBXML_SAX1_ENABLED) 14876 #ifdef LIBXML_SAX1_ENABLED 14877 int mem_base; 14878 xmlDocPtr ret_val; 14879 xmlSAXHandlerPtr sax; /* the SAX handler block */ 14880 int n_sax; 14881 const char * filename; /* the filename */ 14882 int n_filename; 14883 int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */ 14884 int n_recovery; 14885 14886 for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) { 14887 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 14888 for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) { 14889 mem_base = xmlMemBlocks(); 14890 sax = gen_xmlSAXHandlerPtr(n_sax, 0); 14891 filename = gen_filepath(n_filename, 1); 14892 recovery = gen_int(n_recovery, 2); 14893 14894 ret_val = xmlSAXParseFile(sax, filename, recovery); 14895 desret_xmlDocPtr(ret_val); 14896 call_tests++; 14897 des_xmlSAXHandlerPtr(n_sax, sax, 0); 14898 des_filepath(n_filename, filename, 1); 14899 des_int(n_recovery, recovery, 2); 14900 xmlResetLastError(); 14901 if (mem_base != xmlMemBlocks()) { 14902 printf("Leak of %d blocks found in xmlSAXParseFile", 14903 xmlMemBlocks() - mem_base); 14904 test_ret++; 14905 printf(" %d", n_sax); 14906 printf(" %d", n_filename); 14907 printf(" %d", n_recovery); 14908 printf("\n"); 14909 } 14910 } 14911 } 14912 } 14913 function_tests++; 14914 #endif 14915 #endif 14916 14917 return(test_ret); 14918 } 14919 14920 14921 static int 14922 test_xmlSAXParseFileWithData(void) { 14923 int test_ret = 0; 14924 14925 #if defined(LIBXML_SAX1_ENABLED) 14926 #ifdef LIBXML_SAX1_ENABLED 14927 int mem_base; 14928 xmlDocPtr ret_val; 14929 xmlSAXHandlerPtr sax; /* the SAX handler block */ 14930 int n_sax; 14931 const char * filename; /* the filename */ 14932 int n_filename; 14933 int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */ 14934 int n_recovery; 14935 void * data; /* the userdata */ 14936 int n_data; 14937 14938 for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) { 14939 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 14940 for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) { 14941 for (n_data = 0;n_data < gen_nb_userdata;n_data++) { 14942 mem_base = xmlMemBlocks(); 14943 sax = gen_xmlSAXHandlerPtr(n_sax, 0); 14944 filename = gen_filepath(n_filename, 1); 14945 recovery = gen_int(n_recovery, 2); 14946 data = gen_userdata(n_data, 3); 14947 14948 ret_val = xmlSAXParseFileWithData(sax, filename, recovery, data); 14949 desret_xmlDocPtr(ret_val); 14950 call_tests++; 14951 des_xmlSAXHandlerPtr(n_sax, sax, 0); 14952 des_filepath(n_filename, filename, 1); 14953 des_int(n_recovery, recovery, 2); 14954 des_userdata(n_data, data, 3); 14955 xmlResetLastError(); 14956 if (mem_base != xmlMemBlocks()) { 14957 printf("Leak of %d blocks found in xmlSAXParseFileWithData", 14958 xmlMemBlocks() - mem_base); 14959 test_ret++; 14960 printf(" %d", n_sax); 14961 printf(" %d", n_filename); 14962 printf(" %d", n_recovery); 14963 printf(" %d", n_data); 14964 printf("\n"); 14965 } 14966 } 14967 } 14968 } 14969 } 14970 function_tests++; 14971 #endif 14972 #endif 14973 14974 return(test_ret); 14975 } 14976 14977 14978 static int 14979 test_xmlSAXParseMemory(void) { 14980 int test_ret = 0; 14981 14982 #if defined(LIBXML_SAX1_ENABLED) 14983 #ifdef LIBXML_SAX1_ENABLED 14984 int mem_base; 14985 xmlDocPtr ret_val; 14986 xmlSAXHandlerPtr sax; /* the SAX handler block */ 14987 int n_sax; 14988 char * buffer; /* an pointer to a char array */ 14989 int n_buffer; 14990 int size; /* the size of the array */ 14991 int n_size; 14992 int recovery; /* work in recovery mode, i.e. tries to read not Well Formed documents */ 14993 int n_recovery; 14994 14995 for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) { 14996 for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) { 14997 for (n_size = 0;n_size < gen_nb_int;n_size++) { 14998 for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) { 14999 mem_base = xmlMemBlocks(); 15000 sax = gen_xmlSAXHandlerPtr(n_sax, 0); 15001 buffer = gen_const_char_ptr(n_buffer, 1); 15002 size = gen_int(n_size, 2); 15003 recovery = gen_int(n_recovery, 3); 15004 15005 ret_val = xmlSAXParseMemory(sax, (const char *)buffer, size, recovery); 15006 desret_xmlDocPtr(ret_val); 15007 call_tests++; 15008 des_xmlSAXHandlerPtr(n_sax, sax, 0); 15009 des_const_char_ptr(n_buffer, (const char *)buffer, 1); 15010 des_int(n_size, size, 2); 15011 des_int(n_recovery, recovery, 3); 15012 xmlResetLastError(); 15013 if (mem_base != xmlMemBlocks()) { 15014 printf("Leak of %d blocks found in xmlSAXParseMemory", 15015 xmlMemBlocks() - mem_base); 15016 test_ret++; 15017 printf(" %d", n_sax); 15018 printf(" %d", n_buffer); 15019 printf(" %d", n_size); 15020 printf(" %d", n_recovery); 15021 printf("\n"); 15022 } 15023 } 15024 } 15025 } 15026 } 15027 function_tests++; 15028 #endif 15029 #endif 15030 15031 return(test_ret); 15032 } 15033 15034 15035 static int 15036 test_xmlSAXParseMemoryWithData(void) { 15037 int test_ret = 0; 15038 15039 #if defined(LIBXML_SAX1_ENABLED) 15040 #ifdef LIBXML_SAX1_ENABLED 15041 int mem_base; 15042 xmlDocPtr ret_val; 15043 xmlSAXHandlerPtr sax; /* the SAX handler block */ 15044 int n_sax; 15045 char * buffer; /* an pointer to a char array */ 15046 int n_buffer; 15047 int size; /* the size of the array */ 15048 int n_size; 15049 int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */ 15050 int n_recovery; 15051 void * data; /* the userdata */ 15052 int n_data; 15053 15054 for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) { 15055 for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) { 15056 for (n_size = 0;n_size < gen_nb_int;n_size++) { 15057 for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) { 15058 for (n_data = 0;n_data < gen_nb_userdata;n_data++) { 15059 mem_base = xmlMemBlocks(); 15060 sax = gen_xmlSAXHandlerPtr(n_sax, 0); 15061 buffer = gen_const_char_ptr(n_buffer, 1); 15062 size = gen_int(n_size, 2); 15063 recovery = gen_int(n_recovery, 3); 15064 data = gen_userdata(n_data, 4); 15065 15066 ret_val = xmlSAXParseMemoryWithData(sax, (const char *)buffer, size, recovery, data); 15067 desret_xmlDocPtr(ret_val); 15068 call_tests++; 15069 des_xmlSAXHandlerPtr(n_sax, sax, 0); 15070 des_const_char_ptr(n_buffer, (const char *)buffer, 1); 15071 des_int(n_size, size, 2); 15072 des_int(n_recovery, recovery, 3); 15073 des_userdata(n_data, data, 4); 15074 xmlResetLastError(); 15075 if (mem_base != xmlMemBlocks()) { 15076 printf("Leak of %d blocks found in xmlSAXParseMemoryWithData", 15077 xmlMemBlocks() - mem_base); 15078 test_ret++; 15079 printf(" %d", n_sax); 15080 printf(" %d", n_buffer); 15081 printf(" %d", n_size); 15082 printf(" %d", n_recovery); 15083 printf(" %d", n_data); 15084 printf("\n"); 15085 } 15086 } 15087 } 15088 } 15089 } 15090 } 15091 function_tests++; 15092 #endif 15093 #endif 15094 15095 return(test_ret); 15096 } 15097 15098 15099 static int 15100 test_xmlSAXUserParseFile(void) { 15101 int test_ret = 0; 15102 15103 #if defined(LIBXML_SAX1_ENABLED) 15104 #ifdef LIBXML_SAX1_ENABLED 15105 int mem_base; 15106 int ret_val; 15107 xmlSAXHandlerPtr sax; /* a SAX handler */ 15108 int n_sax; 15109 void * user_data; /* The user data returned on SAX callbacks */ 15110 int n_user_data; 15111 const char * filename; /* a file name */ 15112 int n_filename; 15113 15114 for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) { 15115 for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) { 15116 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 15117 mem_base = xmlMemBlocks(); 15118 sax = gen_xmlSAXHandlerPtr(n_sax, 0); 15119 user_data = gen_userdata(n_user_data, 1); 15120 filename = gen_filepath(n_filename, 2); 15121 15122 #ifdef LIBXML_SAX1_ENABLED 15123 if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL; 15124 #endif 15125 15126 15127 ret_val = xmlSAXUserParseFile(sax, user_data, filename); 15128 desret_int(ret_val); 15129 call_tests++; 15130 des_xmlSAXHandlerPtr(n_sax, sax, 0); 15131 des_userdata(n_user_data, user_data, 1); 15132 des_filepath(n_filename, filename, 2); 15133 xmlResetLastError(); 15134 if (mem_base != xmlMemBlocks()) { 15135 printf("Leak of %d blocks found in xmlSAXUserParseFile", 15136 xmlMemBlocks() - mem_base); 15137 test_ret++; 15138 printf(" %d", n_sax); 15139 printf(" %d", n_user_data); 15140 printf(" %d", n_filename); 15141 printf("\n"); 15142 } 15143 } 15144 } 15145 } 15146 function_tests++; 15147 #endif 15148 #endif 15149 15150 return(test_ret); 15151 } 15152 15153 15154 static int 15155 test_xmlSAXUserParseMemory(void) { 15156 int test_ret = 0; 15157 15158 #if defined(LIBXML_SAX1_ENABLED) 15159 #ifdef LIBXML_SAX1_ENABLED 15160 int mem_base; 15161 int ret_val; 15162 xmlSAXHandlerPtr sax; /* a SAX handler */ 15163 int n_sax; 15164 void * user_data; /* The user data returned on SAX callbacks */ 15165 int n_user_data; 15166 char * buffer; /* an in-memory XML document input */ 15167 int n_buffer; 15168 int size; /* the length of the XML document in bytes */ 15169 int n_size; 15170 15171 for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) { 15172 for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) { 15173 for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) { 15174 for (n_size = 0;n_size < gen_nb_int;n_size++) { 15175 mem_base = xmlMemBlocks(); 15176 sax = gen_xmlSAXHandlerPtr(n_sax, 0); 15177 user_data = gen_userdata(n_user_data, 1); 15178 buffer = gen_const_char_ptr(n_buffer, 2); 15179 size = gen_int(n_size, 3); 15180 15181 #ifdef LIBXML_SAX1_ENABLED 15182 if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL; 15183 #endif 15184 15185 15186 ret_val = xmlSAXUserParseMemory(sax, user_data, (const char *)buffer, size); 15187 desret_int(ret_val); 15188 call_tests++; 15189 des_xmlSAXHandlerPtr(n_sax, sax, 0); 15190 des_userdata(n_user_data, user_data, 1); 15191 des_const_char_ptr(n_buffer, (const char *)buffer, 2); 15192 des_int(n_size, size, 3); 15193 xmlResetLastError(); 15194 if (mem_base != xmlMemBlocks()) { 15195 printf("Leak of %d blocks found in xmlSAXUserParseMemory", 15196 xmlMemBlocks() - mem_base); 15197 test_ret++; 15198 printf(" %d", n_sax); 15199 printf(" %d", n_user_data); 15200 printf(" %d", n_buffer); 15201 printf(" %d", n_size); 15202 printf("\n"); 15203 } 15204 } 15205 } 15206 } 15207 } 15208 function_tests++; 15209 #endif 15210 #endif 15211 15212 return(test_ret); 15213 } 15214 15215 15216 static int 15217 test_xmlSetExternalEntityLoader(void) { 15218 int test_ret = 0; 15219 15220 15221 /* missing type support */ 15222 return(test_ret); 15223 } 15224 15225 15226 static int 15227 test_xmlSetFeature(void) { 15228 int test_ret = 0; 15229 15230 #if defined(LIBXML_LEGACY_ENABLED) 15231 #ifdef LIBXML_LEGACY_ENABLED 15232 int mem_base; 15233 int ret_val; 15234 xmlParserCtxtPtr ctxt; /* an XML/HTML parser context */ 15235 int n_ctxt; 15236 char * name; /* the feature name */ 15237 int n_name; 15238 void * value; /* pointer to the location of the new value */ 15239 int n_value; 15240 15241 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 15242 for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) { 15243 for (n_value = 0;n_value < gen_nb_void_ptr;n_value++) { 15244 mem_base = xmlMemBlocks(); 15245 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 15246 name = gen_const_char_ptr(n_name, 1); 15247 value = gen_void_ptr(n_value, 2); 15248 15249 ret_val = xmlSetFeature(ctxt, (const char *)name, value); 15250 desret_int(ret_val); 15251 call_tests++; 15252 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 15253 des_const_char_ptr(n_name, (const char *)name, 1); 15254 des_void_ptr(n_value, value, 2); 15255 xmlResetLastError(); 15256 if (mem_base != xmlMemBlocks()) { 15257 printf("Leak of %d blocks found in xmlSetFeature", 15258 xmlMemBlocks() - mem_base); 15259 test_ret++; 15260 printf(" %d", n_ctxt); 15261 printf(" %d", n_name); 15262 printf(" %d", n_value); 15263 printf("\n"); 15264 } 15265 } 15266 } 15267 } 15268 function_tests++; 15269 #endif 15270 #endif 15271 15272 return(test_ret); 15273 } 15274 15275 15276 static int 15277 test_xmlSetupParserForBuffer(void) { 15278 int test_ret = 0; 15279 15280 #if defined(LIBXML_SAX1_ENABLED) 15281 #ifdef LIBXML_SAX1_ENABLED 15282 int mem_base; 15283 xmlParserCtxtPtr ctxt; /* an XML parser context */ 15284 int n_ctxt; 15285 xmlChar * buffer; /* a xmlChar * buffer */ 15286 int n_buffer; 15287 const char * filename; /* a file name */ 15288 int n_filename; 15289 15290 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 15291 for (n_buffer = 0;n_buffer < gen_nb_const_xmlChar_ptr;n_buffer++) { 15292 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 15293 mem_base = xmlMemBlocks(); 15294 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 15295 buffer = gen_const_xmlChar_ptr(n_buffer, 1); 15296 filename = gen_filepath(n_filename, 2); 15297 15298 xmlSetupParserForBuffer(ctxt, (const xmlChar *)buffer, filename); 15299 call_tests++; 15300 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 15301 des_const_xmlChar_ptr(n_buffer, (const xmlChar *)buffer, 1); 15302 des_filepath(n_filename, filename, 2); 15303 xmlResetLastError(); 15304 if (mem_base != xmlMemBlocks()) { 15305 printf("Leak of %d blocks found in xmlSetupParserForBuffer", 15306 xmlMemBlocks() - mem_base); 15307 test_ret++; 15308 printf(" %d", n_ctxt); 15309 printf(" %d", n_buffer); 15310 printf(" %d", n_filename); 15311 printf("\n"); 15312 } 15313 } 15314 } 15315 } 15316 function_tests++; 15317 #endif 15318 #endif 15319 15320 return(test_ret); 15321 } 15322 15323 15324 static int 15325 test_xmlStopParser(void) { 15326 int test_ret = 0; 15327 15328 #ifdef LIBXML_PUSH_ENABLED 15329 int mem_base; 15330 xmlParserCtxtPtr ctxt; /* an XML parser context */ 15331 int n_ctxt; 15332 15333 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 15334 mem_base = xmlMemBlocks(); 15335 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 15336 15337 xmlStopParser(ctxt); 15338 call_tests++; 15339 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 15340 xmlResetLastError(); 15341 if (mem_base != xmlMemBlocks()) { 15342 printf("Leak of %d blocks found in xmlStopParser", 15343 xmlMemBlocks() - mem_base); 15344 test_ret++; 15345 printf(" %d", n_ctxt); 15346 printf("\n"); 15347 } 15348 } 15349 function_tests++; 15350 #endif 15351 15352 return(test_ret); 15353 } 15354 15355 15356 static int 15357 test_xmlSubstituteEntitiesDefault(void) { 15358 int test_ret = 0; 15359 15360 int mem_base; 15361 int ret_val; 15362 int val; /* int 0 or 1 */ 15363 int n_val; 15364 15365 for (n_val = 0;n_val < gen_nb_int;n_val++) { 15366 mem_base = xmlMemBlocks(); 15367 val = gen_int(n_val, 0); 15368 15369 ret_val = xmlSubstituteEntitiesDefault(val); 15370 desret_int(ret_val); 15371 call_tests++; 15372 des_int(n_val, val, 0); 15373 xmlResetLastError(); 15374 if (mem_base != xmlMemBlocks()) { 15375 printf("Leak of %d blocks found in xmlSubstituteEntitiesDefault", 15376 xmlMemBlocks() - mem_base); 15377 test_ret++; 15378 printf(" %d", n_val); 15379 printf("\n"); 15380 } 15381 } 15382 function_tests++; 15383 15384 return(test_ret); 15385 } 15386 15387 static int 15388 test_parser(void) { 15389 int test_ret = 0; 15390 15391 if (quiet == 0) printf("Testing parser : 61 of 70 functions ...\n"); 15392 test_ret += test_xmlByteConsumed(); 15393 test_ret += test_xmlClearNodeInfoSeq(); 15394 test_ret += test_xmlClearParserCtxt(); 15395 test_ret += test_xmlCreateDocParserCtxt(); 15396 test_ret += test_xmlCreatePushParserCtxt(); 15397 test_ret += test_xmlCtxtReadDoc(); 15398 test_ret += test_xmlCtxtReadFile(); 15399 test_ret += test_xmlCtxtReadMemory(); 15400 test_ret += test_xmlCtxtReset(); 15401 test_ret += test_xmlCtxtResetPush(); 15402 test_ret += test_xmlCtxtUseOptions(); 15403 test_ret += test_xmlGetExternalEntityLoader(); 15404 test_ret += test_xmlGetFeature(); 15405 test_ret += test_xmlGetFeaturesList(); 15406 test_ret += test_xmlHasFeature(); 15407 test_ret += test_xmlIOParseDTD(); 15408 test_ret += test_xmlInitNodeInfoSeq(); 15409 test_ret += test_xmlInitParser(); 15410 test_ret += test_xmlInitParserCtxt(); 15411 test_ret += test_xmlKeepBlanksDefault(); 15412 test_ret += test_xmlLineNumbersDefault(); 15413 test_ret += test_xmlLoadExternalEntity(); 15414 test_ret += test_xmlNewIOInputStream(); 15415 test_ret += test_xmlNewParserCtxt(); 15416 test_ret += test_xmlParseBalancedChunkMemory(); 15417 test_ret += test_xmlParseBalancedChunkMemoryRecover(); 15418 test_ret += test_xmlParseChunk(); 15419 test_ret += test_xmlParseCtxtExternalEntity(); 15420 test_ret += test_xmlParseDTD(); 15421 test_ret += test_xmlParseDoc(); 15422 test_ret += test_xmlParseDocument(); 15423 test_ret += test_xmlParseEntity(); 15424 test_ret += test_xmlParseExtParsedEnt(); 15425 test_ret += test_xmlParseExternalEntity(); 15426 test_ret += test_xmlParseFile(); 15427 test_ret += test_xmlParseInNodeContext(); 15428 test_ret += test_xmlParseMemory(); 15429 test_ret += test_xmlParserAddNodeInfo(); 15430 test_ret += test_xmlParserFindNodeInfo(); 15431 test_ret += test_xmlParserFindNodeInfoIndex(); 15432 test_ret += test_xmlParserInputGrow(); 15433 test_ret += test_xmlParserInputRead(); 15434 test_ret += test_xmlPedanticParserDefault(); 15435 test_ret += test_xmlReadDoc(); 15436 test_ret += test_xmlReadFile(); 15437 test_ret += test_xmlReadMemory(); 15438 test_ret += test_xmlRecoverDoc(); 15439 test_ret += test_xmlRecoverFile(); 15440 test_ret += test_xmlRecoverMemory(); 15441 test_ret += test_xmlSAXParseDTD(); 15442 test_ret += test_xmlSAXParseDoc(); 15443 test_ret += test_xmlSAXParseEntity(); 15444 test_ret += test_xmlSAXParseFile(); 15445 test_ret += test_xmlSAXParseFileWithData(); 15446 test_ret += test_xmlSAXParseMemory(); 15447 test_ret += test_xmlSAXParseMemoryWithData(); 15448 test_ret += test_xmlSAXUserParseFile(); 15449 test_ret += test_xmlSAXUserParseMemory(); 15450 test_ret += test_xmlSetExternalEntityLoader(); 15451 test_ret += test_xmlSetFeature(); 15452 test_ret += test_xmlSetupParserForBuffer(); 15453 test_ret += test_xmlStopParser(); 15454 test_ret += test_xmlSubstituteEntitiesDefault(); 15455 15456 if (test_ret != 0) 15457 printf("Module parser: %d errors\n", test_ret); 15458 return(test_ret); 15459 } 15460 15461 static int 15462 test_htmlCreateFileParserCtxt(void) { 15463 int test_ret = 0; 15464 15465 #if defined(LIBXML_HTML_ENABLED) 15466 int mem_base; 15467 htmlParserCtxtPtr ret_val; 15468 const char * filename; /* the filename */ 15469 int n_filename; 15470 char * encoding; /* a free form C string describing the HTML document encoding, or NULL */ 15471 int n_encoding; 15472 15473 for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) { 15474 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 15475 mem_base = xmlMemBlocks(); 15476 filename = gen_fileoutput(n_filename, 0); 15477 encoding = gen_const_char_ptr(n_encoding, 1); 15478 15479 ret_val = htmlCreateFileParserCtxt(filename, (const char *)encoding); 15480 desret_htmlParserCtxtPtr(ret_val); 15481 call_tests++; 15482 des_fileoutput(n_filename, filename, 0); 15483 des_const_char_ptr(n_encoding, (const char *)encoding, 1); 15484 xmlResetLastError(); 15485 if (mem_base != xmlMemBlocks()) { 15486 printf("Leak of %d blocks found in htmlCreateFileParserCtxt", 15487 xmlMemBlocks() - mem_base); 15488 test_ret++; 15489 printf(" %d", n_filename); 15490 printf(" %d", n_encoding); 15491 printf("\n"); 15492 } 15493 } 15494 } 15495 function_tests++; 15496 #endif 15497 15498 return(test_ret); 15499 } 15500 15501 15502 static int 15503 test_htmlInitAutoClose(void) { 15504 int test_ret = 0; 15505 15506 #if defined(LIBXML_HTML_ENABLED) 15507 int mem_base; 15508 15509 mem_base = xmlMemBlocks(); 15510 15511 htmlInitAutoClose(); 15512 call_tests++; 15513 xmlResetLastError(); 15514 if (mem_base != xmlMemBlocks()) { 15515 printf("Leak of %d blocks found in htmlInitAutoClose", 15516 xmlMemBlocks() - mem_base); 15517 test_ret++; 15518 printf("\n"); 15519 } 15520 function_tests++; 15521 #endif 15522 15523 return(test_ret); 15524 } 15525 15526 15527 static int 15528 test_inputPop(void) { 15529 int test_ret = 0; 15530 15531 int mem_base; 15532 xmlParserInputPtr ret_val; 15533 xmlParserCtxtPtr ctxt; /* an XML parser context */ 15534 int n_ctxt; 15535 15536 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 15537 mem_base = xmlMemBlocks(); 15538 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 15539 15540 ret_val = inputPop(ctxt); 15541 desret_xmlParserInputPtr(ret_val); 15542 call_tests++; 15543 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 15544 xmlResetLastError(); 15545 if (mem_base != xmlMemBlocks()) { 15546 printf("Leak of %d blocks found in inputPop", 15547 xmlMemBlocks() - mem_base); 15548 test_ret++; 15549 printf(" %d", n_ctxt); 15550 printf("\n"); 15551 } 15552 } 15553 function_tests++; 15554 15555 return(test_ret); 15556 } 15557 15558 15559 static int 15560 test_inputPush(void) { 15561 int test_ret = 0; 15562 15563 int mem_base; 15564 int ret_val; 15565 xmlParserCtxtPtr ctxt; /* an XML parser context */ 15566 int n_ctxt; 15567 xmlParserInputPtr value; /* the parser input */ 15568 int n_value; 15569 15570 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 15571 for (n_value = 0;n_value < gen_nb_xmlParserInputPtr;n_value++) { 15572 mem_base = xmlMemBlocks(); 15573 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 15574 value = gen_xmlParserInputPtr(n_value, 1); 15575 15576 ret_val = inputPush(ctxt, value); 15577 desret_int(ret_val); 15578 call_tests++; 15579 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 15580 des_xmlParserInputPtr(n_value, value, 1); 15581 xmlResetLastError(); 15582 if (mem_base != xmlMemBlocks()) { 15583 printf("Leak of %d blocks found in inputPush", 15584 xmlMemBlocks() - mem_base); 15585 test_ret++; 15586 printf(" %d", n_ctxt); 15587 printf(" %d", n_value); 15588 printf("\n"); 15589 } 15590 } 15591 } 15592 function_tests++; 15593 15594 return(test_ret); 15595 } 15596 15597 15598 static int 15599 test_namePop(void) { 15600 int test_ret = 0; 15601 15602 int mem_base; 15603 const xmlChar * ret_val; 15604 xmlParserCtxtPtr ctxt; /* an XML parser context */ 15605 int n_ctxt; 15606 15607 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 15608 mem_base = xmlMemBlocks(); 15609 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 15610 15611 ret_val = namePop(ctxt); 15612 desret_const_xmlChar_ptr(ret_val); 15613 call_tests++; 15614 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 15615 xmlResetLastError(); 15616 if (mem_base != xmlMemBlocks()) { 15617 printf("Leak of %d blocks found in namePop", 15618 xmlMemBlocks() - mem_base); 15619 test_ret++; 15620 printf(" %d", n_ctxt); 15621 printf("\n"); 15622 } 15623 } 15624 function_tests++; 15625 15626 return(test_ret); 15627 } 15628 15629 15630 static int 15631 test_namePush(void) { 15632 int test_ret = 0; 15633 15634 int mem_base; 15635 int ret_val; 15636 xmlParserCtxtPtr ctxt; /* an XML parser context */ 15637 int n_ctxt; 15638 xmlChar * value; /* the element name */ 15639 int n_value; 15640 15641 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 15642 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 15643 mem_base = xmlMemBlocks(); 15644 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 15645 value = gen_const_xmlChar_ptr(n_value, 1); 15646 15647 ret_val = namePush(ctxt, (const xmlChar *)value); 15648 desret_int(ret_val); 15649 call_tests++; 15650 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 15651 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1); 15652 xmlResetLastError(); 15653 if (mem_base != xmlMemBlocks()) { 15654 printf("Leak of %d blocks found in namePush", 15655 xmlMemBlocks() - mem_base); 15656 test_ret++; 15657 printf(" %d", n_ctxt); 15658 printf(" %d", n_value); 15659 printf("\n"); 15660 } 15661 } 15662 } 15663 function_tests++; 15664 15665 return(test_ret); 15666 } 15667 15668 15669 static int 15670 test_nodePop(void) { 15671 int test_ret = 0; 15672 15673 int mem_base; 15674 xmlNodePtr ret_val; 15675 xmlParserCtxtPtr ctxt; /* an XML parser context */ 15676 int n_ctxt; 15677 15678 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 15679 mem_base = xmlMemBlocks(); 15680 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 15681 15682 ret_val = nodePop(ctxt); 15683 desret_xmlNodePtr(ret_val); 15684 call_tests++; 15685 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 15686 xmlResetLastError(); 15687 if (mem_base != xmlMemBlocks()) { 15688 printf("Leak of %d blocks found in nodePop", 15689 xmlMemBlocks() - mem_base); 15690 test_ret++; 15691 printf(" %d", n_ctxt); 15692 printf("\n"); 15693 } 15694 } 15695 function_tests++; 15696 15697 return(test_ret); 15698 } 15699 15700 15701 static int 15702 test_nodePush(void) { 15703 int test_ret = 0; 15704 15705 int mem_base; 15706 int ret_val; 15707 xmlParserCtxtPtr ctxt; /* an XML parser context */ 15708 int n_ctxt; 15709 xmlNodePtr value; /* the element node */ 15710 int n_value; 15711 15712 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 15713 for (n_value = 0;n_value < gen_nb_xmlNodePtr;n_value++) { 15714 mem_base = xmlMemBlocks(); 15715 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 15716 value = gen_xmlNodePtr(n_value, 1); 15717 15718 ret_val = nodePush(ctxt, value); 15719 desret_int(ret_val); 15720 call_tests++; 15721 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 15722 des_xmlNodePtr(n_value, value, 1); 15723 xmlResetLastError(); 15724 if (mem_base != xmlMemBlocks()) { 15725 printf("Leak of %d blocks found in nodePush", 15726 xmlMemBlocks() - mem_base); 15727 test_ret++; 15728 printf(" %d", n_ctxt); 15729 printf(" %d", n_value); 15730 printf("\n"); 15731 } 15732 } 15733 } 15734 function_tests++; 15735 15736 return(test_ret); 15737 } 15738 15739 15740 static int 15741 test_xmlCheckLanguageID(void) { 15742 int test_ret = 0; 15743 15744 int mem_base; 15745 int ret_val; 15746 xmlChar * lang; /* pointer to the string value */ 15747 int n_lang; 15748 15749 for (n_lang = 0;n_lang < gen_nb_const_xmlChar_ptr;n_lang++) { 15750 mem_base = xmlMemBlocks(); 15751 lang = gen_const_xmlChar_ptr(n_lang, 0); 15752 15753 ret_val = xmlCheckLanguageID((const xmlChar *)lang); 15754 desret_int(ret_val); 15755 call_tests++; 15756 des_const_xmlChar_ptr(n_lang, (const xmlChar *)lang, 0); 15757 xmlResetLastError(); 15758 if (mem_base != xmlMemBlocks()) { 15759 printf("Leak of %d blocks found in xmlCheckLanguageID", 15760 xmlMemBlocks() - mem_base); 15761 test_ret++; 15762 printf(" %d", n_lang); 15763 printf("\n"); 15764 } 15765 } 15766 function_tests++; 15767 15768 return(test_ret); 15769 } 15770 15771 15772 static int 15773 test_xmlCopyChar(void) { 15774 int test_ret = 0; 15775 15776 int mem_base; 15777 int ret_val; 15778 int len; /* Ignored, compatibility */ 15779 int n_len; 15780 xmlChar * out; /* pointer to an array of xmlChar */ 15781 int n_out; 15782 int val; /* the char value */ 15783 int n_val; 15784 15785 for (n_len = 0;n_len < gen_nb_int;n_len++) { 15786 for (n_out = 0;n_out < gen_nb_xmlChar_ptr;n_out++) { 15787 for (n_val = 0;n_val < gen_nb_int;n_val++) { 15788 mem_base = xmlMemBlocks(); 15789 len = gen_int(n_len, 0); 15790 out = gen_xmlChar_ptr(n_out, 1); 15791 val = gen_int(n_val, 2); 15792 15793 ret_val = xmlCopyChar(len, out, val); 15794 desret_int(ret_val); 15795 call_tests++; 15796 des_int(n_len, len, 0); 15797 des_xmlChar_ptr(n_out, out, 1); 15798 des_int(n_val, val, 2); 15799 xmlResetLastError(); 15800 if (mem_base != xmlMemBlocks()) { 15801 printf("Leak of %d blocks found in xmlCopyChar", 15802 xmlMemBlocks() - mem_base); 15803 test_ret++; 15804 printf(" %d", n_len); 15805 printf(" %d", n_out); 15806 printf(" %d", n_val); 15807 printf("\n"); 15808 } 15809 } 15810 } 15811 } 15812 function_tests++; 15813 15814 return(test_ret); 15815 } 15816 15817 15818 static int 15819 test_xmlCopyCharMultiByte(void) { 15820 int test_ret = 0; 15821 15822 int mem_base; 15823 int ret_val; 15824 xmlChar * out; /* pointer to an array of xmlChar */ 15825 int n_out; 15826 int val; /* the char value */ 15827 int n_val; 15828 15829 for (n_out = 0;n_out < gen_nb_xmlChar_ptr;n_out++) { 15830 for (n_val = 0;n_val < gen_nb_int;n_val++) { 15831 mem_base = xmlMemBlocks(); 15832 out = gen_xmlChar_ptr(n_out, 0); 15833 val = gen_int(n_val, 1); 15834 15835 ret_val = xmlCopyCharMultiByte(out, val); 15836 desret_int(ret_val); 15837 call_tests++; 15838 des_xmlChar_ptr(n_out, out, 0); 15839 des_int(n_val, val, 1); 15840 xmlResetLastError(); 15841 if (mem_base != xmlMemBlocks()) { 15842 printf("Leak of %d blocks found in xmlCopyCharMultiByte", 15843 xmlMemBlocks() - mem_base); 15844 test_ret++; 15845 printf(" %d", n_out); 15846 printf(" %d", n_val); 15847 printf("\n"); 15848 } 15849 } 15850 } 15851 function_tests++; 15852 15853 return(test_ret); 15854 } 15855 15856 15857 static int 15858 test_xmlCreateEntityParserCtxt(void) { 15859 int test_ret = 0; 15860 15861 int mem_base; 15862 xmlParserCtxtPtr ret_val; 15863 xmlChar * URL; /* the entity URL */ 15864 int n_URL; 15865 xmlChar * ID; /* the entity PUBLIC ID */ 15866 int n_ID; 15867 xmlChar * base; /* a possible base for the target URI */ 15868 int n_base; 15869 15870 for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) { 15871 for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) { 15872 for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) { 15873 mem_base = xmlMemBlocks(); 15874 URL = gen_const_xmlChar_ptr(n_URL, 0); 15875 ID = gen_const_xmlChar_ptr(n_ID, 1); 15876 base = gen_const_xmlChar_ptr(n_base, 2); 15877 15878 ret_val = xmlCreateEntityParserCtxt((const xmlChar *)URL, (const xmlChar *)ID, (const xmlChar *)base); 15879 desret_xmlParserCtxtPtr(ret_val); 15880 call_tests++; 15881 des_const_xmlChar_ptr(n_URL, (const xmlChar *)URL, 0); 15882 des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 1); 15883 des_const_xmlChar_ptr(n_base, (const xmlChar *)base, 2); 15884 xmlResetLastError(); 15885 if (mem_base != xmlMemBlocks()) { 15886 printf("Leak of %d blocks found in xmlCreateEntityParserCtxt", 15887 xmlMemBlocks() - mem_base); 15888 test_ret++; 15889 printf(" %d", n_URL); 15890 printf(" %d", n_ID); 15891 printf(" %d", n_base); 15892 printf("\n"); 15893 } 15894 } 15895 } 15896 } 15897 function_tests++; 15898 15899 return(test_ret); 15900 } 15901 15902 15903 static int 15904 test_xmlCreateFileParserCtxt(void) { 15905 int test_ret = 0; 15906 15907 int mem_base; 15908 xmlParserCtxtPtr ret_val; 15909 const char * filename; /* the filename */ 15910 int n_filename; 15911 15912 for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) { 15913 mem_base = xmlMemBlocks(); 15914 filename = gen_fileoutput(n_filename, 0); 15915 15916 ret_val = xmlCreateFileParserCtxt(filename); 15917 desret_xmlParserCtxtPtr(ret_val); 15918 call_tests++; 15919 des_fileoutput(n_filename, filename, 0); 15920 xmlResetLastError(); 15921 if (mem_base != xmlMemBlocks()) { 15922 printf("Leak of %d blocks found in xmlCreateFileParserCtxt", 15923 xmlMemBlocks() - mem_base); 15924 test_ret++; 15925 printf(" %d", n_filename); 15926 printf("\n"); 15927 } 15928 } 15929 function_tests++; 15930 15931 return(test_ret); 15932 } 15933 15934 15935 static int 15936 test_xmlCreateMemoryParserCtxt(void) { 15937 int test_ret = 0; 15938 15939 int mem_base; 15940 xmlParserCtxtPtr ret_val; 15941 char * buffer; /* a pointer to a char array */ 15942 int n_buffer; 15943 int size; /* the size of the array */ 15944 int n_size; 15945 15946 for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) { 15947 for (n_size = 0;n_size < gen_nb_int;n_size++) { 15948 mem_base = xmlMemBlocks(); 15949 buffer = gen_const_char_ptr(n_buffer, 0); 15950 size = gen_int(n_size, 1); 15951 15952 ret_val = xmlCreateMemoryParserCtxt((const char *)buffer, size); 15953 desret_xmlParserCtxtPtr(ret_val); 15954 call_tests++; 15955 des_const_char_ptr(n_buffer, (const char *)buffer, 0); 15956 des_int(n_size, size, 1); 15957 xmlResetLastError(); 15958 if (mem_base != xmlMemBlocks()) { 15959 printf("Leak of %d blocks found in xmlCreateMemoryParserCtxt", 15960 xmlMemBlocks() - mem_base); 15961 test_ret++; 15962 printf(" %d", n_buffer); 15963 printf(" %d", n_size); 15964 printf("\n"); 15965 } 15966 } 15967 } 15968 function_tests++; 15969 15970 return(test_ret); 15971 } 15972 15973 15974 static int 15975 test_xmlCreateURLParserCtxt(void) { 15976 int test_ret = 0; 15977 15978 int mem_base; 15979 xmlParserCtxtPtr ret_val; 15980 const char * filename; /* the filename or URL */ 15981 int n_filename; 15982 int options; /* a combination of xmlParserOption */ 15983 int n_options; 15984 15985 for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) { 15986 for (n_options = 0;n_options < gen_nb_int;n_options++) { 15987 mem_base = xmlMemBlocks(); 15988 filename = gen_fileoutput(n_filename, 0); 15989 options = gen_int(n_options, 1); 15990 15991 ret_val = xmlCreateURLParserCtxt(filename, options); 15992 desret_xmlParserCtxtPtr(ret_val); 15993 call_tests++; 15994 des_fileoutput(n_filename, filename, 0); 15995 des_int(n_options, options, 1); 15996 xmlResetLastError(); 15997 if (mem_base != xmlMemBlocks()) { 15998 printf("Leak of %d blocks found in xmlCreateURLParserCtxt", 15999 xmlMemBlocks() - mem_base); 16000 test_ret++; 16001 printf(" %d", n_filename); 16002 printf(" %d", n_options); 16003 printf("\n"); 16004 } 16005 } 16006 } 16007 function_tests++; 16008 16009 return(test_ret); 16010 } 16011 16012 16013 static int 16014 test_xmlCurrentChar(void) { 16015 int test_ret = 0; 16016 16017 int mem_base; 16018 int ret_val; 16019 xmlParserCtxtPtr ctxt; /* the XML parser context */ 16020 int n_ctxt; 16021 int * len; /* pointer to the length of the char read */ 16022 int n_len; 16023 16024 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 16025 for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) { 16026 mem_base = xmlMemBlocks(); 16027 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 16028 len = gen_int_ptr(n_len, 1); 16029 16030 ret_val = xmlCurrentChar(ctxt, len); 16031 desret_int(ret_val); 16032 call_tests++; 16033 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 16034 des_int_ptr(n_len, len, 1); 16035 xmlResetLastError(); 16036 if (mem_base != xmlMemBlocks()) { 16037 printf("Leak of %d blocks found in xmlCurrentChar", 16038 xmlMemBlocks() - mem_base); 16039 test_ret++; 16040 printf(" %d", n_ctxt); 16041 printf(" %d", n_len); 16042 printf("\n"); 16043 } 16044 } 16045 } 16046 function_tests++; 16047 16048 return(test_ret); 16049 } 16050 16051 16052 static int 16053 test_xmlErrMemory(void) { 16054 int test_ret = 0; 16055 16056 int mem_base; 16057 xmlParserCtxtPtr ctxt; /* an XML parser context */ 16058 int n_ctxt; 16059 char * extra; /* extra informations */ 16060 int n_extra; 16061 16062 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 16063 for (n_extra = 0;n_extra < gen_nb_const_char_ptr;n_extra++) { 16064 mem_base = xmlMemBlocks(); 16065 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 16066 extra = gen_const_char_ptr(n_extra, 1); 16067 16068 xmlErrMemory(ctxt, (const char *)extra); 16069 call_tests++; 16070 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 16071 des_const_char_ptr(n_extra, (const char *)extra, 1); 16072 xmlResetLastError(); 16073 if (mem_base != xmlMemBlocks()) { 16074 printf("Leak of %d blocks found in xmlErrMemory", 16075 xmlMemBlocks() - mem_base); 16076 test_ret++; 16077 printf(" %d", n_ctxt); 16078 printf(" %d", n_extra); 16079 printf("\n"); 16080 } 16081 } 16082 } 16083 function_tests++; 16084 16085 return(test_ret); 16086 } 16087 16088 16089 static int 16090 test_xmlIsLetter(void) { 16091 int test_ret = 0; 16092 16093 int mem_base; 16094 int ret_val; 16095 int c; /* an unicode character (int) */ 16096 int n_c; 16097 16098 for (n_c = 0;n_c < gen_nb_int;n_c++) { 16099 mem_base = xmlMemBlocks(); 16100 c = gen_int(n_c, 0); 16101 16102 ret_val = xmlIsLetter(c); 16103 desret_int(ret_val); 16104 call_tests++; 16105 des_int(n_c, c, 0); 16106 xmlResetLastError(); 16107 if (mem_base != xmlMemBlocks()) { 16108 printf("Leak of %d blocks found in xmlIsLetter", 16109 xmlMemBlocks() - mem_base); 16110 test_ret++; 16111 printf(" %d", n_c); 16112 printf("\n"); 16113 } 16114 } 16115 function_tests++; 16116 16117 return(test_ret); 16118 } 16119 16120 16121 static int 16122 test_xmlNewEntityInputStream(void) { 16123 int test_ret = 0; 16124 16125 int mem_base; 16126 xmlParserInputPtr ret_val; 16127 xmlParserCtxtPtr ctxt; /* an XML parser context */ 16128 int n_ctxt; 16129 xmlEntityPtr entity; /* an Entity pointer */ 16130 int n_entity; 16131 16132 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 16133 for (n_entity = 0;n_entity < gen_nb_xmlEntityPtr;n_entity++) { 16134 mem_base = xmlMemBlocks(); 16135 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 16136 entity = gen_xmlEntityPtr(n_entity, 1); 16137 16138 ret_val = xmlNewEntityInputStream(ctxt, entity); 16139 desret_xmlParserInputPtr(ret_val); 16140 call_tests++; 16141 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 16142 des_xmlEntityPtr(n_entity, entity, 1); 16143 xmlResetLastError(); 16144 if (mem_base != xmlMemBlocks()) { 16145 printf("Leak of %d blocks found in xmlNewEntityInputStream", 16146 xmlMemBlocks() - mem_base); 16147 test_ret++; 16148 printf(" %d", n_ctxt); 16149 printf(" %d", n_entity); 16150 printf("\n"); 16151 } 16152 } 16153 } 16154 function_tests++; 16155 16156 return(test_ret); 16157 } 16158 16159 16160 static int 16161 test_xmlNewInputFromFile(void) { 16162 int test_ret = 0; 16163 16164 int mem_base; 16165 xmlParserInputPtr ret_val; 16166 xmlParserCtxtPtr ctxt; /* an XML parser context */ 16167 int n_ctxt; 16168 const char * filename; /* the filename to use as entity */ 16169 int n_filename; 16170 16171 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 16172 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 16173 mem_base = xmlMemBlocks(); 16174 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 16175 filename = gen_filepath(n_filename, 1); 16176 16177 ret_val = xmlNewInputFromFile(ctxt, filename); 16178 desret_xmlParserInputPtr(ret_val); 16179 call_tests++; 16180 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 16181 des_filepath(n_filename, filename, 1); 16182 xmlResetLastError(); 16183 if (mem_base != xmlMemBlocks()) { 16184 printf("Leak of %d blocks found in xmlNewInputFromFile", 16185 xmlMemBlocks() - mem_base); 16186 test_ret++; 16187 printf(" %d", n_ctxt); 16188 printf(" %d", n_filename); 16189 printf("\n"); 16190 } 16191 } 16192 } 16193 function_tests++; 16194 16195 return(test_ret); 16196 } 16197 16198 16199 static int 16200 test_xmlNewInputStream(void) { 16201 int test_ret = 0; 16202 16203 int mem_base; 16204 xmlParserInputPtr ret_val; 16205 xmlParserCtxtPtr ctxt; /* an XML parser context */ 16206 int n_ctxt; 16207 16208 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 16209 mem_base = xmlMemBlocks(); 16210 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 16211 16212 ret_val = xmlNewInputStream(ctxt); 16213 desret_xmlParserInputPtr(ret_val); 16214 call_tests++; 16215 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 16216 xmlResetLastError(); 16217 if (mem_base != xmlMemBlocks()) { 16218 printf("Leak of %d blocks found in xmlNewInputStream", 16219 xmlMemBlocks() - mem_base); 16220 test_ret++; 16221 printf(" %d", n_ctxt); 16222 printf("\n"); 16223 } 16224 } 16225 function_tests++; 16226 16227 return(test_ret); 16228 } 16229 16230 16231 static int 16232 test_xmlNewStringInputStream(void) { 16233 int test_ret = 0; 16234 16235 int mem_base; 16236 xmlParserInputPtr ret_val; 16237 xmlParserCtxtPtr ctxt; /* an XML parser context */ 16238 int n_ctxt; 16239 xmlChar * buffer; /* an memory buffer */ 16240 int n_buffer; 16241 16242 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 16243 for (n_buffer = 0;n_buffer < gen_nb_const_xmlChar_ptr;n_buffer++) { 16244 mem_base = xmlMemBlocks(); 16245 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 16246 buffer = gen_const_xmlChar_ptr(n_buffer, 1); 16247 16248 ret_val = xmlNewStringInputStream(ctxt, (const xmlChar *)buffer); 16249 desret_xmlParserInputPtr(ret_val); 16250 call_tests++; 16251 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 16252 des_const_xmlChar_ptr(n_buffer, (const xmlChar *)buffer, 1); 16253 xmlResetLastError(); 16254 if (mem_base != xmlMemBlocks()) { 16255 printf("Leak of %d blocks found in xmlNewStringInputStream", 16256 xmlMemBlocks() - mem_base); 16257 test_ret++; 16258 printf(" %d", n_ctxt); 16259 printf(" %d", n_buffer); 16260 printf("\n"); 16261 } 16262 } 16263 } 16264 function_tests++; 16265 16266 return(test_ret); 16267 } 16268 16269 16270 static int 16271 test_xmlNextChar(void) { 16272 int test_ret = 0; 16273 16274 int mem_base; 16275 xmlParserCtxtPtr ctxt; /* the XML parser context */ 16276 int n_ctxt; 16277 16278 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 16279 mem_base = xmlMemBlocks(); 16280 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 16281 16282 xmlNextChar(ctxt); 16283 call_tests++; 16284 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 16285 xmlResetLastError(); 16286 if (mem_base != xmlMemBlocks()) { 16287 printf("Leak of %d blocks found in xmlNextChar", 16288 xmlMemBlocks() - mem_base); 16289 test_ret++; 16290 printf(" %d", n_ctxt); 16291 printf("\n"); 16292 } 16293 } 16294 function_tests++; 16295 16296 return(test_ret); 16297 } 16298 16299 16300 static int 16301 test_xmlParserInputShrink(void) { 16302 int test_ret = 0; 16303 16304 int mem_base; 16305 xmlParserInputPtr in; /* an XML parser input */ 16306 int n_in; 16307 16308 for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) { 16309 mem_base = xmlMemBlocks(); 16310 in = gen_xmlParserInputPtr(n_in, 0); 16311 16312 xmlParserInputShrink(in); 16313 call_tests++; 16314 des_xmlParserInputPtr(n_in, in, 0); 16315 xmlResetLastError(); 16316 if (mem_base != xmlMemBlocks()) { 16317 printf("Leak of %d blocks found in xmlParserInputShrink", 16318 xmlMemBlocks() - mem_base); 16319 test_ret++; 16320 printf(" %d", n_in); 16321 printf("\n"); 16322 } 16323 } 16324 function_tests++; 16325 16326 return(test_ret); 16327 } 16328 16329 16330 static int 16331 test_xmlPopInput(void) { 16332 int test_ret = 0; 16333 16334 int mem_base; 16335 xmlChar ret_val; 16336 xmlParserCtxtPtr ctxt; /* an XML parser context */ 16337 int n_ctxt; 16338 16339 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 16340 mem_base = xmlMemBlocks(); 16341 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 16342 16343 ret_val = xmlPopInput(ctxt); 16344 desret_xmlChar(ret_val); 16345 call_tests++; 16346 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 16347 xmlResetLastError(); 16348 if (mem_base != xmlMemBlocks()) { 16349 printf("Leak of %d blocks found in xmlPopInput", 16350 xmlMemBlocks() - mem_base); 16351 test_ret++; 16352 printf(" %d", n_ctxt); 16353 printf("\n"); 16354 } 16355 } 16356 function_tests++; 16357 16358 return(test_ret); 16359 } 16360 16361 16362 static int 16363 test_xmlPushInput(void) { 16364 int test_ret = 0; 16365 16366 int mem_base; 16367 int ret_val; 16368 xmlParserCtxtPtr ctxt; /* an XML parser context */ 16369 int n_ctxt; 16370 xmlParserInputPtr input; /* an XML parser input fragment (entity, XML fragment ...). */ 16371 int n_input; 16372 16373 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 16374 for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) { 16375 mem_base = xmlMemBlocks(); 16376 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 16377 input = gen_xmlParserInputPtr(n_input, 1); 16378 16379 ret_val = xmlPushInput(ctxt, input); 16380 desret_int(ret_val); 16381 call_tests++; 16382 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 16383 des_xmlParserInputPtr(n_input, input, 1); 16384 xmlResetLastError(); 16385 if (mem_base != xmlMemBlocks()) { 16386 printf("Leak of %d blocks found in xmlPushInput", 16387 xmlMemBlocks() - mem_base); 16388 test_ret++; 16389 printf(" %d", n_ctxt); 16390 printf(" %d", n_input); 16391 printf("\n"); 16392 } 16393 } 16394 } 16395 function_tests++; 16396 16397 return(test_ret); 16398 } 16399 16400 16401 static int 16402 test_xmlSetEntityReferenceFunc(void) { 16403 int test_ret = 0; 16404 16405 16406 /* missing type support */ 16407 return(test_ret); 16408 } 16409 16410 16411 static int 16412 test_xmlSplitQName(void) { 16413 int test_ret = 0; 16414 16415 int mem_base; 16416 xmlChar * ret_val; 16417 xmlParserCtxtPtr ctxt; /* an XML parser context */ 16418 int n_ctxt; 16419 xmlChar * name; /* an XML parser context */ 16420 int n_name; 16421 xmlChar ** prefix; /* a xmlChar ** */ 16422 int n_prefix; 16423 16424 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 16425 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 16426 for (n_prefix = 0;n_prefix < gen_nb_xmlChar_ptr_ptr;n_prefix++) { 16427 mem_base = xmlMemBlocks(); 16428 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 16429 name = gen_const_xmlChar_ptr(n_name, 1); 16430 prefix = gen_xmlChar_ptr_ptr(n_prefix, 2); 16431 16432 ret_val = xmlSplitQName(ctxt, (const xmlChar *)name, prefix); 16433 desret_xmlChar_ptr(ret_val); 16434 call_tests++; 16435 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 16436 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 16437 des_xmlChar_ptr_ptr(n_prefix, prefix, 2); 16438 xmlResetLastError(); 16439 if (mem_base != xmlMemBlocks()) { 16440 printf("Leak of %d blocks found in xmlSplitQName", 16441 xmlMemBlocks() - mem_base); 16442 test_ret++; 16443 printf(" %d", n_ctxt); 16444 printf(" %d", n_name); 16445 printf(" %d", n_prefix); 16446 printf("\n"); 16447 } 16448 } 16449 } 16450 } 16451 function_tests++; 16452 16453 return(test_ret); 16454 } 16455 16456 16457 static int 16458 test_xmlStringCurrentChar(void) { 16459 int test_ret = 0; 16460 16461 int mem_base; 16462 int ret_val; 16463 xmlParserCtxtPtr ctxt; /* the XML parser context */ 16464 int n_ctxt; 16465 xmlChar * cur; /* pointer to the beginning of the char */ 16466 int n_cur; 16467 int * len; /* pointer to the length of the char read */ 16468 int n_len; 16469 16470 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 16471 for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) { 16472 for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) { 16473 mem_base = xmlMemBlocks(); 16474 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 16475 cur = gen_const_xmlChar_ptr(n_cur, 1); 16476 len = gen_int_ptr(n_len, 2); 16477 16478 ret_val = xmlStringCurrentChar(ctxt, (const xmlChar *)cur, len); 16479 desret_int(ret_val); 16480 call_tests++; 16481 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 16482 des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1); 16483 des_int_ptr(n_len, len, 2); 16484 xmlResetLastError(); 16485 if (mem_base != xmlMemBlocks()) { 16486 printf("Leak of %d blocks found in xmlStringCurrentChar", 16487 xmlMemBlocks() - mem_base); 16488 test_ret++; 16489 printf(" %d", n_ctxt); 16490 printf(" %d", n_cur); 16491 printf(" %d", n_len); 16492 printf("\n"); 16493 } 16494 } 16495 } 16496 } 16497 function_tests++; 16498 16499 return(test_ret); 16500 } 16501 16502 16503 static int 16504 test_xmlStringDecodeEntities(void) { 16505 int test_ret = 0; 16506 16507 int mem_base; 16508 xmlChar * ret_val; 16509 xmlParserCtxtPtr ctxt; /* the parser context */ 16510 int n_ctxt; 16511 xmlChar * str; /* the input string */ 16512 int n_str; 16513 int what; /* combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF */ 16514 int n_what; 16515 xmlChar end; /* an end marker xmlChar, 0 if none */ 16516 int n_end; 16517 xmlChar end2; /* an end marker xmlChar, 0 if none */ 16518 int n_end2; 16519 xmlChar end3; /* an end marker xmlChar, 0 if none */ 16520 int n_end3; 16521 16522 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 16523 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 16524 for (n_what = 0;n_what < gen_nb_int;n_what++) { 16525 for (n_end = 0;n_end < gen_nb_xmlChar;n_end++) { 16526 for (n_end2 = 0;n_end2 < gen_nb_xmlChar;n_end2++) { 16527 for (n_end3 = 0;n_end3 < gen_nb_xmlChar;n_end3++) { 16528 mem_base = xmlMemBlocks(); 16529 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 16530 str = gen_const_xmlChar_ptr(n_str, 1); 16531 what = gen_int(n_what, 2); 16532 end = gen_xmlChar(n_end, 3); 16533 end2 = gen_xmlChar(n_end2, 4); 16534 end3 = gen_xmlChar(n_end3, 5); 16535 16536 ret_val = xmlStringDecodeEntities(ctxt, (const xmlChar *)str, what, end, end2, end3); 16537 desret_xmlChar_ptr(ret_val); 16538 call_tests++; 16539 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 16540 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1); 16541 des_int(n_what, what, 2); 16542 des_xmlChar(n_end, end, 3); 16543 des_xmlChar(n_end2, end2, 4); 16544 des_xmlChar(n_end3, end3, 5); 16545 xmlResetLastError(); 16546 if (mem_base != xmlMemBlocks()) { 16547 printf("Leak of %d blocks found in xmlStringDecodeEntities", 16548 xmlMemBlocks() - mem_base); 16549 test_ret++; 16550 printf(" %d", n_ctxt); 16551 printf(" %d", n_str); 16552 printf(" %d", n_what); 16553 printf(" %d", n_end); 16554 printf(" %d", n_end2); 16555 printf(" %d", n_end3); 16556 printf("\n"); 16557 } 16558 } 16559 } 16560 } 16561 } 16562 } 16563 } 16564 function_tests++; 16565 16566 return(test_ret); 16567 } 16568 16569 16570 static int 16571 test_xmlStringLenDecodeEntities(void) { 16572 int test_ret = 0; 16573 16574 int mem_base; 16575 xmlChar * ret_val; 16576 xmlParserCtxtPtr ctxt; /* the parser context */ 16577 int n_ctxt; 16578 xmlChar * str; /* the input string */ 16579 int n_str; 16580 int len; /* the string length */ 16581 int n_len; 16582 int what; /* combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF */ 16583 int n_what; 16584 xmlChar end; /* an end marker xmlChar, 0 if none */ 16585 int n_end; 16586 xmlChar end2; /* an end marker xmlChar, 0 if none */ 16587 int n_end2; 16588 xmlChar end3; /* an end marker xmlChar, 0 if none */ 16589 int n_end3; 16590 16591 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 16592 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 16593 for (n_len = 0;n_len < gen_nb_int;n_len++) { 16594 for (n_what = 0;n_what < gen_nb_int;n_what++) { 16595 for (n_end = 0;n_end < gen_nb_xmlChar;n_end++) { 16596 for (n_end2 = 0;n_end2 < gen_nb_xmlChar;n_end2++) { 16597 for (n_end3 = 0;n_end3 < gen_nb_xmlChar;n_end3++) { 16598 mem_base = xmlMemBlocks(); 16599 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 16600 str = gen_const_xmlChar_ptr(n_str, 1); 16601 len = gen_int(n_len, 2); 16602 what = gen_int(n_what, 3); 16603 end = gen_xmlChar(n_end, 4); 16604 end2 = gen_xmlChar(n_end2, 5); 16605 end3 = gen_xmlChar(n_end3, 6); 16606 16607 ret_val = xmlStringLenDecodeEntities(ctxt, (const xmlChar *)str, len, what, end, end2, end3); 16608 desret_xmlChar_ptr(ret_val); 16609 call_tests++; 16610 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 16611 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1); 16612 des_int(n_len, len, 2); 16613 des_int(n_what, what, 3); 16614 des_xmlChar(n_end, end, 4); 16615 des_xmlChar(n_end2, end2, 5); 16616 des_xmlChar(n_end3, end3, 6); 16617 xmlResetLastError(); 16618 if (mem_base != xmlMemBlocks()) { 16619 printf("Leak of %d blocks found in xmlStringLenDecodeEntities", 16620 xmlMemBlocks() - mem_base); 16621 test_ret++; 16622 printf(" %d", n_ctxt); 16623 printf(" %d", n_str); 16624 printf(" %d", n_len); 16625 printf(" %d", n_what); 16626 printf(" %d", n_end); 16627 printf(" %d", n_end2); 16628 printf(" %d", n_end3); 16629 printf("\n"); 16630 } 16631 } 16632 } 16633 } 16634 } 16635 } 16636 } 16637 } 16638 function_tests++; 16639 16640 return(test_ret); 16641 } 16642 16643 16644 static int 16645 test_xmlSwitchEncoding(void) { 16646 int test_ret = 0; 16647 16648 int mem_base; 16649 int ret_val; 16650 xmlParserCtxtPtr ctxt; /* the parser context */ 16651 int n_ctxt; 16652 xmlCharEncoding enc; /* the encoding value (number) */ 16653 int n_enc; 16654 16655 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 16656 for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) { 16657 mem_base = xmlMemBlocks(); 16658 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 16659 enc = gen_xmlCharEncoding(n_enc, 1); 16660 16661 ret_val = xmlSwitchEncoding(ctxt, enc); 16662 desret_int(ret_val); 16663 call_tests++; 16664 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 16665 des_xmlCharEncoding(n_enc, enc, 1); 16666 xmlResetLastError(); 16667 if (mem_base != xmlMemBlocks()) { 16668 printf("Leak of %d blocks found in xmlSwitchEncoding", 16669 xmlMemBlocks() - mem_base); 16670 test_ret++; 16671 printf(" %d", n_ctxt); 16672 printf(" %d", n_enc); 16673 printf("\n"); 16674 } 16675 } 16676 } 16677 function_tests++; 16678 16679 return(test_ret); 16680 } 16681 16682 16683 static int 16684 test_xmlSwitchInputEncoding(void) { 16685 int test_ret = 0; 16686 16687 int mem_base; 16688 int ret_val; 16689 xmlParserCtxtPtr ctxt; /* the parser context */ 16690 int n_ctxt; 16691 xmlParserInputPtr input; /* the input stream */ 16692 int n_input; 16693 xmlCharEncodingHandlerPtr handler; /* the encoding handler */ 16694 int n_handler; 16695 16696 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 16697 for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) { 16698 for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) { 16699 mem_base = xmlMemBlocks(); 16700 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 16701 input = gen_xmlParserInputPtr(n_input, 1); 16702 handler = gen_xmlCharEncodingHandlerPtr(n_handler, 2); 16703 16704 ret_val = xmlSwitchInputEncoding(ctxt, input, handler); 16705 desret_int(ret_val); 16706 call_tests++; 16707 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 16708 des_xmlParserInputPtr(n_input, input, 1); 16709 des_xmlCharEncodingHandlerPtr(n_handler, handler, 2); 16710 xmlResetLastError(); 16711 if (mem_base != xmlMemBlocks()) { 16712 printf("Leak of %d blocks found in xmlSwitchInputEncoding", 16713 xmlMemBlocks() - mem_base); 16714 test_ret++; 16715 printf(" %d", n_ctxt); 16716 printf(" %d", n_input); 16717 printf(" %d", n_handler); 16718 printf("\n"); 16719 } 16720 } 16721 } 16722 } 16723 function_tests++; 16724 16725 return(test_ret); 16726 } 16727 16728 16729 static int 16730 test_xmlSwitchToEncoding(void) { 16731 int test_ret = 0; 16732 16733 int mem_base; 16734 int ret_val; 16735 xmlParserCtxtPtr ctxt; /* the parser context */ 16736 int n_ctxt; 16737 xmlCharEncodingHandlerPtr handler; /* the encoding handler */ 16738 int n_handler; 16739 16740 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 16741 for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) { 16742 mem_base = xmlMemBlocks(); 16743 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 16744 handler = gen_xmlCharEncodingHandlerPtr(n_handler, 1); 16745 16746 ret_val = xmlSwitchToEncoding(ctxt, handler); 16747 desret_int(ret_val); 16748 call_tests++; 16749 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 16750 des_xmlCharEncodingHandlerPtr(n_handler, handler, 1); 16751 xmlResetLastError(); 16752 if (mem_base != xmlMemBlocks()) { 16753 printf("Leak of %d blocks found in xmlSwitchToEncoding", 16754 xmlMemBlocks() - mem_base); 16755 test_ret++; 16756 printf(" %d", n_ctxt); 16757 printf(" %d", n_handler); 16758 printf("\n"); 16759 } 16760 } 16761 } 16762 function_tests++; 16763 16764 return(test_ret); 16765 } 16766 16767 static int 16768 test_parserInternals(void) { 16769 int test_ret = 0; 16770 16771 if (quiet == 0) printf("Testing parserInternals : 33 of 90 functions ...\n"); 16772 test_ret += test_htmlCreateFileParserCtxt(); 16773 test_ret += test_htmlInitAutoClose(); 16774 test_ret += test_inputPop(); 16775 test_ret += test_inputPush(); 16776 test_ret += test_namePop(); 16777 test_ret += test_namePush(); 16778 test_ret += test_nodePop(); 16779 test_ret += test_nodePush(); 16780 test_ret += test_xmlCheckLanguageID(); 16781 test_ret += test_xmlCopyChar(); 16782 test_ret += test_xmlCopyCharMultiByte(); 16783 test_ret += test_xmlCreateEntityParserCtxt(); 16784 test_ret += test_xmlCreateFileParserCtxt(); 16785 test_ret += test_xmlCreateMemoryParserCtxt(); 16786 test_ret += test_xmlCreateURLParserCtxt(); 16787 test_ret += test_xmlCurrentChar(); 16788 test_ret += test_xmlErrMemory(); 16789 test_ret += test_xmlIsLetter(); 16790 test_ret += test_xmlNewEntityInputStream(); 16791 test_ret += test_xmlNewInputFromFile(); 16792 test_ret += test_xmlNewInputStream(); 16793 test_ret += test_xmlNewStringInputStream(); 16794 test_ret += test_xmlNextChar(); 16795 test_ret += test_xmlParserInputShrink(); 16796 test_ret += test_xmlPopInput(); 16797 test_ret += test_xmlPushInput(); 16798 test_ret += test_xmlSetEntityReferenceFunc(); 16799 test_ret += test_xmlSplitQName(); 16800 test_ret += test_xmlStringCurrentChar(); 16801 test_ret += test_xmlStringDecodeEntities(); 16802 test_ret += test_xmlStringLenDecodeEntities(); 16803 test_ret += test_xmlSwitchEncoding(); 16804 test_ret += test_xmlSwitchInputEncoding(); 16805 test_ret += test_xmlSwitchToEncoding(); 16806 16807 if (test_ret != 0) 16808 printf("Module parserInternals: %d errors\n", test_ret); 16809 return(test_ret); 16810 } 16811 16812 static int 16813 test_xmlPatternFromRoot(void) { 16814 int test_ret = 0; 16815 16816 #if defined(LIBXML_PATTERN_ENABLED) 16817 int mem_base; 16818 int ret_val; 16819 xmlPatternPtr comp; /* the precompiled pattern */ 16820 int n_comp; 16821 16822 for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) { 16823 mem_base = xmlMemBlocks(); 16824 comp = gen_xmlPatternPtr(n_comp, 0); 16825 16826 ret_val = xmlPatternFromRoot(comp); 16827 desret_int(ret_val); 16828 call_tests++; 16829 des_xmlPatternPtr(n_comp, comp, 0); 16830 xmlResetLastError(); 16831 if (mem_base != xmlMemBlocks()) { 16832 printf("Leak of %d blocks found in xmlPatternFromRoot", 16833 xmlMemBlocks() - mem_base); 16834 test_ret++; 16835 printf(" %d", n_comp); 16836 printf("\n"); 16837 } 16838 } 16839 function_tests++; 16840 #endif 16841 16842 return(test_ret); 16843 } 16844 16845 16846 static int 16847 test_xmlPatternGetStreamCtxt(void) { 16848 int test_ret = 0; 16849 16850 16851 /* missing type support */ 16852 return(test_ret); 16853 } 16854 16855 16856 static int 16857 test_xmlPatternMatch(void) { 16858 int test_ret = 0; 16859 16860 #if defined(LIBXML_PATTERN_ENABLED) 16861 int mem_base; 16862 int ret_val; 16863 xmlPatternPtr comp; /* the precompiled pattern */ 16864 int n_comp; 16865 xmlNodePtr node; /* a node */ 16866 int n_node; 16867 16868 for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) { 16869 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 16870 mem_base = xmlMemBlocks(); 16871 comp = gen_xmlPatternPtr(n_comp, 0); 16872 node = gen_xmlNodePtr(n_node, 1); 16873 16874 ret_val = xmlPatternMatch(comp, node); 16875 desret_int(ret_val); 16876 call_tests++; 16877 des_xmlPatternPtr(n_comp, comp, 0); 16878 des_xmlNodePtr(n_node, node, 1); 16879 xmlResetLastError(); 16880 if (mem_base != xmlMemBlocks()) { 16881 printf("Leak of %d blocks found in xmlPatternMatch", 16882 xmlMemBlocks() - mem_base); 16883 test_ret++; 16884 printf(" %d", n_comp); 16885 printf(" %d", n_node); 16886 printf("\n"); 16887 } 16888 } 16889 } 16890 function_tests++; 16891 #endif 16892 16893 return(test_ret); 16894 } 16895 16896 16897 static int 16898 test_xmlPatternMaxDepth(void) { 16899 int test_ret = 0; 16900 16901 #if defined(LIBXML_PATTERN_ENABLED) 16902 int mem_base; 16903 int ret_val; 16904 xmlPatternPtr comp; /* the precompiled pattern */ 16905 int n_comp; 16906 16907 for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) { 16908 mem_base = xmlMemBlocks(); 16909 comp = gen_xmlPatternPtr(n_comp, 0); 16910 16911 ret_val = xmlPatternMaxDepth(comp); 16912 desret_int(ret_val); 16913 call_tests++; 16914 des_xmlPatternPtr(n_comp, comp, 0); 16915 xmlResetLastError(); 16916 if (mem_base != xmlMemBlocks()) { 16917 printf("Leak of %d blocks found in xmlPatternMaxDepth", 16918 xmlMemBlocks() - mem_base); 16919 test_ret++; 16920 printf(" %d", n_comp); 16921 printf("\n"); 16922 } 16923 } 16924 function_tests++; 16925 #endif 16926 16927 return(test_ret); 16928 } 16929 16930 16931 static int 16932 test_xmlPatternMinDepth(void) { 16933 int test_ret = 0; 16934 16935 #if defined(LIBXML_PATTERN_ENABLED) 16936 int mem_base; 16937 int ret_val; 16938 xmlPatternPtr comp; /* the precompiled pattern */ 16939 int n_comp; 16940 16941 for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) { 16942 mem_base = xmlMemBlocks(); 16943 comp = gen_xmlPatternPtr(n_comp, 0); 16944 16945 ret_val = xmlPatternMinDepth(comp); 16946 desret_int(ret_val); 16947 call_tests++; 16948 des_xmlPatternPtr(n_comp, comp, 0); 16949 xmlResetLastError(); 16950 if (mem_base != xmlMemBlocks()) { 16951 printf("Leak of %d blocks found in xmlPatternMinDepth", 16952 xmlMemBlocks() - mem_base); 16953 test_ret++; 16954 printf(" %d", n_comp); 16955 printf("\n"); 16956 } 16957 } 16958 function_tests++; 16959 #endif 16960 16961 return(test_ret); 16962 } 16963 16964 16965 static int 16966 test_xmlPatternStreamable(void) { 16967 int test_ret = 0; 16968 16969 #if defined(LIBXML_PATTERN_ENABLED) 16970 int mem_base; 16971 int ret_val; 16972 xmlPatternPtr comp; /* the precompiled pattern */ 16973 int n_comp; 16974 16975 for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) { 16976 mem_base = xmlMemBlocks(); 16977 comp = gen_xmlPatternPtr(n_comp, 0); 16978 16979 ret_val = xmlPatternStreamable(comp); 16980 desret_int(ret_val); 16981 call_tests++; 16982 des_xmlPatternPtr(n_comp, comp, 0); 16983 xmlResetLastError(); 16984 if (mem_base != xmlMemBlocks()) { 16985 printf("Leak of %d blocks found in xmlPatternStreamable", 16986 xmlMemBlocks() - mem_base); 16987 test_ret++; 16988 printf(" %d", n_comp); 16989 printf("\n"); 16990 } 16991 } 16992 function_tests++; 16993 #endif 16994 16995 return(test_ret); 16996 } 16997 16998 16999 static int 17000 test_xmlPatterncompile(void) { 17001 int test_ret = 0; 17002 17003 17004 /* missing type support */ 17005 return(test_ret); 17006 } 17007 17008 #ifdef LIBXML_PATTERN_ENABLED 17009 17010 #define gen_nb_xmlStreamCtxtPtr 1 17011 static xmlStreamCtxtPtr gen_xmlStreamCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 17012 return(NULL); 17013 } 17014 static void des_xmlStreamCtxtPtr(int no ATTRIBUTE_UNUSED, xmlStreamCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 17015 } 17016 #endif 17017 17018 17019 static int 17020 test_xmlStreamPop(void) { 17021 int test_ret = 0; 17022 17023 #if defined(LIBXML_PATTERN_ENABLED) 17024 int mem_base; 17025 int ret_val; 17026 xmlStreamCtxtPtr stream; /* the stream context */ 17027 int n_stream; 17028 17029 for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) { 17030 mem_base = xmlMemBlocks(); 17031 stream = gen_xmlStreamCtxtPtr(n_stream, 0); 17032 17033 ret_val = xmlStreamPop(stream); 17034 desret_int(ret_val); 17035 call_tests++; 17036 des_xmlStreamCtxtPtr(n_stream, stream, 0); 17037 xmlResetLastError(); 17038 if (mem_base != xmlMemBlocks()) { 17039 printf("Leak of %d blocks found in xmlStreamPop", 17040 xmlMemBlocks() - mem_base); 17041 test_ret++; 17042 printf(" %d", n_stream); 17043 printf("\n"); 17044 } 17045 } 17046 function_tests++; 17047 #endif 17048 17049 return(test_ret); 17050 } 17051 17052 17053 static int 17054 test_xmlStreamPush(void) { 17055 int test_ret = 0; 17056 17057 #if defined(LIBXML_PATTERN_ENABLED) 17058 int mem_base; 17059 int ret_val; 17060 xmlStreamCtxtPtr stream; /* the stream context */ 17061 int n_stream; 17062 xmlChar * name; /* the current name */ 17063 int n_name; 17064 xmlChar * ns; /* the namespace name */ 17065 int n_ns; 17066 17067 for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) { 17068 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 17069 for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) { 17070 mem_base = xmlMemBlocks(); 17071 stream = gen_xmlStreamCtxtPtr(n_stream, 0); 17072 name = gen_const_xmlChar_ptr(n_name, 1); 17073 ns = gen_const_xmlChar_ptr(n_ns, 2); 17074 17075 ret_val = xmlStreamPush(stream, (const xmlChar *)name, (const xmlChar *)ns); 17076 desret_int(ret_val); 17077 call_tests++; 17078 des_xmlStreamCtxtPtr(n_stream, stream, 0); 17079 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 17080 des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 2); 17081 xmlResetLastError(); 17082 if (mem_base != xmlMemBlocks()) { 17083 printf("Leak of %d blocks found in xmlStreamPush", 17084 xmlMemBlocks() - mem_base); 17085 test_ret++; 17086 printf(" %d", n_stream); 17087 printf(" %d", n_name); 17088 printf(" %d", n_ns); 17089 printf("\n"); 17090 } 17091 } 17092 } 17093 } 17094 function_tests++; 17095 #endif 17096 17097 return(test_ret); 17098 } 17099 17100 17101 static int 17102 test_xmlStreamPushAttr(void) { 17103 int test_ret = 0; 17104 17105 #if defined(LIBXML_PATTERN_ENABLED) 17106 int mem_base; 17107 int ret_val; 17108 xmlStreamCtxtPtr stream; /* the stream context */ 17109 int n_stream; 17110 xmlChar * name; /* the current name */ 17111 int n_name; 17112 xmlChar * ns; /* the namespace name */ 17113 int n_ns; 17114 17115 for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) { 17116 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 17117 for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) { 17118 mem_base = xmlMemBlocks(); 17119 stream = gen_xmlStreamCtxtPtr(n_stream, 0); 17120 name = gen_const_xmlChar_ptr(n_name, 1); 17121 ns = gen_const_xmlChar_ptr(n_ns, 2); 17122 17123 ret_val = xmlStreamPushAttr(stream, (const xmlChar *)name, (const xmlChar *)ns); 17124 desret_int(ret_val); 17125 call_tests++; 17126 des_xmlStreamCtxtPtr(n_stream, stream, 0); 17127 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 17128 des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 2); 17129 xmlResetLastError(); 17130 if (mem_base != xmlMemBlocks()) { 17131 printf("Leak of %d blocks found in xmlStreamPushAttr", 17132 xmlMemBlocks() - mem_base); 17133 test_ret++; 17134 printf(" %d", n_stream); 17135 printf(" %d", n_name); 17136 printf(" %d", n_ns); 17137 printf("\n"); 17138 } 17139 } 17140 } 17141 } 17142 function_tests++; 17143 #endif 17144 17145 return(test_ret); 17146 } 17147 17148 17149 static int 17150 test_xmlStreamPushNode(void) { 17151 int test_ret = 0; 17152 17153 #if defined(LIBXML_PATTERN_ENABLED) 17154 int mem_base; 17155 int ret_val; 17156 xmlStreamCtxtPtr stream; /* the stream context */ 17157 int n_stream; 17158 xmlChar * name; /* the current name */ 17159 int n_name; 17160 xmlChar * ns; /* the namespace name */ 17161 int n_ns; 17162 int nodeType; /* the type of the node being pushed */ 17163 int n_nodeType; 17164 17165 for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) { 17166 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 17167 for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) { 17168 for (n_nodeType = 0;n_nodeType < gen_nb_int;n_nodeType++) { 17169 mem_base = xmlMemBlocks(); 17170 stream = gen_xmlStreamCtxtPtr(n_stream, 0); 17171 name = gen_const_xmlChar_ptr(n_name, 1); 17172 ns = gen_const_xmlChar_ptr(n_ns, 2); 17173 nodeType = gen_int(n_nodeType, 3); 17174 17175 ret_val = xmlStreamPushNode(stream, (const xmlChar *)name, (const xmlChar *)ns, nodeType); 17176 desret_int(ret_val); 17177 call_tests++; 17178 des_xmlStreamCtxtPtr(n_stream, stream, 0); 17179 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 17180 des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 2); 17181 des_int(n_nodeType, nodeType, 3); 17182 xmlResetLastError(); 17183 if (mem_base != xmlMemBlocks()) { 17184 printf("Leak of %d blocks found in xmlStreamPushNode", 17185 xmlMemBlocks() - mem_base); 17186 test_ret++; 17187 printf(" %d", n_stream); 17188 printf(" %d", n_name); 17189 printf(" %d", n_ns); 17190 printf(" %d", n_nodeType); 17191 printf("\n"); 17192 } 17193 } 17194 } 17195 } 17196 } 17197 function_tests++; 17198 #endif 17199 17200 return(test_ret); 17201 } 17202 17203 17204 static int 17205 test_xmlStreamWantsAnyNode(void) { 17206 int test_ret = 0; 17207 17208 #if defined(LIBXML_PATTERN_ENABLED) 17209 int mem_base; 17210 int ret_val; 17211 xmlStreamCtxtPtr streamCtxt; /* the stream context */ 17212 int n_streamCtxt; 17213 17214 for (n_streamCtxt = 0;n_streamCtxt < gen_nb_xmlStreamCtxtPtr;n_streamCtxt++) { 17215 mem_base = xmlMemBlocks(); 17216 streamCtxt = gen_xmlStreamCtxtPtr(n_streamCtxt, 0); 17217 17218 ret_val = xmlStreamWantsAnyNode(streamCtxt); 17219 desret_int(ret_val); 17220 call_tests++; 17221 des_xmlStreamCtxtPtr(n_streamCtxt, streamCtxt, 0); 17222 xmlResetLastError(); 17223 if (mem_base != xmlMemBlocks()) { 17224 printf("Leak of %d blocks found in xmlStreamWantsAnyNode", 17225 xmlMemBlocks() - mem_base); 17226 test_ret++; 17227 printf(" %d", n_streamCtxt); 17228 printf("\n"); 17229 } 17230 } 17231 function_tests++; 17232 #endif 17233 17234 return(test_ret); 17235 } 17236 17237 static int 17238 test_pattern(void) { 17239 int test_ret = 0; 17240 17241 if (quiet == 0) printf("Testing pattern : 10 of 15 functions ...\n"); 17242 test_ret += test_xmlPatternFromRoot(); 17243 test_ret += test_xmlPatternGetStreamCtxt(); 17244 test_ret += test_xmlPatternMatch(); 17245 test_ret += test_xmlPatternMaxDepth(); 17246 test_ret += test_xmlPatternMinDepth(); 17247 test_ret += test_xmlPatternStreamable(); 17248 test_ret += test_xmlPatterncompile(); 17249 test_ret += test_xmlStreamPop(); 17250 test_ret += test_xmlStreamPush(); 17251 test_ret += test_xmlStreamPushAttr(); 17252 test_ret += test_xmlStreamPushNode(); 17253 test_ret += test_xmlStreamWantsAnyNode(); 17254 17255 if (test_ret != 0) 17256 printf("Module pattern: %d errors\n", test_ret); 17257 return(test_ret); 17258 } 17259 #ifdef LIBXML_SCHEMAS_ENABLED 17260 17261 #define gen_nb_xmlRelaxNGPtr 1 17262 static xmlRelaxNGPtr gen_xmlRelaxNGPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 17263 return(NULL); 17264 } 17265 static void des_xmlRelaxNGPtr(int no ATTRIBUTE_UNUSED, xmlRelaxNGPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 17266 } 17267 #endif 17268 17269 17270 static int 17271 test_xmlRelaxNGDump(void) { 17272 int test_ret = 0; 17273 17274 #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 17275 int mem_base; 17276 FILE * output; /* the file output */ 17277 int n_output; 17278 xmlRelaxNGPtr schema; /* a schema structure */ 17279 int n_schema; 17280 17281 for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) { 17282 for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) { 17283 mem_base = xmlMemBlocks(); 17284 output = gen_FILE_ptr(n_output, 0); 17285 schema = gen_xmlRelaxNGPtr(n_schema, 1); 17286 17287 xmlRelaxNGDump(output, schema); 17288 call_tests++; 17289 des_FILE_ptr(n_output, output, 0); 17290 des_xmlRelaxNGPtr(n_schema, schema, 1); 17291 xmlResetLastError(); 17292 if (mem_base != xmlMemBlocks()) { 17293 printf("Leak of %d blocks found in xmlRelaxNGDump", 17294 xmlMemBlocks() - mem_base); 17295 test_ret++; 17296 printf(" %d", n_output); 17297 printf(" %d", n_schema); 17298 printf("\n"); 17299 } 17300 } 17301 } 17302 function_tests++; 17303 #endif 17304 17305 return(test_ret); 17306 } 17307 17308 17309 static int 17310 test_xmlRelaxNGDumpTree(void) { 17311 int test_ret = 0; 17312 17313 #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 17314 int mem_base; 17315 FILE * output; /* the file output */ 17316 int n_output; 17317 xmlRelaxNGPtr schema; /* a schema structure */ 17318 int n_schema; 17319 17320 for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) { 17321 for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) { 17322 mem_base = xmlMemBlocks(); 17323 output = gen_FILE_ptr(n_output, 0); 17324 schema = gen_xmlRelaxNGPtr(n_schema, 1); 17325 17326 xmlRelaxNGDumpTree(output, schema); 17327 call_tests++; 17328 des_FILE_ptr(n_output, output, 0); 17329 des_xmlRelaxNGPtr(n_schema, schema, 1); 17330 xmlResetLastError(); 17331 if (mem_base != xmlMemBlocks()) { 17332 printf("Leak of %d blocks found in xmlRelaxNGDumpTree", 17333 xmlMemBlocks() - mem_base); 17334 test_ret++; 17335 printf(" %d", n_output); 17336 printf(" %d", n_schema); 17337 printf("\n"); 17338 } 17339 } 17340 } 17341 function_tests++; 17342 #endif 17343 17344 return(test_ret); 17345 } 17346 17347 #ifdef LIBXML_SCHEMAS_ENABLED 17348 17349 #define gen_nb_xmlRelaxNGParserCtxtPtr 1 17350 static xmlRelaxNGParserCtxtPtr gen_xmlRelaxNGParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 17351 return(NULL); 17352 } 17353 static void des_xmlRelaxNGParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlRelaxNGParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 17354 } 17355 #endif 17356 17357 #ifdef LIBXML_SCHEMAS_ENABLED 17358 17359 #define gen_nb_xmlRelaxNGValidityErrorFunc_ptr 1 17360 static xmlRelaxNGValidityErrorFunc * gen_xmlRelaxNGValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 17361 return(NULL); 17362 } 17363 static void des_xmlRelaxNGValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlRelaxNGValidityErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 17364 } 17365 #endif 17366 17367 #ifdef LIBXML_SCHEMAS_ENABLED 17368 17369 #define gen_nb_xmlRelaxNGValidityWarningFunc_ptr 1 17370 static xmlRelaxNGValidityWarningFunc * gen_xmlRelaxNGValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 17371 return(NULL); 17372 } 17373 static void des_xmlRelaxNGValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, xmlRelaxNGValidityWarningFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 17374 } 17375 #endif 17376 17377 17378 static int 17379 test_xmlRelaxNGGetParserErrors(void) { 17380 int test_ret = 0; 17381 17382 #if defined(LIBXML_SCHEMAS_ENABLED) 17383 int mem_base; 17384 int ret_val; 17385 xmlRelaxNGParserCtxtPtr ctxt; /* a Relax-NG validation context */ 17386 int n_ctxt; 17387 xmlRelaxNGValidityErrorFunc * err; /* the error callback result */ 17388 int n_err; 17389 xmlRelaxNGValidityWarningFunc * warn; /* the warning callback result */ 17390 int n_warn; 17391 void ** ctx; /* contextual data for the callbacks result */ 17392 int n_ctx; 17393 17394 for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGParserCtxtPtr;n_ctxt++) { 17395 for (n_err = 0;n_err < gen_nb_xmlRelaxNGValidityErrorFunc_ptr;n_err++) { 17396 for (n_warn = 0;n_warn < gen_nb_xmlRelaxNGValidityWarningFunc_ptr;n_warn++) { 17397 for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) { 17398 mem_base = xmlMemBlocks(); 17399 ctxt = gen_xmlRelaxNGParserCtxtPtr(n_ctxt, 0); 17400 err = gen_xmlRelaxNGValidityErrorFunc_ptr(n_err, 1); 17401 warn = gen_xmlRelaxNGValidityWarningFunc_ptr(n_warn, 2); 17402 ctx = gen_void_ptr_ptr(n_ctx, 3); 17403 17404 ret_val = xmlRelaxNGGetParserErrors(ctxt, err, warn, ctx); 17405 desret_int(ret_val); 17406 call_tests++; 17407 des_xmlRelaxNGParserCtxtPtr(n_ctxt, ctxt, 0); 17408 des_xmlRelaxNGValidityErrorFunc_ptr(n_err, err, 1); 17409 des_xmlRelaxNGValidityWarningFunc_ptr(n_warn, warn, 2); 17410 des_void_ptr_ptr(n_ctx, ctx, 3); 17411 xmlResetLastError(); 17412 if (mem_base != xmlMemBlocks()) { 17413 printf("Leak of %d blocks found in xmlRelaxNGGetParserErrors", 17414 xmlMemBlocks() - mem_base); 17415 test_ret++; 17416 printf(" %d", n_ctxt); 17417 printf(" %d", n_err); 17418 printf(" %d", n_warn); 17419 printf(" %d", n_ctx); 17420 printf("\n"); 17421 } 17422 } 17423 } 17424 } 17425 } 17426 function_tests++; 17427 #endif 17428 17429 return(test_ret); 17430 } 17431 17432 #ifdef LIBXML_SCHEMAS_ENABLED 17433 17434 #define gen_nb_xmlRelaxNGValidCtxtPtr 1 17435 static xmlRelaxNGValidCtxtPtr gen_xmlRelaxNGValidCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 17436 return(NULL); 17437 } 17438 static void des_xmlRelaxNGValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlRelaxNGValidCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 17439 } 17440 #endif 17441 17442 17443 static int 17444 test_xmlRelaxNGGetValidErrors(void) { 17445 int test_ret = 0; 17446 17447 #if defined(LIBXML_SCHEMAS_ENABLED) 17448 int mem_base; 17449 int ret_val; 17450 xmlRelaxNGValidCtxtPtr ctxt; /* a Relax-NG validation context */ 17451 int n_ctxt; 17452 xmlRelaxNGValidityErrorFunc * err; /* the error function result */ 17453 int n_err; 17454 xmlRelaxNGValidityWarningFunc * warn; /* the warning function result */ 17455 int n_warn; 17456 void ** ctx; /* the functions context result */ 17457 int n_ctx; 17458 17459 for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) { 17460 for (n_err = 0;n_err < gen_nb_xmlRelaxNGValidityErrorFunc_ptr;n_err++) { 17461 for (n_warn = 0;n_warn < gen_nb_xmlRelaxNGValidityWarningFunc_ptr;n_warn++) { 17462 for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) { 17463 mem_base = xmlMemBlocks(); 17464 ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0); 17465 err = gen_xmlRelaxNGValidityErrorFunc_ptr(n_err, 1); 17466 warn = gen_xmlRelaxNGValidityWarningFunc_ptr(n_warn, 2); 17467 ctx = gen_void_ptr_ptr(n_ctx, 3); 17468 17469 ret_val = xmlRelaxNGGetValidErrors(ctxt, err, warn, ctx); 17470 desret_int(ret_val); 17471 call_tests++; 17472 des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0); 17473 des_xmlRelaxNGValidityErrorFunc_ptr(n_err, err, 1); 17474 des_xmlRelaxNGValidityWarningFunc_ptr(n_warn, warn, 2); 17475 des_void_ptr_ptr(n_ctx, ctx, 3); 17476 xmlResetLastError(); 17477 if (mem_base != xmlMemBlocks()) { 17478 printf("Leak of %d blocks found in xmlRelaxNGGetValidErrors", 17479 xmlMemBlocks() - mem_base); 17480 test_ret++; 17481 printf(" %d", n_ctxt); 17482 printf(" %d", n_err); 17483 printf(" %d", n_warn); 17484 printf(" %d", n_ctx); 17485 printf("\n"); 17486 } 17487 } 17488 } 17489 } 17490 } 17491 function_tests++; 17492 #endif 17493 17494 return(test_ret); 17495 } 17496 17497 17498 static int 17499 test_xmlRelaxNGInitTypes(void) { 17500 int test_ret = 0; 17501 17502 #if defined(LIBXML_SCHEMAS_ENABLED) 17503 int mem_base; 17504 int ret_val; 17505 17506 mem_base = xmlMemBlocks(); 17507 17508 ret_val = xmlRelaxNGInitTypes(); 17509 desret_int(ret_val); 17510 call_tests++; 17511 xmlResetLastError(); 17512 if (mem_base != xmlMemBlocks()) { 17513 printf("Leak of %d blocks found in xmlRelaxNGInitTypes", 17514 xmlMemBlocks() - mem_base); 17515 test_ret++; 17516 printf("\n"); 17517 } 17518 function_tests++; 17519 #endif 17520 17521 return(test_ret); 17522 } 17523 17524 17525 static int 17526 test_xmlRelaxNGNewDocParserCtxt(void) { 17527 int test_ret = 0; 17528 17529 #if defined(LIBXML_SCHEMAS_ENABLED) 17530 int mem_base; 17531 xmlRelaxNGParserCtxtPtr ret_val; 17532 xmlDocPtr doc; /* a preparsed document tree */ 17533 int n_doc; 17534 17535 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 17536 mem_base = xmlMemBlocks(); 17537 doc = gen_xmlDocPtr(n_doc, 0); 17538 17539 ret_val = xmlRelaxNGNewDocParserCtxt(doc); 17540 desret_xmlRelaxNGParserCtxtPtr(ret_val); 17541 call_tests++; 17542 des_xmlDocPtr(n_doc, doc, 0); 17543 xmlResetLastError(); 17544 if (mem_base != xmlMemBlocks()) { 17545 printf("Leak of %d blocks found in xmlRelaxNGNewDocParserCtxt", 17546 xmlMemBlocks() - mem_base); 17547 test_ret++; 17548 printf(" %d", n_doc); 17549 printf("\n"); 17550 } 17551 } 17552 function_tests++; 17553 #endif 17554 17555 return(test_ret); 17556 } 17557 17558 17559 static int 17560 test_xmlRelaxNGNewMemParserCtxt(void) { 17561 int test_ret = 0; 17562 17563 #if defined(LIBXML_SCHEMAS_ENABLED) 17564 int mem_base; 17565 xmlRelaxNGParserCtxtPtr ret_val; 17566 char * buffer; /* a pointer to a char array containing the schemas */ 17567 int n_buffer; 17568 int size; /* the size of the array */ 17569 int n_size; 17570 17571 for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) { 17572 for (n_size = 0;n_size < gen_nb_int;n_size++) { 17573 mem_base = xmlMemBlocks(); 17574 buffer = gen_const_char_ptr(n_buffer, 0); 17575 size = gen_int(n_size, 1); 17576 17577 ret_val = xmlRelaxNGNewMemParserCtxt((const char *)buffer, size); 17578 desret_xmlRelaxNGParserCtxtPtr(ret_val); 17579 call_tests++; 17580 des_const_char_ptr(n_buffer, (const char *)buffer, 0); 17581 des_int(n_size, size, 1); 17582 xmlResetLastError(); 17583 if (mem_base != xmlMemBlocks()) { 17584 printf("Leak of %d blocks found in xmlRelaxNGNewMemParserCtxt", 17585 xmlMemBlocks() - mem_base); 17586 test_ret++; 17587 printf(" %d", n_buffer); 17588 printf(" %d", n_size); 17589 printf("\n"); 17590 } 17591 } 17592 } 17593 function_tests++; 17594 #endif 17595 17596 return(test_ret); 17597 } 17598 17599 17600 static int 17601 test_xmlRelaxNGNewParserCtxt(void) { 17602 int test_ret = 0; 17603 17604 #if defined(LIBXML_SCHEMAS_ENABLED) 17605 int mem_base; 17606 xmlRelaxNGParserCtxtPtr ret_val; 17607 char * URL; /* the location of the schema */ 17608 int n_URL; 17609 17610 for (n_URL = 0;n_URL < gen_nb_const_char_ptr;n_URL++) { 17611 mem_base = xmlMemBlocks(); 17612 URL = gen_const_char_ptr(n_URL, 0); 17613 17614 ret_val = xmlRelaxNGNewParserCtxt((const char *)URL); 17615 desret_xmlRelaxNGParserCtxtPtr(ret_val); 17616 call_tests++; 17617 des_const_char_ptr(n_URL, (const char *)URL, 0); 17618 xmlResetLastError(); 17619 if (mem_base != xmlMemBlocks()) { 17620 printf("Leak of %d blocks found in xmlRelaxNGNewParserCtxt", 17621 xmlMemBlocks() - mem_base); 17622 test_ret++; 17623 printf(" %d", n_URL); 17624 printf("\n"); 17625 } 17626 } 17627 function_tests++; 17628 #endif 17629 17630 return(test_ret); 17631 } 17632 17633 17634 static int 17635 test_xmlRelaxNGNewValidCtxt(void) { 17636 int test_ret = 0; 17637 17638 17639 /* missing type support */ 17640 return(test_ret); 17641 } 17642 17643 17644 static int 17645 test_xmlRelaxNGParse(void) { 17646 int test_ret = 0; 17647 17648 17649 /* missing type support */ 17650 return(test_ret); 17651 } 17652 17653 17654 static int 17655 test_xmlRelaxNGSetParserErrors(void) { 17656 int test_ret = 0; 17657 17658 17659 /* missing type support */ 17660 return(test_ret); 17661 } 17662 17663 17664 static int 17665 test_xmlRelaxNGSetParserStructuredErrors(void) { 17666 int test_ret = 0; 17667 17668 17669 /* missing type support */ 17670 return(test_ret); 17671 } 17672 17673 17674 static int 17675 test_xmlRelaxNGSetValidErrors(void) { 17676 int test_ret = 0; 17677 17678 17679 /* missing type support */ 17680 return(test_ret); 17681 } 17682 17683 17684 static int 17685 test_xmlRelaxNGSetValidStructuredErrors(void) { 17686 int test_ret = 0; 17687 17688 17689 /* missing type support */ 17690 return(test_ret); 17691 } 17692 17693 17694 static int 17695 test_xmlRelaxNGValidateDoc(void) { 17696 int test_ret = 0; 17697 17698 #if defined(LIBXML_SCHEMAS_ENABLED) 17699 int mem_base; 17700 int ret_val; 17701 xmlRelaxNGValidCtxtPtr ctxt; /* a Relax-NG validation context */ 17702 int n_ctxt; 17703 xmlDocPtr doc; /* a parsed document tree */ 17704 int n_doc; 17705 17706 for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) { 17707 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 17708 mem_base = xmlMemBlocks(); 17709 ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0); 17710 doc = gen_xmlDocPtr(n_doc, 1); 17711 17712 ret_val = xmlRelaxNGValidateDoc(ctxt, doc); 17713 desret_int(ret_val); 17714 call_tests++; 17715 des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0); 17716 des_xmlDocPtr(n_doc, doc, 1); 17717 xmlResetLastError(); 17718 if (mem_base != xmlMemBlocks()) { 17719 printf("Leak of %d blocks found in xmlRelaxNGValidateDoc", 17720 xmlMemBlocks() - mem_base); 17721 test_ret++; 17722 printf(" %d", n_ctxt); 17723 printf(" %d", n_doc); 17724 printf("\n"); 17725 } 17726 } 17727 } 17728 function_tests++; 17729 #endif 17730 17731 return(test_ret); 17732 } 17733 17734 17735 static int 17736 test_xmlRelaxNGValidateFullElement(void) { 17737 int test_ret = 0; 17738 17739 #if defined(LIBXML_SCHEMAS_ENABLED) 17740 int mem_base; 17741 int ret_val; 17742 xmlRelaxNGValidCtxtPtr ctxt; /* the validation context */ 17743 int n_ctxt; 17744 xmlDocPtr doc; /* a document instance */ 17745 int n_doc; 17746 xmlNodePtr elem; /* an element instance */ 17747 int n_elem; 17748 17749 for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) { 17750 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 17751 for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) { 17752 mem_base = xmlMemBlocks(); 17753 ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0); 17754 doc = gen_xmlDocPtr(n_doc, 1); 17755 elem = gen_xmlNodePtr(n_elem, 2); 17756 17757 ret_val = xmlRelaxNGValidateFullElement(ctxt, doc, elem); 17758 desret_int(ret_val); 17759 call_tests++; 17760 des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0); 17761 des_xmlDocPtr(n_doc, doc, 1); 17762 des_xmlNodePtr(n_elem, elem, 2); 17763 xmlResetLastError(); 17764 if (mem_base != xmlMemBlocks()) { 17765 printf("Leak of %d blocks found in xmlRelaxNGValidateFullElement", 17766 xmlMemBlocks() - mem_base); 17767 test_ret++; 17768 printf(" %d", n_ctxt); 17769 printf(" %d", n_doc); 17770 printf(" %d", n_elem); 17771 printf("\n"); 17772 } 17773 } 17774 } 17775 } 17776 function_tests++; 17777 #endif 17778 17779 return(test_ret); 17780 } 17781 17782 17783 static int 17784 test_xmlRelaxNGValidatePopElement(void) { 17785 int test_ret = 0; 17786 17787 #if defined(LIBXML_SCHEMAS_ENABLED) 17788 int mem_base; 17789 int ret_val; 17790 xmlRelaxNGValidCtxtPtr ctxt; /* the RelaxNG validation context */ 17791 int n_ctxt; 17792 xmlDocPtr doc; /* a document instance */ 17793 int n_doc; 17794 xmlNodePtr elem; /* an element instance */ 17795 int n_elem; 17796 17797 for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) { 17798 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 17799 for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) { 17800 mem_base = xmlMemBlocks(); 17801 ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0); 17802 doc = gen_xmlDocPtr(n_doc, 1); 17803 elem = gen_xmlNodePtr(n_elem, 2); 17804 17805 ret_val = xmlRelaxNGValidatePopElement(ctxt, doc, elem); 17806 desret_int(ret_val); 17807 call_tests++; 17808 des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0); 17809 des_xmlDocPtr(n_doc, doc, 1); 17810 des_xmlNodePtr(n_elem, elem, 2); 17811 xmlResetLastError(); 17812 if (mem_base != xmlMemBlocks()) { 17813 printf("Leak of %d blocks found in xmlRelaxNGValidatePopElement", 17814 xmlMemBlocks() - mem_base); 17815 test_ret++; 17816 printf(" %d", n_ctxt); 17817 printf(" %d", n_doc); 17818 printf(" %d", n_elem); 17819 printf("\n"); 17820 } 17821 } 17822 } 17823 } 17824 function_tests++; 17825 #endif 17826 17827 return(test_ret); 17828 } 17829 17830 17831 static int 17832 test_xmlRelaxNGValidatePushCData(void) { 17833 int test_ret = 0; 17834 17835 #if defined(LIBXML_SCHEMAS_ENABLED) 17836 int mem_base; 17837 int ret_val; 17838 xmlRelaxNGValidCtxtPtr ctxt; /* the RelaxNG validation context */ 17839 int n_ctxt; 17840 xmlChar * data; /* some character data read */ 17841 int n_data; 17842 int len; /* the length of the data */ 17843 int n_len; 17844 17845 for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) { 17846 for (n_data = 0;n_data < gen_nb_const_xmlChar_ptr;n_data++) { 17847 for (n_len = 0;n_len < gen_nb_int;n_len++) { 17848 mem_base = xmlMemBlocks(); 17849 ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0); 17850 data = gen_const_xmlChar_ptr(n_data, 1); 17851 len = gen_int(n_len, 2); 17852 17853 ret_val = xmlRelaxNGValidatePushCData(ctxt, (const xmlChar *)data, len); 17854 desret_int(ret_val); 17855 call_tests++; 17856 des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0); 17857 des_const_xmlChar_ptr(n_data, (const xmlChar *)data, 1); 17858 des_int(n_len, len, 2); 17859 xmlResetLastError(); 17860 if (mem_base != xmlMemBlocks()) { 17861 printf("Leak of %d blocks found in xmlRelaxNGValidatePushCData", 17862 xmlMemBlocks() - mem_base); 17863 test_ret++; 17864 printf(" %d", n_ctxt); 17865 printf(" %d", n_data); 17866 printf(" %d", n_len); 17867 printf("\n"); 17868 } 17869 } 17870 } 17871 } 17872 function_tests++; 17873 #endif 17874 17875 return(test_ret); 17876 } 17877 17878 17879 static int 17880 test_xmlRelaxNGValidatePushElement(void) { 17881 int test_ret = 0; 17882 17883 #if defined(LIBXML_SCHEMAS_ENABLED) 17884 int mem_base; 17885 int ret_val; 17886 xmlRelaxNGValidCtxtPtr ctxt; /* the validation context */ 17887 int n_ctxt; 17888 xmlDocPtr doc; /* a document instance */ 17889 int n_doc; 17890 xmlNodePtr elem; /* an element instance */ 17891 int n_elem; 17892 17893 for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) { 17894 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 17895 for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) { 17896 mem_base = xmlMemBlocks(); 17897 ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0); 17898 doc = gen_xmlDocPtr(n_doc, 1); 17899 elem = gen_xmlNodePtr(n_elem, 2); 17900 17901 ret_val = xmlRelaxNGValidatePushElement(ctxt, doc, elem); 17902 desret_int(ret_val); 17903 call_tests++; 17904 des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0); 17905 des_xmlDocPtr(n_doc, doc, 1); 17906 des_xmlNodePtr(n_elem, elem, 2); 17907 xmlResetLastError(); 17908 if (mem_base != xmlMemBlocks()) { 17909 printf("Leak of %d blocks found in xmlRelaxNGValidatePushElement", 17910 xmlMemBlocks() - mem_base); 17911 test_ret++; 17912 printf(" %d", n_ctxt); 17913 printf(" %d", n_doc); 17914 printf(" %d", n_elem); 17915 printf("\n"); 17916 } 17917 } 17918 } 17919 } 17920 function_tests++; 17921 #endif 17922 17923 return(test_ret); 17924 } 17925 17926 17927 static int 17928 test_xmlRelaxParserSetFlag(void) { 17929 int test_ret = 0; 17930 17931 #if defined(LIBXML_SCHEMAS_ENABLED) 17932 int mem_base; 17933 int ret_val; 17934 xmlRelaxNGParserCtxtPtr ctxt; /* a RelaxNG parser context */ 17935 int n_ctxt; 17936 int flags; /* a set of flags values */ 17937 int n_flags; 17938 17939 for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGParserCtxtPtr;n_ctxt++) { 17940 for (n_flags = 0;n_flags < gen_nb_int;n_flags++) { 17941 mem_base = xmlMemBlocks(); 17942 ctxt = gen_xmlRelaxNGParserCtxtPtr(n_ctxt, 0); 17943 flags = gen_int(n_flags, 1); 17944 17945 ret_val = xmlRelaxParserSetFlag(ctxt, flags); 17946 desret_int(ret_val); 17947 call_tests++; 17948 des_xmlRelaxNGParserCtxtPtr(n_ctxt, ctxt, 0); 17949 des_int(n_flags, flags, 1); 17950 xmlResetLastError(); 17951 if (mem_base != xmlMemBlocks()) { 17952 printf("Leak of %d blocks found in xmlRelaxParserSetFlag", 17953 xmlMemBlocks() - mem_base); 17954 test_ret++; 17955 printf(" %d", n_ctxt); 17956 printf(" %d", n_flags); 17957 printf("\n"); 17958 } 17959 } 17960 } 17961 function_tests++; 17962 #endif 17963 17964 return(test_ret); 17965 } 17966 17967 static int 17968 test_relaxng(void) { 17969 int test_ret = 0; 17970 17971 if (quiet == 0) printf("Testing relaxng : 14 of 24 functions ...\n"); 17972 test_ret += test_xmlRelaxNGDump(); 17973 test_ret += test_xmlRelaxNGDumpTree(); 17974 test_ret += test_xmlRelaxNGGetParserErrors(); 17975 test_ret += test_xmlRelaxNGGetValidErrors(); 17976 test_ret += test_xmlRelaxNGInitTypes(); 17977 test_ret += test_xmlRelaxNGNewDocParserCtxt(); 17978 test_ret += test_xmlRelaxNGNewMemParserCtxt(); 17979 test_ret += test_xmlRelaxNGNewParserCtxt(); 17980 test_ret += test_xmlRelaxNGNewValidCtxt(); 17981 test_ret += test_xmlRelaxNGParse(); 17982 test_ret += test_xmlRelaxNGSetParserErrors(); 17983 test_ret += test_xmlRelaxNGSetParserStructuredErrors(); 17984 test_ret += test_xmlRelaxNGSetValidErrors(); 17985 test_ret += test_xmlRelaxNGSetValidStructuredErrors(); 17986 test_ret += test_xmlRelaxNGValidateDoc(); 17987 test_ret += test_xmlRelaxNGValidateFullElement(); 17988 test_ret += test_xmlRelaxNGValidatePopElement(); 17989 test_ret += test_xmlRelaxNGValidatePushCData(); 17990 test_ret += test_xmlRelaxNGValidatePushElement(); 17991 test_ret += test_xmlRelaxParserSetFlag(); 17992 17993 if (test_ret != 0) 17994 printf("Module relaxng: %d errors\n", test_ret); 17995 return(test_ret); 17996 } 17997 static int 17998 test_schemasInternals(void) { 17999 int test_ret = 0; 18000 18001 if (quiet == 0) printf("Testing schemasInternals : 0 of 2 functions ...\n"); 18002 18003 if (test_ret != 0) 18004 printf("Module schemasInternals: %d errors\n", test_ret); 18005 return(test_ret); 18006 } 18007 18008 static int 18009 test_xmlSchematronNewDocParserCtxt(void) { 18010 int test_ret = 0; 18011 18012 18013 /* missing type support */ 18014 return(test_ret); 18015 } 18016 18017 18018 static int 18019 test_xmlSchematronNewMemParserCtxt(void) { 18020 int test_ret = 0; 18021 18022 18023 /* missing type support */ 18024 return(test_ret); 18025 } 18026 18027 18028 static int 18029 test_xmlSchematronNewParserCtxt(void) { 18030 int test_ret = 0; 18031 18032 18033 /* missing type support */ 18034 return(test_ret); 18035 } 18036 18037 #ifdef LIBXML_SCHEMATRON_ENABLED 18038 18039 #define gen_nb_xmlSchematronPtr 1 18040 static xmlSchematronPtr gen_xmlSchematronPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 18041 return(NULL); 18042 } 18043 static void des_xmlSchematronPtr(int no ATTRIBUTE_UNUSED, xmlSchematronPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 18044 } 18045 #endif 18046 18047 18048 static int 18049 test_xmlSchematronNewValidCtxt(void) { 18050 int test_ret = 0; 18051 18052 18053 /* missing type support */ 18054 return(test_ret); 18055 } 18056 18057 #ifdef LIBXML_SCHEMATRON_ENABLED 18058 18059 #define gen_nb_xmlSchematronParserCtxtPtr 1 18060 static xmlSchematronParserCtxtPtr gen_xmlSchematronParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 18061 return(NULL); 18062 } 18063 static void des_xmlSchematronParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchematronParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 18064 } 18065 #endif 18066 18067 18068 static int 18069 test_xmlSchematronParse(void) { 18070 int test_ret = 0; 18071 18072 18073 /* missing type support */ 18074 return(test_ret); 18075 } 18076 18077 #ifdef LIBXML_SCHEMATRON_ENABLED 18078 18079 #define gen_nb_xmlSchematronValidCtxtPtr 1 18080 static xmlSchematronValidCtxtPtr gen_xmlSchematronValidCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 18081 return(NULL); 18082 } 18083 static void des_xmlSchematronValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchematronValidCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 18084 } 18085 #endif 18086 18087 18088 static int 18089 test_xmlSchematronSetValidStructuredErrors(void) { 18090 int test_ret = 0; 18091 18092 18093 /* missing type support */ 18094 return(test_ret); 18095 } 18096 18097 18098 static int 18099 test_xmlSchematronValidateDoc(void) { 18100 int test_ret = 0; 18101 18102 #if defined(LIBXML_SCHEMATRON_ENABLED) 18103 int mem_base; 18104 int ret_val; 18105 xmlSchematronValidCtxtPtr ctxt; /* the schema validation context */ 18106 int n_ctxt; 18107 xmlDocPtr instance; /* the document instace tree */ 18108 int n_instance; 18109 18110 for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchematronValidCtxtPtr;n_ctxt++) { 18111 for (n_instance = 0;n_instance < gen_nb_xmlDocPtr;n_instance++) { 18112 mem_base = xmlMemBlocks(); 18113 ctxt = gen_xmlSchematronValidCtxtPtr(n_ctxt, 0); 18114 instance = gen_xmlDocPtr(n_instance, 1); 18115 18116 ret_val = xmlSchematronValidateDoc(ctxt, instance); 18117 desret_int(ret_val); 18118 call_tests++; 18119 des_xmlSchematronValidCtxtPtr(n_ctxt, ctxt, 0); 18120 des_xmlDocPtr(n_instance, instance, 1); 18121 xmlResetLastError(); 18122 if (mem_base != xmlMemBlocks()) { 18123 printf("Leak of %d blocks found in xmlSchematronValidateDoc", 18124 xmlMemBlocks() - mem_base); 18125 test_ret++; 18126 printf(" %d", n_ctxt); 18127 printf(" %d", n_instance); 18128 printf("\n"); 18129 } 18130 } 18131 } 18132 function_tests++; 18133 #endif 18134 18135 return(test_ret); 18136 } 18137 18138 static int 18139 test_schematron(void) { 18140 int test_ret = 0; 18141 18142 if (quiet == 0) printf("Testing schematron : 1 of 10 functions ...\n"); 18143 test_ret += test_xmlSchematronNewDocParserCtxt(); 18144 test_ret += test_xmlSchematronNewMemParserCtxt(); 18145 test_ret += test_xmlSchematronNewParserCtxt(); 18146 test_ret += test_xmlSchematronNewValidCtxt(); 18147 test_ret += test_xmlSchematronParse(); 18148 test_ret += test_xmlSchematronSetValidStructuredErrors(); 18149 test_ret += test_xmlSchematronValidateDoc(); 18150 18151 if (test_ret != 0) 18152 printf("Module schematron: %d errors\n", test_ret); 18153 return(test_ret); 18154 } 18155 18156 static int 18157 test_xmlAddChild(void) { 18158 int test_ret = 0; 18159 18160 int mem_base; 18161 xmlNodePtr ret_val; 18162 xmlNodePtr parent; /* the parent node */ 18163 int n_parent; 18164 xmlNodePtr cur; /* the child node */ 18165 int n_cur; 18166 18167 for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) { 18168 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) { 18169 mem_base = xmlMemBlocks(); 18170 parent = gen_xmlNodePtr(n_parent, 0); 18171 cur = gen_xmlNodePtr_in(n_cur, 1); 18172 18173 ret_val = xmlAddChild(parent, cur); 18174 if (ret_val == NULL) { xmlFreeNode(cur) ; cur = NULL ; } 18175 desret_xmlNodePtr(ret_val); 18176 call_tests++; 18177 des_xmlNodePtr(n_parent, parent, 0); 18178 des_xmlNodePtr_in(n_cur, cur, 1); 18179 xmlResetLastError(); 18180 if (mem_base != xmlMemBlocks()) { 18181 printf("Leak of %d blocks found in xmlAddChild", 18182 xmlMemBlocks() - mem_base); 18183 test_ret++; 18184 printf(" %d", n_parent); 18185 printf(" %d", n_cur); 18186 printf("\n"); 18187 } 18188 } 18189 } 18190 function_tests++; 18191 18192 return(test_ret); 18193 } 18194 18195 18196 static int 18197 test_xmlAddChildList(void) { 18198 int test_ret = 0; 18199 18200 int mem_base; 18201 xmlNodePtr ret_val; 18202 xmlNodePtr parent; /* the parent node */ 18203 int n_parent; 18204 xmlNodePtr cur; /* the first node in the list */ 18205 int n_cur; 18206 18207 for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) { 18208 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) { 18209 mem_base = xmlMemBlocks(); 18210 parent = gen_xmlNodePtr(n_parent, 0); 18211 cur = gen_xmlNodePtr_in(n_cur, 1); 18212 18213 ret_val = xmlAddChildList(parent, cur); 18214 if (ret_val == NULL) { xmlFreeNodeList(cur) ; cur = NULL ; } 18215 desret_xmlNodePtr(ret_val); 18216 call_tests++; 18217 des_xmlNodePtr(n_parent, parent, 0); 18218 des_xmlNodePtr_in(n_cur, cur, 1); 18219 xmlResetLastError(); 18220 if (mem_base != xmlMemBlocks()) { 18221 printf("Leak of %d blocks found in xmlAddChildList", 18222 xmlMemBlocks() - mem_base); 18223 test_ret++; 18224 printf(" %d", n_parent); 18225 printf(" %d", n_cur); 18226 printf("\n"); 18227 } 18228 } 18229 } 18230 function_tests++; 18231 18232 return(test_ret); 18233 } 18234 18235 18236 static int 18237 test_xmlAddNextSibling(void) { 18238 int test_ret = 0; 18239 18240 int mem_base; 18241 xmlNodePtr ret_val; 18242 xmlNodePtr cur; /* the child node */ 18243 int n_cur; 18244 xmlNodePtr elem; /* the new node */ 18245 int n_elem; 18246 18247 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 18248 for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) { 18249 mem_base = xmlMemBlocks(); 18250 cur = gen_xmlNodePtr(n_cur, 0); 18251 elem = gen_xmlNodePtr_in(n_elem, 1); 18252 18253 ret_val = xmlAddNextSibling(cur, elem); 18254 if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; } 18255 desret_xmlNodePtr(ret_val); 18256 call_tests++; 18257 des_xmlNodePtr(n_cur, cur, 0); 18258 des_xmlNodePtr_in(n_elem, elem, 1); 18259 xmlResetLastError(); 18260 if (mem_base != xmlMemBlocks()) { 18261 printf("Leak of %d blocks found in xmlAddNextSibling", 18262 xmlMemBlocks() - mem_base); 18263 test_ret++; 18264 printf(" %d", n_cur); 18265 printf(" %d", n_elem); 18266 printf("\n"); 18267 } 18268 } 18269 } 18270 function_tests++; 18271 18272 return(test_ret); 18273 } 18274 18275 18276 static int 18277 test_xmlAddPrevSibling(void) { 18278 int test_ret = 0; 18279 18280 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) 18281 int mem_base; 18282 xmlNodePtr ret_val; 18283 xmlNodePtr cur; /* the child node */ 18284 int n_cur; 18285 xmlNodePtr elem; /* the new node */ 18286 int n_elem; 18287 18288 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 18289 for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) { 18290 mem_base = xmlMemBlocks(); 18291 cur = gen_xmlNodePtr(n_cur, 0); 18292 elem = gen_xmlNodePtr_in(n_elem, 1); 18293 18294 ret_val = xmlAddPrevSibling(cur, elem); 18295 if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; } 18296 desret_xmlNodePtr(ret_val); 18297 call_tests++; 18298 des_xmlNodePtr(n_cur, cur, 0); 18299 des_xmlNodePtr_in(n_elem, elem, 1); 18300 xmlResetLastError(); 18301 if (mem_base != xmlMemBlocks()) { 18302 printf("Leak of %d blocks found in xmlAddPrevSibling", 18303 xmlMemBlocks() - mem_base); 18304 test_ret++; 18305 printf(" %d", n_cur); 18306 printf(" %d", n_elem); 18307 printf("\n"); 18308 } 18309 } 18310 } 18311 function_tests++; 18312 #endif 18313 18314 return(test_ret); 18315 } 18316 18317 18318 static int 18319 test_xmlAddSibling(void) { 18320 int test_ret = 0; 18321 18322 int mem_base; 18323 xmlNodePtr ret_val; 18324 xmlNodePtr cur; /* the child node */ 18325 int n_cur; 18326 xmlNodePtr elem; /* the new node */ 18327 int n_elem; 18328 18329 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 18330 for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) { 18331 mem_base = xmlMemBlocks(); 18332 cur = gen_xmlNodePtr(n_cur, 0); 18333 elem = gen_xmlNodePtr_in(n_elem, 1); 18334 18335 ret_val = xmlAddSibling(cur, elem); 18336 if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; } 18337 desret_xmlNodePtr(ret_val); 18338 call_tests++; 18339 des_xmlNodePtr(n_cur, cur, 0); 18340 des_xmlNodePtr_in(n_elem, elem, 1); 18341 xmlResetLastError(); 18342 if (mem_base != xmlMemBlocks()) { 18343 printf("Leak of %d blocks found in xmlAddSibling", 18344 xmlMemBlocks() - mem_base); 18345 test_ret++; 18346 printf(" %d", n_cur); 18347 printf(" %d", n_elem); 18348 printf("\n"); 18349 } 18350 } 18351 } 18352 function_tests++; 18353 18354 return(test_ret); 18355 } 18356 18357 18358 static int 18359 test_xmlAttrSerializeTxtContent(void) { 18360 int test_ret = 0; 18361 18362 #if defined(LIBXML_OUTPUT_ENABLED) 18363 #ifdef LIBXML_OUTPUT_ENABLED 18364 int mem_base; 18365 xmlBufferPtr buf; /* the XML buffer output */ 18366 int n_buf; 18367 xmlDocPtr doc; /* the document */ 18368 int n_doc; 18369 xmlAttrPtr attr; /* the attribute node */ 18370 int n_attr; 18371 xmlChar * string; /* the text content */ 18372 int n_string; 18373 18374 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 18375 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 18376 for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) { 18377 for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) { 18378 mem_base = xmlMemBlocks(); 18379 buf = gen_xmlBufferPtr(n_buf, 0); 18380 doc = gen_xmlDocPtr(n_doc, 1); 18381 attr = gen_xmlAttrPtr(n_attr, 2); 18382 string = gen_const_xmlChar_ptr(n_string, 3); 18383 18384 xmlAttrSerializeTxtContent(buf, doc, attr, (const xmlChar *)string); 18385 call_tests++; 18386 des_xmlBufferPtr(n_buf, buf, 0); 18387 des_xmlDocPtr(n_doc, doc, 1); 18388 des_xmlAttrPtr(n_attr, attr, 2); 18389 des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 3); 18390 xmlResetLastError(); 18391 if (mem_base != xmlMemBlocks()) { 18392 printf("Leak of %d blocks found in xmlAttrSerializeTxtContent", 18393 xmlMemBlocks() - mem_base); 18394 test_ret++; 18395 printf(" %d", n_buf); 18396 printf(" %d", n_doc); 18397 printf(" %d", n_attr); 18398 printf(" %d", n_string); 18399 printf("\n"); 18400 } 18401 } 18402 } 18403 } 18404 } 18405 function_tests++; 18406 #endif 18407 #endif 18408 18409 return(test_ret); 18410 } 18411 18412 18413 #define gen_nb_const_xmlBuf_ptr 1 18414 static xmlBuf * gen_const_xmlBuf_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 18415 return(NULL); 18416 } 18417 static void des_const_xmlBuf_ptr(int no ATTRIBUTE_UNUSED, const xmlBuf * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 18418 } 18419 18420 static int 18421 test_xmlBufContent(void) { 18422 int test_ret = 0; 18423 18424 int mem_base; 18425 xmlChar * ret_val; 18426 xmlBuf * buf; /* the buffer */ 18427 int n_buf; 18428 18429 for (n_buf = 0;n_buf < gen_nb_const_xmlBuf_ptr;n_buf++) { 18430 mem_base = xmlMemBlocks(); 18431 buf = gen_const_xmlBuf_ptr(n_buf, 0); 18432 18433 ret_val = xmlBufContent((const xmlBuf *)buf); 18434 desret_xmlChar_ptr(ret_val); 18435 call_tests++; 18436 des_const_xmlBuf_ptr(n_buf, (const xmlBuf *)buf, 0); 18437 xmlResetLastError(); 18438 if (mem_base != xmlMemBlocks()) { 18439 printf("Leak of %d blocks found in xmlBufContent", 18440 xmlMemBlocks() - mem_base); 18441 test_ret++; 18442 printf(" %d", n_buf); 18443 printf("\n"); 18444 } 18445 } 18446 function_tests++; 18447 18448 return(test_ret); 18449 } 18450 18451 18452 #define gen_nb_xmlBufPtr 1 18453 static xmlBufPtr gen_xmlBufPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 18454 return(NULL); 18455 } 18456 static void des_xmlBufPtr(int no ATTRIBUTE_UNUSED, xmlBufPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 18457 } 18458 18459 static int 18460 test_xmlBufEnd(void) { 18461 int test_ret = 0; 18462 18463 int mem_base; 18464 xmlChar * ret_val; 18465 xmlBufPtr buf; /* the buffer */ 18466 int n_buf; 18467 18468 for (n_buf = 0;n_buf < gen_nb_xmlBufPtr;n_buf++) { 18469 mem_base = xmlMemBlocks(); 18470 buf = gen_xmlBufPtr(n_buf, 0); 18471 18472 ret_val = xmlBufEnd(buf); 18473 desret_xmlChar_ptr(ret_val); 18474 call_tests++; 18475 des_xmlBufPtr(n_buf, buf, 0); 18476 xmlResetLastError(); 18477 if (mem_base != xmlMemBlocks()) { 18478 printf("Leak of %d blocks found in xmlBufEnd", 18479 xmlMemBlocks() - mem_base); 18480 test_ret++; 18481 printf(" %d", n_buf); 18482 printf("\n"); 18483 } 18484 } 18485 function_tests++; 18486 18487 return(test_ret); 18488 } 18489 18490 18491 #define gen_nb_const_xmlNode_ptr 1 18492 static xmlNode * gen_const_xmlNode_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 18493 return(NULL); 18494 } 18495 static void des_const_xmlNode_ptr(int no ATTRIBUTE_UNUSED, const xmlNode * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 18496 } 18497 18498 static int 18499 test_xmlBufGetNodeContent(void) { 18500 int test_ret = 0; 18501 18502 int mem_base; 18503 int ret_val; 18504 xmlBufPtr buf; /* a buffer xmlBufPtr */ 18505 int n_buf; 18506 xmlNode * cur; /* the node being read */ 18507 int n_cur; 18508 18509 for (n_buf = 0;n_buf < gen_nb_xmlBufPtr;n_buf++) { 18510 for (n_cur = 0;n_cur < gen_nb_const_xmlNode_ptr;n_cur++) { 18511 mem_base = xmlMemBlocks(); 18512 buf = gen_xmlBufPtr(n_buf, 0); 18513 cur = gen_const_xmlNode_ptr(n_cur, 1); 18514 18515 ret_val = xmlBufGetNodeContent(buf, (const xmlNode *)cur); 18516 desret_int(ret_val); 18517 call_tests++; 18518 des_xmlBufPtr(n_buf, buf, 0); 18519 des_const_xmlNode_ptr(n_cur, (const xmlNode *)cur, 1); 18520 xmlResetLastError(); 18521 if (mem_base != xmlMemBlocks()) { 18522 printf("Leak of %d blocks found in xmlBufGetNodeContent", 18523 xmlMemBlocks() - mem_base); 18524 test_ret++; 18525 printf(" %d", n_buf); 18526 printf(" %d", n_cur); 18527 printf("\n"); 18528 } 18529 } 18530 } 18531 function_tests++; 18532 18533 return(test_ret); 18534 } 18535 18536 18537 static int 18538 test_xmlBufNodeDump(void) { 18539 int test_ret = 0; 18540 18541 18542 /* missing type support */ 18543 return(test_ret); 18544 } 18545 18546 18547 static int 18548 test_xmlBufShrink(void) { 18549 int test_ret = 0; 18550 18551 18552 /* missing type support */ 18553 return(test_ret); 18554 } 18555 18556 18557 #define gen_nb_const_xmlBufPtr 1 18558 static xmlBufPtr gen_const_xmlBufPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 18559 return(NULL); 18560 } 18561 static void des_const_xmlBufPtr(int no ATTRIBUTE_UNUSED, const xmlBufPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 18562 } 18563 18564 static int 18565 test_xmlBufUse(void) { 18566 int test_ret = 0; 18567 18568 18569 /* missing type support */ 18570 return(test_ret); 18571 } 18572 18573 18574 static int 18575 test_xmlBufferAdd(void) { 18576 int test_ret = 0; 18577 18578 int mem_base; 18579 int ret_val; 18580 xmlBufferPtr buf; /* the buffer to dump */ 18581 int n_buf; 18582 xmlChar * str; /* the #xmlChar string */ 18583 int n_str; 18584 int len; /* the number of #xmlChar to add */ 18585 int n_len; 18586 18587 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 18588 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 18589 for (n_len = 0;n_len < gen_nb_int;n_len++) { 18590 mem_base = xmlMemBlocks(); 18591 buf = gen_xmlBufferPtr(n_buf, 0); 18592 str = gen_const_xmlChar_ptr(n_str, 1); 18593 len = gen_int(n_len, 2); 18594 18595 ret_val = xmlBufferAdd(buf, (const xmlChar *)str, len); 18596 desret_int(ret_val); 18597 call_tests++; 18598 des_xmlBufferPtr(n_buf, buf, 0); 18599 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1); 18600 des_int(n_len, len, 2); 18601 xmlResetLastError(); 18602 if (mem_base != xmlMemBlocks()) { 18603 printf("Leak of %d blocks found in xmlBufferAdd", 18604 xmlMemBlocks() - mem_base); 18605 test_ret++; 18606 printf(" %d", n_buf); 18607 printf(" %d", n_str); 18608 printf(" %d", n_len); 18609 printf("\n"); 18610 } 18611 } 18612 } 18613 } 18614 function_tests++; 18615 18616 return(test_ret); 18617 } 18618 18619 18620 static int 18621 test_xmlBufferAddHead(void) { 18622 int test_ret = 0; 18623 18624 int mem_base; 18625 int ret_val; 18626 xmlBufferPtr buf; /* the buffer */ 18627 int n_buf; 18628 xmlChar * str; /* the #xmlChar string */ 18629 int n_str; 18630 int len; /* the number of #xmlChar to add */ 18631 int n_len; 18632 18633 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 18634 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 18635 for (n_len = 0;n_len < gen_nb_int;n_len++) { 18636 mem_base = xmlMemBlocks(); 18637 buf = gen_xmlBufferPtr(n_buf, 0); 18638 str = gen_const_xmlChar_ptr(n_str, 1); 18639 len = gen_int(n_len, 2); 18640 18641 ret_val = xmlBufferAddHead(buf, (const xmlChar *)str, len); 18642 desret_int(ret_val); 18643 call_tests++; 18644 des_xmlBufferPtr(n_buf, buf, 0); 18645 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1); 18646 des_int(n_len, len, 2); 18647 xmlResetLastError(); 18648 if (mem_base != xmlMemBlocks()) { 18649 printf("Leak of %d blocks found in xmlBufferAddHead", 18650 xmlMemBlocks() - mem_base); 18651 test_ret++; 18652 printf(" %d", n_buf); 18653 printf(" %d", n_str); 18654 printf(" %d", n_len); 18655 printf("\n"); 18656 } 18657 } 18658 } 18659 } 18660 function_tests++; 18661 18662 return(test_ret); 18663 } 18664 18665 18666 static int 18667 test_xmlBufferCCat(void) { 18668 int test_ret = 0; 18669 18670 int mem_base; 18671 int ret_val; 18672 xmlBufferPtr buf; /* the buffer to dump */ 18673 int n_buf; 18674 char * str; /* the C char string */ 18675 int n_str; 18676 18677 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 18678 for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) { 18679 mem_base = xmlMemBlocks(); 18680 buf = gen_xmlBufferPtr(n_buf, 0); 18681 str = gen_const_char_ptr(n_str, 1); 18682 18683 ret_val = xmlBufferCCat(buf, (const char *)str); 18684 desret_int(ret_val); 18685 call_tests++; 18686 des_xmlBufferPtr(n_buf, buf, 0); 18687 des_const_char_ptr(n_str, (const char *)str, 1); 18688 xmlResetLastError(); 18689 if (mem_base != xmlMemBlocks()) { 18690 printf("Leak of %d blocks found in xmlBufferCCat", 18691 xmlMemBlocks() - mem_base); 18692 test_ret++; 18693 printf(" %d", n_buf); 18694 printf(" %d", n_str); 18695 printf("\n"); 18696 } 18697 } 18698 } 18699 function_tests++; 18700 18701 return(test_ret); 18702 } 18703 18704 18705 static int 18706 test_xmlBufferCat(void) { 18707 int test_ret = 0; 18708 18709 int mem_base; 18710 int ret_val; 18711 xmlBufferPtr buf; /* the buffer to add to */ 18712 int n_buf; 18713 xmlChar * str; /* the #xmlChar string */ 18714 int n_str; 18715 18716 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 18717 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 18718 mem_base = xmlMemBlocks(); 18719 buf = gen_xmlBufferPtr(n_buf, 0); 18720 str = gen_const_xmlChar_ptr(n_str, 1); 18721 18722 ret_val = xmlBufferCat(buf, (const xmlChar *)str); 18723 desret_int(ret_val); 18724 call_tests++; 18725 des_xmlBufferPtr(n_buf, buf, 0); 18726 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1); 18727 xmlResetLastError(); 18728 if (mem_base != xmlMemBlocks()) { 18729 printf("Leak of %d blocks found in xmlBufferCat", 18730 xmlMemBlocks() - mem_base); 18731 test_ret++; 18732 printf(" %d", n_buf); 18733 printf(" %d", n_str); 18734 printf("\n"); 18735 } 18736 } 18737 } 18738 function_tests++; 18739 18740 return(test_ret); 18741 } 18742 18743 18744 #define gen_nb_const_xmlBuffer_ptr 1 18745 static xmlBuffer * gen_const_xmlBuffer_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 18746 return(NULL); 18747 } 18748 static void des_const_xmlBuffer_ptr(int no ATTRIBUTE_UNUSED, const xmlBuffer * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 18749 } 18750 18751 static int 18752 test_xmlBufferContent(void) { 18753 int test_ret = 0; 18754 18755 int mem_base; 18756 const xmlChar * ret_val; 18757 xmlBuffer * buf; /* the buffer */ 18758 int n_buf; 18759 18760 for (n_buf = 0;n_buf < gen_nb_const_xmlBuffer_ptr;n_buf++) { 18761 mem_base = xmlMemBlocks(); 18762 buf = gen_const_xmlBuffer_ptr(n_buf, 0); 18763 18764 ret_val = xmlBufferContent((const xmlBuffer *)buf); 18765 desret_const_xmlChar_ptr(ret_val); 18766 call_tests++; 18767 des_const_xmlBuffer_ptr(n_buf, (const xmlBuffer *)buf, 0); 18768 xmlResetLastError(); 18769 if (mem_base != xmlMemBlocks()) { 18770 printf("Leak of %d blocks found in xmlBufferContent", 18771 xmlMemBlocks() - mem_base); 18772 test_ret++; 18773 printf(" %d", n_buf); 18774 printf("\n"); 18775 } 18776 } 18777 function_tests++; 18778 18779 return(test_ret); 18780 } 18781 18782 18783 static int 18784 test_xmlBufferCreate(void) { 18785 int test_ret = 0; 18786 18787 int mem_base; 18788 xmlBufferPtr ret_val; 18789 18790 mem_base = xmlMemBlocks(); 18791 18792 ret_val = xmlBufferCreate(); 18793 desret_xmlBufferPtr(ret_val); 18794 call_tests++; 18795 xmlResetLastError(); 18796 if (mem_base != xmlMemBlocks()) { 18797 printf("Leak of %d blocks found in xmlBufferCreate", 18798 xmlMemBlocks() - mem_base); 18799 test_ret++; 18800 printf("\n"); 18801 } 18802 function_tests++; 18803 18804 return(test_ret); 18805 } 18806 18807 18808 static int 18809 test_xmlBufferCreateSize(void) { 18810 int test_ret = 0; 18811 18812 18813 /* missing type support */ 18814 return(test_ret); 18815 } 18816 18817 18818 static int 18819 test_xmlBufferCreateStatic(void) { 18820 int test_ret = 0; 18821 18822 18823 /* missing type support */ 18824 return(test_ret); 18825 } 18826 18827 18828 static int 18829 test_xmlBufferDetach(void) { 18830 int test_ret = 0; 18831 18832 int mem_base; 18833 xmlChar * ret_val; 18834 xmlBufferPtr buf; /* the buffer */ 18835 int n_buf; 18836 18837 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 18838 mem_base = xmlMemBlocks(); 18839 buf = gen_xmlBufferPtr(n_buf, 0); 18840 18841 ret_val = xmlBufferDetach(buf); 18842 desret_xmlChar_ptr(ret_val); 18843 call_tests++; 18844 des_xmlBufferPtr(n_buf, buf, 0); 18845 xmlResetLastError(); 18846 if (mem_base != xmlMemBlocks()) { 18847 printf("Leak of %d blocks found in xmlBufferDetach", 18848 xmlMemBlocks() - mem_base); 18849 test_ret++; 18850 printf(" %d", n_buf); 18851 printf("\n"); 18852 } 18853 } 18854 function_tests++; 18855 18856 return(test_ret); 18857 } 18858 18859 18860 static int 18861 test_xmlBufferEmpty(void) { 18862 int test_ret = 0; 18863 18864 int mem_base; 18865 xmlBufferPtr buf; /* the buffer */ 18866 int n_buf; 18867 18868 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 18869 mem_base = xmlMemBlocks(); 18870 buf = gen_xmlBufferPtr(n_buf, 0); 18871 18872 xmlBufferEmpty(buf); 18873 call_tests++; 18874 des_xmlBufferPtr(n_buf, buf, 0); 18875 xmlResetLastError(); 18876 if (mem_base != xmlMemBlocks()) { 18877 printf("Leak of %d blocks found in xmlBufferEmpty", 18878 xmlMemBlocks() - mem_base); 18879 test_ret++; 18880 printf(" %d", n_buf); 18881 printf("\n"); 18882 } 18883 } 18884 function_tests++; 18885 18886 return(test_ret); 18887 } 18888 18889 18890 static int 18891 test_xmlBufferGrow(void) { 18892 int test_ret = 0; 18893 18894 int mem_base; 18895 int ret_val; 18896 xmlBufferPtr buf; /* the buffer */ 18897 int n_buf; 18898 unsigned int len; /* the minimum free size to allocate */ 18899 int n_len; 18900 18901 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 18902 for (n_len = 0;n_len < gen_nb_unsigned_int;n_len++) { 18903 mem_base = xmlMemBlocks(); 18904 buf = gen_xmlBufferPtr(n_buf, 0); 18905 len = gen_unsigned_int(n_len, 1); 18906 18907 ret_val = xmlBufferGrow(buf, len); 18908 desret_int(ret_val); 18909 call_tests++; 18910 des_xmlBufferPtr(n_buf, buf, 0); 18911 des_unsigned_int(n_len, len, 1); 18912 xmlResetLastError(); 18913 if (mem_base != xmlMemBlocks()) { 18914 printf("Leak of %d blocks found in xmlBufferGrow", 18915 xmlMemBlocks() - mem_base); 18916 test_ret++; 18917 printf(" %d", n_buf); 18918 printf(" %d", n_len); 18919 printf("\n"); 18920 } 18921 } 18922 } 18923 function_tests++; 18924 18925 return(test_ret); 18926 } 18927 18928 18929 static int 18930 test_xmlBufferLength(void) { 18931 int test_ret = 0; 18932 18933 int mem_base; 18934 int ret_val; 18935 xmlBuffer * buf; /* the buffer */ 18936 int n_buf; 18937 18938 for (n_buf = 0;n_buf < gen_nb_const_xmlBuffer_ptr;n_buf++) { 18939 mem_base = xmlMemBlocks(); 18940 buf = gen_const_xmlBuffer_ptr(n_buf, 0); 18941 18942 ret_val = xmlBufferLength((const xmlBuffer *)buf); 18943 desret_int(ret_val); 18944 call_tests++; 18945 des_const_xmlBuffer_ptr(n_buf, (const xmlBuffer *)buf, 0); 18946 xmlResetLastError(); 18947 if (mem_base != xmlMemBlocks()) { 18948 printf("Leak of %d blocks found in xmlBufferLength", 18949 xmlMemBlocks() - mem_base); 18950 test_ret++; 18951 printf(" %d", n_buf); 18952 printf("\n"); 18953 } 18954 } 18955 function_tests++; 18956 18957 return(test_ret); 18958 } 18959 18960 18961 static int 18962 test_xmlBufferResize(void) { 18963 int test_ret = 0; 18964 18965 int mem_base; 18966 int ret_val; 18967 xmlBufferPtr buf; /* the buffer to resize */ 18968 int n_buf; 18969 unsigned int size; /* the desired size */ 18970 int n_size; 18971 18972 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 18973 for (n_size = 0;n_size < gen_nb_unsigned_int;n_size++) { 18974 mem_base = xmlMemBlocks(); 18975 buf = gen_xmlBufferPtr(n_buf, 0); 18976 size = gen_unsigned_int(n_size, 1); 18977 18978 ret_val = xmlBufferResize(buf, size); 18979 desret_int(ret_val); 18980 call_tests++; 18981 des_xmlBufferPtr(n_buf, buf, 0); 18982 des_unsigned_int(n_size, size, 1); 18983 xmlResetLastError(); 18984 if (mem_base != xmlMemBlocks()) { 18985 printf("Leak of %d blocks found in xmlBufferResize", 18986 xmlMemBlocks() - mem_base); 18987 test_ret++; 18988 printf(" %d", n_buf); 18989 printf(" %d", n_size); 18990 printf("\n"); 18991 } 18992 } 18993 } 18994 function_tests++; 18995 18996 return(test_ret); 18997 } 18998 18999 19000 static int 19001 test_xmlBufferSetAllocationScheme(void) { 19002 int test_ret = 0; 19003 19004 int mem_base; 19005 xmlBufferPtr buf; /* the buffer to tune */ 19006 int n_buf; 19007 xmlBufferAllocationScheme scheme; /* allocation scheme to use */ 19008 int n_scheme; 19009 19010 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 19011 for (n_scheme = 0;n_scheme < gen_nb_xmlBufferAllocationScheme;n_scheme++) { 19012 mem_base = xmlMemBlocks(); 19013 buf = gen_xmlBufferPtr(n_buf, 0); 19014 scheme = gen_xmlBufferAllocationScheme(n_scheme, 1); 19015 19016 xmlBufferSetAllocationScheme(buf, scheme); 19017 if ((buf != NULL) && (scheme == XML_BUFFER_ALLOC_IMMUTABLE) && (buf->content != NULL) && (buf->content != static_buf_content)) { xmlFree(buf->content); buf->content = NULL;} 19018 call_tests++; 19019 des_xmlBufferPtr(n_buf, buf, 0); 19020 des_xmlBufferAllocationScheme(n_scheme, scheme, 1); 19021 xmlResetLastError(); 19022 if (mem_base != xmlMemBlocks()) { 19023 printf("Leak of %d blocks found in xmlBufferSetAllocationScheme", 19024 xmlMemBlocks() - mem_base); 19025 test_ret++; 19026 printf(" %d", n_buf); 19027 printf(" %d", n_scheme); 19028 printf("\n"); 19029 } 19030 } 19031 } 19032 function_tests++; 19033 19034 return(test_ret); 19035 } 19036 19037 19038 static int 19039 test_xmlBufferShrink(void) { 19040 int test_ret = 0; 19041 19042 int mem_base; 19043 int ret_val; 19044 xmlBufferPtr buf; /* the buffer to dump */ 19045 int n_buf; 19046 unsigned int len; /* the number of xmlChar to remove */ 19047 int n_len; 19048 19049 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 19050 for (n_len = 0;n_len < gen_nb_unsigned_int;n_len++) { 19051 mem_base = xmlMemBlocks(); 19052 buf = gen_xmlBufferPtr(n_buf, 0); 19053 len = gen_unsigned_int(n_len, 1); 19054 19055 ret_val = xmlBufferShrink(buf, len); 19056 desret_int(ret_val); 19057 call_tests++; 19058 des_xmlBufferPtr(n_buf, buf, 0); 19059 des_unsigned_int(n_len, len, 1); 19060 xmlResetLastError(); 19061 if (mem_base != xmlMemBlocks()) { 19062 printf("Leak of %d blocks found in xmlBufferShrink", 19063 xmlMemBlocks() - mem_base); 19064 test_ret++; 19065 printf(" %d", n_buf); 19066 printf(" %d", n_len); 19067 printf("\n"); 19068 } 19069 } 19070 } 19071 function_tests++; 19072 19073 return(test_ret); 19074 } 19075 19076 19077 static int 19078 test_xmlBufferWriteCHAR(void) { 19079 int test_ret = 0; 19080 19081 int mem_base; 19082 xmlBufferPtr buf; /* the XML buffer */ 19083 int n_buf; 19084 xmlChar * string; /* the string to add */ 19085 int n_string; 19086 19087 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 19088 for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) { 19089 mem_base = xmlMemBlocks(); 19090 buf = gen_xmlBufferPtr(n_buf, 0); 19091 string = gen_const_xmlChar_ptr(n_string, 1); 19092 19093 xmlBufferWriteCHAR(buf, (const xmlChar *)string); 19094 call_tests++; 19095 des_xmlBufferPtr(n_buf, buf, 0); 19096 des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 1); 19097 xmlResetLastError(); 19098 if (mem_base != xmlMemBlocks()) { 19099 printf("Leak of %d blocks found in xmlBufferWriteCHAR", 19100 xmlMemBlocks() - mem_base); 19101 test_ret++; 19102 printf(" %d", n_buf); 19103 printf(" %d", n_string); 19104 printf("\n"); 19105 } 19106 } 19107 } 19108 function_tests++; 19109 19110 return(test_ret); 19111 } 19112 19113 19114 static int 19115 test_xmlBufferWriteChar(void) { 19116 int test_ret = 0; 19117 19118 int mem_base; 19119 xmlBufferPtr buf; /* the XML buffer output */ 19120 int n_buf; 19121 char * string; /* the string to add */ 19122 int n_string; 19123 19124 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 19125 for (n_string = 0;n_string < gen_nb_const_char_ptr;n_string++) { 19126 mem_base = xmlMemBlocks(); 19127 buf = gen_xmlBufferPtr(n_buf, 0); 19128 string = gen_const_char_ptr(n_string, 1); 19129 19130 xmlBufferWriteChar(buf, (const char *)string); 19131 call_tests++; 19132 des_xmlBufferPtr(n_buf, buf, 0); 19133 des_const_char_ptr(n_string, (const char *)string, 1); 19134 xmlResetLastError(); 19135 if (mem_base != xmlMemBlocks()) { 19136 printf("Leak of %d blocks found in xmlBufferWriteChar", 19137 xmlMemBlocks() - mem_base); 19138 test_ret++; 19139 printf(" %d", n_buf); 19140 printf(" %d", n_string); 19141 printf("\n"); 19142 } 19143 } 19144 } 19145 function_tests++; 19146 19147 return(test_ret); 19148 } 19149 19150 19151 static int 19152 test_xmlBufferWriteQuotedString(void) { 19153 int test_ret = 0; 19154 19155 int mem_base; 19156 xmlBufferPtr buf; /* the XML buffer output */ 19157 int n_buf; 19158 xmlChar * string; /* the string to add */ 19159 int n_string; 19160 19161 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 19162 for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) { 19163 mem_base = xmlMemBlocks(); 19164 buf = gen_xmlBufferPtr(n_buf, 0); 19165 string = gen_const_xmlChar_ptr(n_string, 1); 19166 19167 xmlBufferWriteQuotedString(buf, (const xmlChar *)string); 19168 call_tests++; 19169 des_xmlBufferPtr(n_buf, buf, 0); 19170 des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 1); 19171 xmlResetLastError(); 19172 if (mem_base != xmlMemBlocks()) { 19173 printf("Leak of %d blocks found in xmlBufferWriteQuotedString", 19174 xmlMemBlocks() - mem_base); 19175 test_ret++; 19176 printf(" %d", n_buf); 19177 printf(" %d", n_string); 19178 printf("\n"); 19179 } 19180 } 19181 } 19182 function_tests++; 19183 19184 return(test_ret); 19185 } 19186 19187 19188 static int 19189 test_xmlBuildQName(void) { 19190 int test_ret = 0; 19191 19192 int mem_base; 19193 xmlChar * ret_val; 19194 xmlChar * ncname; /* the Name */ 19195 int n_ncname; 19196 xmlChar * prefix; /* the prefix */ 19197 int n_prefix; 19198 xmlChar * memory; /* preallocated memory */ 19199 int n_memory; 19200 int len; /* preallocated memory length */ 19201 int n_len; 19202 19203 for (n_ncname = 0;n_ncname < gen_nb_const_xmlChar_ptr;n_ncname++) { 19204 for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) { 19205 for (n_memory = 0;n_memory < gen_nb_xmlChar_ptr;n_memory++) { 19206 for (n_len = 0;n_len < gen_nb_int;n_len++) { 19207 mem_base = xmlMemBlocks(); 19208 ncname = gen_const_xmlChar_ptr(n_ncname, 0); 19209 prefix = gen_const_xmlChar_ptr(n_prefix, 1); 19210 memory = gen_xmlChar_ptr(n_memory, 2); 19211 len = gen_int(n_len, 3); 19212 19213 ret_val = xmlBuildQName((const xmlChar *)ncname, (const xmlChar *)prefix, memory, len); 19214 if ((ret_val != NULL) && (ret_val != ncname) && 19215 (ret_val != prefix) && (ret_val != memory)) 19216 xmlFree(ret_val); 19217 ret_val = NULL; 19218 desret_xmlChar_ptr(ret_val); 19219 call_tests++; 19220 des_const_xmlChar_ptr(n_ncname, (const xmlChar *)ncname, 0); 19221 des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1); 19222 des_xmlChar_ptr(n_memory, memory, 2); 19223 des_int(n_len, len, 3); 19224 xmlResetLastError(); 19225 if (mem_base != xmlMemBlocks()) { 19226 printf("Leak of %d blocks found in xmlBuildQName", 19227 xmlMemBlocks() - mem_base); 19228 test_ret++; 19229 printf(" %d", n_ncname); 19230 printf(" %d", n_prefix); 19231 printf(" %d", n_memory); 19232 printf(" %d", n_len); 19233 printf("\n"); 19234 } 19235 } 19236 } 19237 } 19238 } 19239 function_tests++; 19240 19241 return(test_ret); 19242 } 19243 19244 19245 static int 19246 test_xmlChildElementCount(void) { 19247 int test_ret = 0; 19248 19249 #if defined(LIBXML_TREE_ENABLED) 19250 int mem_base; 19251 unsigned long ret_val; 19252 xmlNodePtr parent; /* the parent node */ 19253 int n_parent; 19254 19255 for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) { 19256 mem_base = xmlMemBlocks(); 19257 parent = gen_xmlNodePtr(n_parent, 0); 19258 19259 ret_val = xmlChildElementCount(parent); 19260 desret_unsigned_long(ret_val); 19261 call_tests++; 19262 des_xmlNodePtr(n_parent, parent, 0); 19263 xmlResetLastError(); 19264 if (mem_base != xmlMemBlocks()) { 19265 printf("Leak of %d blocks found in xmlChildElementCount", 19266 xmlMemBlocks() - mem_base); 19267 test_ret++; 19268 printf(" %d", n_parent); 19269 printf("\n"); 19270 } 19271 } 19272 function_tests++; 19273 #endif 19274 19275 return(test_ret); 19276 } 19277 19278 19279 static int 19280 test_xmlCopyDoc(void) { 19281 int test_ret = 0; 19282 19283 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 19284 int mem_base; 19285 xmlDocPtr ret_val; 19286 xmlDocPtr doc; /* the document */ 19287 int n_doc; 19288 int recursive; /* if not zero do a recursive copy. */ 19289 int n_recursive; 19290 19291 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 19292 for (n_recursive = 0;n_recursive < gen_nb_int;n_recursive++) { 19293 mem_base = xmlMemBlocks(); 19294 doc = gen_xmlDocPtr(n_doc, 0); 19295 recursive = gen_int(n_recursive, 1); 19296 19297 ret_val = xmlCopyDoc(doc, recursive); 19298 desret_xmlDocPtr(ret_val); 19299 call_tests++; 19300 des_xmlDocPtr(n_doc, doc, 0); 19301 des_int(n_recursive, recursive, 1); 19302 xmlResetLastError(); 19303 if (mem_base != xmlMemBlocks()) { 19304 printf("Leak of %d blocks found in xmlCopyDoc", 19305 xmlMemBlocks() - mem_base); 19306 test_ret++; 19307 printf(" %d", n_doc); 19308 printf(" %d", n_recursive); 19309 printf("\n"); 19310 } 19311 } 19312 } 19313 function_tests++; 19314 #endif 19315 19316 return(test_ret); 19317 } 19318 19319 19320 static int 19321 test_xmlCopyDtd(void) { 19322 int test_ret = 0; 19323 19324 #if defined(LIBXML_TREE_ENABLED) 19325 int mem_base; 19326 xmlDtdPtr ret_val; 19327 xmlDtdPtr dtd; /* the dtd */ 19328 int n_dtd; 19329 19330 for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) { 19331 mem_base = xmlMemBlocks(); 19332 dtd = gen_xmlDtdPtr(n_dtd, 0); 19333 19334 ret_val = xmlCopyDtd(dtd); 19335 desret_xmlDtdPtr(ret_val); 19336 call_tests++; 19337 des_xmlDtdPtr(n_dtd, dtd, 0); 19338 xmlResetLastError(); 19339 if (mem_base != xmlMemBlocks()) { 19340 printf("Leak of %d blocks found in xmlCopyDtd", 19341 xmlMemBlocks() - mem_base); 19342 test_ret++; 19343 printf(" %d", n_dtd); 19344 printf("\n"); 19345 } 19346 } 19347 function_tests++; 19348 #endif 19349 19350 return(test_ret); 19351 } 19352 19353 19354 static int 19355 test_xmlCopyNamespace(void) { 19356 int test_ret = 0; 19357 19358 int mem_base; 19359 xmlNsPtr ret_val; 19360 xmlNsPtr cur; /* the namespace */ 19361 int n_cur; 19362 19363 for (n_cur = 0;n_cur < gen_nb_xmlNsPtr;n_cur++) { 19364 mem_base = xmlMemBlocks(); 19365 cur = gen_xmlNsPtr(n_cur, 0); 19366 19367 ret_val = xmlCopyNamespace(cur); 19368 if (ret_val != NULL) xmlFreeNs(ret_val); 19369 desret_xmlNsPtr(ret_val); 19370 call_tests++; 19371 des_xmlNsPtr(n_cur, cur, 0); 19372 xmlResetLastError(); 19373 if (mem_base != xmlMemBlocks()) { 19374 printf("Leak of %d blocks found in xmlCopyNamespace", 19375 xmlMemBlocks() - mem_base); 19376 test_ret++; 19377 printf(" %d", n_cur); 19378 printf("\n"); 19379 } 19380 } 19381 function_tests++; 19382 19383 return(test_ret); 19384 } 19385 19386 19387 static int 19388 test_xmlCopyNamespaceList(void) { 19389 int test_ret = 0; 19390 19391 int mem_base; 19392 xmlNsPtr ret_val; 19393 xmlNsPtr cur; /* the first namespace */ 19394 int n_cur; 19395 19396 for (n_cur = 0;n_cur < gen_nb_xmlNsPtr;n_cur++) { 19397 mem_base = xmlMemBlocks(); 19398 cur = gen_xmlNsPtr(n_cur, 0); 19399 19400 ret_val = xmlCopyNamespaceList(cur); 19401 if (ret_val != NULL) xmlFreeNsList(ret_val); 19402 desret_xmlNsPtr(ret_val); 19403 call_tests++; 19404 des_xmlNsPtr(n_cur, cur, 0); 19405 xmlResetLastError(); 19406 if (mem_base != xmlMemBlocks()) { 19407 printf("Leak of %d blocks found in xmlCopyNamespaceList", 19408 xmlMemBlocks() - mem_base); 19409 test_ret++; 19410 printf(" %d", n_cur); 19411 printf("\n"); 19412 } 19413 } 19414 function_tests++; 19415 19416 return(test_ret); 19417 } 19418 19419 19420 static int 19421 test_xmlCopyNode(void) { 19422 int test_ret = 0; 19423 19424 int mem_base; 19425 xmlNodePtr ret_val; 19426 xmlNodePtr node; /* the node */ 19427 int n_node; 19428 int extended; /* if 1 do a recursive copy (properties, namespaces and children when applicable) if 2 copy properties and namespaces (when applicable) */ 19429 int n_extended; 19430 19431 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 19432 for (n_extended = 0;n_extended < gen_nb_int;n_extended++) { 19433 mem_base = xmlMemBlocks(); 19434 node = gen_xmlNodePtr(n_node, 0); 19435 extended = gen_int(n_extended, 1); 19436 19437 ret_val = xmlCopyNode(node, extended); 19438 desret_xmlNodePtr(ret_val); 19439 call_tests++; 19440 des_xmlNodePtr(n_node, node, 0); 19441 des_int(n_extended, extended, 1); 19442 xmlResetLastError(); 19443 if (mem_base != xmlMemBlocks()) { 19444 printf("Leak of %d blocks found in xmlCopyNode", 19445 xmlMemBlocks() - mem_base); 19446 test_ret++; 19447 printf(" %d", n_node); 19448 printf(" %d", n_extended); 19449 printf("\n"); 19450 } 19451 } 19452 } 19453 function_tests++; 19454 19455 return(test_ret); 19456 } 19457 19458 19459 static int 19460 test_xmlCopyNodeList(void) { 19461 int test_ret = 0; 19462 19463 int mem_base; 19464 xmlNodePtr ret_val; 19465 xmlNodePtr node; /* the first node in the list. */ 19466 int n_node; 19467 19468 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 19469 mem_base = xmlMemBlocks(); 19470 node = gen_xmlNodePtr(n_node, 0); 19471 19472 ret_val = xmlCopyNodeList(node); 19473 desret_xmlNodePtr(ret_val); 19474 call_tests++; 19475 des_xmlNodePtr(n_node, node, 0); 19476 xmlResetLastError(); 19477 if (mem_base != xmlMemBlocks()) { 19478 printf("Leak of %d blocks found in xmlCopyNodeList", 19479 xmlMemBlocks() - mem_base); 19480 test_ret++; 19481 printf(" %d", n_node); 19482 printf("\n"); 19483 } 19484 } 19485 function_tests++; 19486 19487 return(test_ret); 19488 } 19489 19490 19491 static int 19492 test_xmlCopyProp(void) { 19493 int test_ret = 0; 19494 19495 int mem_base; 19496 xmlAttrPtr ret_val; 19497 xmlNodePtr target; /* the element where the attribute will be grafted */ 19498 int n_target; 19499 xmlAttrPtr cur; /* the attribute */ 19500 int n_cur; 19501 19502 for (n_target = 0;n_target < gen_nb_xmlNodePtr;n_target++) { 19503 for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) { 19504 mem_base = xmlMemBlocks(); 19505 target = gen_xmlNodePtr(n_target, 0); 19506 cur = gen_xmlAttrPtr(n_cur, 1); 19507 19508 ret_val = xmlCopyProp(target, cur); 19509 desret_xmlAttrPtr(ret_val); 19510 call_tests++; 19511 des_xmlNodePtr(n_target, target, 0); 19512 des_xmlAttrPtr(n_cur, cur, 1); 19513 xmlResetLastError(); 19514 if (mem_base != xmlMemBlocks()) { 19515 printf("Leak of %d blocks found in xmlCopyProp", 19516 xmlMemBlocks() - mem_base); 19517 test_ret++; 19518 printf(" %d", n_target); 19519 printf(" %d", n_cur); 19520 printf("\n"); 19521 } 19522 } 19523 } 19524 function_tests++; 19525 19526 return(test_ret); 19527 } 19528 19529 19530 static int 19531 test_xmlCopyPropList(void) { 19532 int test_ret = 0; 19533 19534 int mem_base; 19535 xmlAttrPtr ret_val; 19536 xmlNodePtr target; /* the element where the attributes will be grafted */ 19537 int n_target; 19538 xmlAttrPtr cur; /* the first attribute */ 19539 int n_cur; 19540 19541 for (n_target = 0;n_target < gen_nb_xmlNodePtr;n_target++) { 19542 for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) { 19543 mem_base = xmlMemBlocks(); 19544 target = gen_xmlNodePtr(n_target, 0); 19545 cur = gen_xmlAttrPtr(n_cur, 1); 19546 19547 ret_val = xmlCopyPropList(target, cur); 19548 desret_xmlAttrPtr(ret_val); 19549 call_tests++; 19550 des_xmlNodePtr(n_target, target, 0); 19551 des_xmlAttrPtr(n_cur, cur, 1); 19552 xmlResetLastError(); 19553 if (mem_base != xmlMemBlocks()) { 19554 printf("Leak of %d blocks found in xmlCopyPropList", 19555 xmlMemBlocks() - mem_base); 19556 test_ret++; 19557 printf(" %d", n_target); 19558 printf(" %d", n_cur); 19559 printf("\n"); 19560 } 19561 } 19562 } 19563 function_tests++; 19564 19565 return(test_ret); 19566 } 19567 19568 19569 static int 19570 test_xmlCreateIntSubset(void) { 19571 int test_ret = 0; 19572 19573 int mem_base; 19574 xmlDtdPtr ret_val; 19575 xmlDocPtr doc; /* the document pointer */ 19576 int n_doc; 19577 xmlChar * name; /* the DTD name */ 19578 int n_name; 19579 xmlChar * ExternalID; /* the external (PUBLIC) ID */ 19580 int n_ExternalID; 19581 xmlChar * SystemID; /* the system ID */ 19582 int n_SystemID; 19583 19584 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 19585 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 19586 for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) { 19587 for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) { 19588 mem_base = xmlMemBlocks(); 19589 doc = gen_xmlDocPtr(n_doc, 0); 19590 name = gen_const_xmlChar_ptr(n_name, 1); 19591 ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2); 19592 SystemID = gen_const_xmlChar_ptr(n_SystemID, 3); 19593 19594 ret_val = xmlCreateIntSubset(doc, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID); 19595 desret_xmlDtdPtr(ret_val); 19596 call_tests++; 19597 des_xmlDocPtr(n_doc, doc, 0); 19598 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 19599 des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2); 19600 des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3); 19601 xmlResetLastError(); 19602 if (mem_base != xmlMemBlocks()) { 19603 printf("Leak of %d blocks found in xmlCreateIntSubset", 19604 xmlMemBlocks() - mem_base); 19605 test_ret++; 19606 printf(" %d", n_doc); 19607 printf(" %d", n_name); 19608 printf(" %d", n_ExternalID); 19609 printf(" %d", n_SystemID); 19610 printf("\n"); 19611 } 19612 } 19613 } 19614 } 19615 } 19616 function_tests++; 19617 19618 return(test_ret); 19619 } 19620 19621 19622 #define gen_nb_xmlDOMWrapCtxtPtr 1 19623 static xmlDOMWrapCtxtPtr gen_xmlDOMWrapCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 19624 return(NULL); 19625 } 19626 static void des_xmlDOMWrapCtxtPtr(int no ATTRIBUTE_UNUSED, xmlDOMWrapCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 19627 } 19628 19629 static int 19630 test_xmlDOMWrapAdoptNode(void) { 19631 int test_ret = 0; 19632 19633 int mem_base; 19634 int ret_val; 19635 xmlDOMWrapCtxtPtr ctxt; /* the optional context for custom processing */ 19636 int n_ctxt; 19637 xmlDocPtr sourceDoc; /* the optional sourceDoc */ 19638 int n_sourceDoc; 19639 xmlNodePtr node; /* the node to start with */ 19640 int n_node; 19641 xmlDocPtr destDoc; /* the destination doc */ 19642 int n_destDoc; 19643 xmlNodePtr destParent; /* the optional new parent of @node in @destDoc */ 19644 int n_destParent; 19645 int options; /* option flags */ 19646 int n_options; 19647 19648 for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) { 19649 for (n_sourceDoc = 0;n_sourceDoc < gen_nb_xmlDocPtr;n_sourceDoc++) { 19650 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 19651 for (n_destDoc = 0;n_destDoc < gen_nb_xmlDocPtr;n_destDoc++) { 19652 for (n_destParent = 0;n_destParent < gen_nb_xmlNodePtr;n_destParent++) { 19653 for (n_options = 0;n_options < gen_nb_int;n_options++) { 19654 mem_base = xmlMemBlocks(); 19655 ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0); 19656 sourceDoc = gen_xmlDocPtr(n_sourceDoc, 1); 19657 node = gen_xmlNodePtr(n_node, 2); 19658 destDoc = gen_xmlDocPtr(n_destDoc, 3); 19659 destParent = gen_xmlNodePtr(n_destParent, 4); 19660 options = gen_int(n_options, 5); 19661 19662 ret_val = xmlDOMWrapAdoptNode(ctxt, sourceDoc, node, destDoc, destParent, options); 19663 if ((node != NULL) && (node->parent == NULL)) {xmlUnlinkNode(node);xmlFreeNode(node);node = NULL;} 19664 desret_int(ret_val); 19665 call_tests++; 19666 des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0); 19667 des_xmlDocPtr(n_sourceDoc, sourceDoc, 1); 19668 des_xmlNodePtr(n_node, node, 2); 19669 des_xmlDocPtr(n_destDoc, destDoc, 3); 19670 des_xmlNodePtr(n_destParent, destParent, 4); 19671 des_int(n_options, options, 5); 19672 xmlResetLastError(); 19673 if (mem_base != xmlMemBlocks()) { 19674 printf("Leak of %d blocks found in xmlDOMWrapAdoptNode", 19675 xmlMemBlocks() - mem_base); 19676 test_ret++; 19677 printf(" %d", n_ctxt); 19678 printf(" %d", n_sourceDoc); 19679 printf(" %d", n_node); 19680 printf(" %d", n_destDoc); 19681 printf(" %d", n_destParent); 19682 printf(" %d", n_options); 19683 printf("\n"); 19684 } 19685 } 19686 } 19687 } 19688 } 19689 } 19690 } 19691 function_tests++; 19692 19693 return(test_ret); 19694 } 19695 19696 19697 static int 19698 test_xmlDOMWrapCloneNode(void) { 19699 int test_ret = 0; 19700 19701 int mem_base; 19702 int ret_val; 19703 xmlDOMWrapCtxtPtr ctxt; /* the optional context for custom processing */ 19704 int n_ctxt; 19705 xmlDocPtr sourceDoc; /* the optional sourceDoc */ 19706 int n_sourceDoc; 19707 xmlNodePtr node; /* the node to start with */ 19708 int n_node; 19709 xmlNodePtr * resNode; /* the clone of the given @node */ 19710 int n_resNode; 19711 xmlDocPtr destDoc; /* the destination doc */ 19712 int n_destDoc; 19713 xmlNodePtr destParent; /* the optional new parent of @node in @destDoc */ 19714 int n_destParent; 19715 int deep; /* descend into child if set */ 19716 int n_deep; 19717 int options; /* option flags */ 19718 int n_options; 19719 19720 for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) { 19721 for (n_sourceDoc = 0;n_sourceDoc < gen_nb_xmlDocPtr;n_sourceDoc++) { 19722 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 19723 for (n_resNode = 0;n_resNode < gen_nb_xmlNodePtr_ptr;n_resNode++) { 19724 for (n_destDoc = 0;n_destDoc < gen_nb_xmlDocPtr;n_destDoc++) { 19725 for (n_destParent = 0;n_destParent < gen_nb_xmlNodePtr;n_destParent++) { 19726 for (n_deep = 0;n_deep < gen_nb_int;n_deep++) { 19727 for (n_options = 0;n_options < gen_nb_int;n_options++) { 19728 mem_base = xmlMemBlocks(); 19729 ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0); 19730 sourceDoc = gen_xmlDocPtr(n_sourceDoc, 1); 19731 node = gen_xmlNodePtr(n_node, 2); 19732 resNode = gen_xmlNodePtr_ptr(n_resNode, 3); 19733 destDoc = gen_xmlDocPtr(n_destDoc, 4); 19734 destParent = gen_xmlNodePtr(n_destParent, 5); 19735 deep = gen_int(n_deep, 6); 19736 options = gen_int(n_options, 7); 19737 19738 ret_val = xmlDOMWrapCloneNode(ctxt, sourceDoc, node, resNode, destDoc, destParent, deep, options); 19739 desret_int(ret_val); 19740 call_tests++; 19741 des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0); 19742 des_xmlDocPtr(n_sourceDoc, sourceDoc, 1); 19743 des_xmlNodePtr(n_node, node, 2); 19744 des_xmlNodePtr_ptr(n_resNode, resNode, 3); 19745 des_xmlDocPtr(n_destDoc, destDoc, 4); 19746 des_xmlNodePtr(n_destParent, destParent, 5); 19747 des_int(n_deep, deep, 6); 19748 des_int(n_options, options, 7); 19749 xmlResetLastError(); 19750 if (mem_base != xmlMemBlocks()) { 19751 printf("Leak of %d blocks found in xmlDOMWrapCloneNode", 19752 xmlMemBlocks() - mem_base); 19753 test_ret++; 19754 printf(" %d", n_ctxt); 19755 printf(" %d", n_sourceDoc); 19756 printf(" %d", n_node); 19757 printf(" %d", n_resNode); 19758 printf(" %d", n_destDoc); 19759 printf(" %d", n_destParent); 19760 printf(" %d", n_deep); 19761 printf(" %d", n_options); 19762 printf("\n"); 19763 } 19764 } 19765 } 19766 } 19767 } 19768 } 19769 } 19770 } 19771 } 19772 function_tests++; 19773 19774 return(test_ret); 19775 } 19776 19777 19778 static int 19779 test_xmlDOMWrapNewCtxt(void) { 19780 int test_ret = 0; 19781 19782 19783 /* missing type support */ 19784 return(test_ret); 19785 } 19786 19787 19788 static int 19789 test_xmlDOMWrapReconcileNamespaces(void) { 19790 int test_ret = 0; 19791 19792 int mem_base; 19793 int ret_val; 19794 xmlDOMWrapCtxtPtr ctxt; /* DOM wrapper context, unused at the moment */ 19795 int n_ctxt; 19796 xmlNodePtr elem; /* the element-node */ 19797 int n_elem; 19798 int options; /* option flags */ 19799 int n_options; 19800 19801 for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) { 19802 for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) { 19803 for (n_options = 0;n_options < gen_nb_int;n_options++) { 19804 mem_base = xmlMemBlocks(); 19805 ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0); 19806 elem = gen_xmlNodePtr(n_elem, 1); 19807 options = gen_int(n_options, 2); 19808 19809 ret_val = xmlDOMWrapReconcileNamespaces(ctxt, elem, options); 19810 desret_int(ret_val); 19811 call_tests++; 19812 des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0); 19813 des_xmlNodePtr(n_elem, elem, 1); 19814 des_int(n_options, options, 2); 19815 xmlResetLastError(); 19816 if (mem_base != xmlMemBlocks()) { 19817 printf("Leak of %d blocks found in xmlDOMWrapReconcileNamespaces", 19818 xmlMemBlocks() - mem_base); 19819 test_ret++; 19820 printf(" %d", n_ctxt); 19821 printf(" %d", n_elem); 19822 printf(" %d", n_options); 19823 printf("\n"); 19824 } 19825 } 19826 } 19827 } 19828 function_tests++; 19829 19830 return(test_ret); 19831 } 19832 19833 19834 static int 19835 test_xmlDOMWrapRemoveNode(void) { 19836 int test_ret = 0; 19837 19838 int mem_base; 19839 int ret_val; 19840 xmlDOMWrapCtxtPtr ctxt; /* a DOM wrapper context */ 19841 int n_ctxt; 19842 xmlDocPtr doc; /* the doc */ 19843 int n_doc; 19844 xmlNodePtr node; /* the node to be removed. */ 19845 int n_node; 19846 int options; /* set of options, unused at the moment */ 19847 int n_options; 19848 19849 for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) { 19850 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 19851 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 19852 for (n_options = 0;n_options < gen_nb_int;n_options++) { 19853 mem_base = xmlMemBlocks(); 19854 ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0); 19855 doc = gen_xmlDocPtr(n_doc, 1); 19856 node = gen_xmlNodePtr(n_node, 2); 19857 options = gen_int(n_options, 3); 19858 19859 ret_val = xmlDOMWrapRemoveNode(ctxt, doc, node, options); 19860 desret_int(ret_val); 19861 call_tests++; 19862 des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0); 19863 des_xmlDocPtr(n_doc, doc, 1); 19864 des_xmlNodePtr(n_node, node, 2); 19865 des_int(n_options, options, 3); 19866 xmlResetLastError(); 19867 if (mem_base != xmlMemBlocks()) { 19868 printf("Leak of %d blocks found in xmlDOMWrapRemoveNode", 19869 xmlMemBlocks() - mem_base); 19870 test_ret++; 19871 printf(" %d", n_ctxt); 19872 printf(" %d", n_doc); 19873 printf(" %d", n_node); 19874 printf(" %d", n_options); 19875 printf("\n"); 19876 } 19877 } 19878 } 19879 } 19880 } 19881 function_tests++; 19882 19883 return(test_ret); 19884 } 19885 19886 19887 static int 19888 test_xmlDocCopyNode(void) { 19889 int test_ret = 0; 19890 19891 int mem_base; 19892 xmlNodePtr ret_val; 19893 xmlNodePtr node; /* the node */ 19894 int n_node; 19895 xmlDocPtr doc; /* the document */ 19896 int n_doc; 19897 int extended; /* if 1 do a recursive copy (properties, namespaces and children when applicable) if 2 copy properties and namespaces (when applicable) */ 19898 int n_extended; 19899 19900 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 19901 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 19902 for (n_extended = 0;n_extended < gen_nb_int;n_extended++) { 19903 mem_base = xmlMemBlocks(); 19904 node = gen_xmlNodePtr(n_node, 0); 19905 doc = gen_xmlDocPtr(n_doc, 1); 19906 extended = gen_int(n_extended, 2); 19907 19908 ret_val = xmlDocCopyNode(node, doc, extended); 19909 desret_xmlNodePtr(ret_val); 19910 call_tests++; 19911 des_xmlNodePtr(n_node, node, 0); 19912 des_xmlDocPtr(n_doc, doc, 1); 19913 des_int(n_extended, extended, 2); 19914 xmlResetLastError(); 19915 if (mem_base != xmlMemBlocks()) { 19916 printf("Leak of %d blocks found in xmlDocCopyNode", 19917 xmlMemBlocks() - mem_base); 19918 test_ret++; 19919 printf(" %d", n_node); 19920 printf(" %d", n_doc); 19921 printf(" %d", n_extended); 19922 printf("\n"); 19923 } 19924 } 19925 } 19926 } 19927 function_tests++; 19928 19929 return(test_ret); 19930 } 19931 19932 19933 static int 19934 test_xmlDocCopyNodeList(void) { 19935 int test_ret = 0; 19936 19937 int mem_base; 19938 xmlNodePtr ret_val; 19939 xmlDocPtr doc; /* the target document */ 19940 int n_doc; 19941 xmlNodePtr node; /* the first node in the list. */ 19942 int n_node; 19943 19944 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 19945 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 19946 mem_base = xmlMemBlocks(); 19947 doc = gen_xmlDocPtr(n_doc, 0); 19948 node = gen_xmlNodePtr(n_node, 1); 19949 19950 ret_val = xmlDocCopyNodeList(doc, node); 19951 desret_xmlNodePtr(ret_val); 19952 call_tests++; 19953 des_xmlDocPtr(n_doc, doc, 0); 19954 des_xmlNodePtr(n_node, node, 1); 19955 xmlResetLastError(); 19956 if (mem_base != xmlMemBlocks()) { 19957 printf("Leak of %d blocks found in xmlDocCopyNodeList", 19958 xmlMemBlocks() - mem_base); 19959 test_ret++; 19960 printf(" %d", n_doc); 19961 printf(" %d", n_node); 19962 printf("\n"); 19963 } 19964 } 19965 } 19966 function_tests++; 19967 19968 return(test_ret); 19969 } 19970 19971 19972 static int 19973 test_xmlDocDump(void) { 19974 int test_ret = 0; 19975 19976 #if defined(LIBXML_OUTPUT_ENABLED) 19977 int mem_base; 19978 int ret_val; 19979 FILE * f; /* the FILE* */ 19980 int n_f; 19981 xmlDocPtr cur; /* the document */ 19982 int n_cur; 19983 19984 for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) { 19985 for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) { 19986 mem_base = xmlMemBlocks(); 19987 f = gen_FILE_ptr(n_f, 0); 19988 cur = gen_xmlDocPtr(n_cur, 1); 19989 19990 ret_val = xmlDocDump(f, cur); 19991 desret_int(ret_val); 19992 call_tests++; 19993 des_FILE_ptr(n_f, f, 0); 19994 des_xmlDocPtr(n_cur, cur, 1); 19995 xmlResetLastError(); 19996 if (mem_base != xmlMemBlocks()) { 19997 printf("Leak of %d blocks found in xmlDocDump", 19998 xmlMemBlocks() - mem_base); 19999 test_ret++; 20000 printf(" %d", n_f); 20001 printf(" %d", n_cur); 20002 printf("\n"); 20003 } 20004 } 20005 } 20006 function_tests++; 20007 #endif 20008 20009 return(test_ret); 20010 } 20011 20012 20013 static int 20014 test_xmlDocDumpFormatMemory(void) { 20015 int test_ret = 0; 20016 20017 #if defined(LIBXML_OUTPUT_ENABLED) 20018 int mem_base; 20019 xmlDocPtr cur; /* the document */ 20020 int n_cur; 20021 xmlChar ** mem; /* OUT: the memory pointer */ 20022 int n_mem; 20023 int * size; /* OUT: the memory length */ 20024 int n_size; 20025 int format; /* should formatting spaces been added */ 20026 int n_format; 20027 20028 for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) { 20029 for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) { 20030 for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) { 20031 for (n_format = 0;n_format < gen_nb_int;n_format++) { 20032 mem_base = xmlMemBlocks(); 20033 cur = gen_xmlDocPtr(n_cur, 0); 20034 mem = gen_xmlChar_ptr_ptr(n_mem, 1); 20035 size = gen_int_ptr(n_size, 2); 20036 format = gen_int(n_format, 3); 20037 20038 xmlDocDumpFormatMemory(cur, mem, size, format); 20039 call_tests++; 20040 des_xmlDocPtr(n_cur, cur, 0); 20041 des_xmlChar_ptr_ptr(n_mem, mem, 1); 20042 des_int_ptr(n_size, size, 2); 20043 des_int(n_format, format, 3); 20044 xmlResetLastError(); 20045 if (mem_base != xmlMemBlocks()) { 20046 printf("Leak of %d blocks found in xmlDocDumpFormatMemory", 20047 xmlMemBlocks() - mem_base); 20048 test_ret++; 20049 printf(" %d", n_cur); 20050 printf(" %d", n_mem); 20051 printf(" %d", n_size); 20052 printf(" %d", n_format); 20053 printf("\n"); 20054 } 20055 } 20056 } 20057 } 20058 } 20059 function_tests++; 20060 #endif 20061 20062 return(test_ret); 20063 } 20064 20065 20066 static int 20067 test_xmlDocDumpFormatMemoryEnc(void) { 20068 int test_ret = 0; 20069 20070 #if defined(LIBXML_OUTPUT_ENABLED) 20071 int mem_base; 20072 xmlDocPtr out_doc; /* Document to generate XML text from */ 20073 int n_out_doc; 20074 xmlChar ** doc_txt_ptr; /* Memory pointer for allocated XML text */ 20075 int n_doc_txt_ptr; 20076 int * doc_txt_len; /* Length of the generated XML text */ 20077 int n_doc_txt_len; 20078 char * txt_encoding; /* Character encoding to use when generating XML text */ 20079 int n_txt_encoding; 20080 int format; /* should formatting spaces been added */ 20081 int n_format; 20082 20083 for (n_out_doc = 0;n_out_doc < gen_nb_xmlDocPtr;n_out_doc++) { 20084 for (n_doc_txt_ptr = 0;n_doc_txt_ptr < gen_nb_xmlChar_ptr_ptr;n_doc_txt_ptr++) { 20085 for (n_doc_txt_len = 0;n_doc_txt_len < gen_nb_int_ptr;n_doc_txt_len++) { 20086 for (n_txt_encoding = 0;n_txt_encoding < gen_nb_const_char_ptr;n_txt_encoding++) { 20087 for (n_format = 0;n_format < gen_nb_int;n_format++) { 20088 mem_base = xmlMemBlocks(); 20089 out_doc = gen_xmlDocPtr(n_out_doc, 0); 20090 doc_txt_ptr = gen_xmlChar_ptr_ptr(n_doc_txt_ptr, 1); 20091 doc_txt_len = gen_int_ptr(n_doc_txt_len, 2); 20092 txt_encoding = gen_const_char_ptr(n_txt_encoding, 3); 20093 format = gen_int(n_format, 4); 20094 20095 xmlDocDumpFormatMemoryEnc(out_doc, doc_txt_ptr, doc_txt_len, (const char *)txt_encoding, format); 20096 call_tests++; 20097 des_xmlDocPtr(n_out_doc, out_doc, 0); 20098 des_xmlChar_ptr_ptr(n_doc_txt_ptr, doc_txt_ptr, 1); 20099 des_int_ptr(n_doc_txt_len, doc_txt_len, 2); 20100 des_const_char_ptr(n_txt_encoding, (const char *)txt_encoding, 3); 20101 des_int(n_format, format, 4); 20102 xmlResetLastError(); 20103 if (mem_base != xmlMemBlocks()) { 20104 printf("Leak of %d blocks found in xmlDocDumpFormatMemoryEnc", 20105 xmlMemBlocks() - mem_base); 20106 test_ret++; 20107 printf(" %d", n_out_doc); 20108 printf(" %d", n_doc_txt_ptr); 20109 printf(" %d", n_doc_txt_len); 20110 printf(" %d", n_txt_encoding); 20111 printf(" %d", n_format); 20112 printf("\n"); 20113 } 20114 } 20115 } 20116 } 20117 } 20118 } 20119 function_tests++; 20120 #endif 20121 20122 return(test_ret); 20123 } 20124 20125 20126 static int 20127 test_xmlDocDumpMemory(void) { 20128 int test_ret = 0; 20129 20130 #if defined(LIBXML_OUTPUT_ENABLED) 20131 int mem_base; 20132 xmlDocPtr cur; /* the document */ 20133 int n_cur; 20134 xmlChar ** mem; /* OUT: the memory pointer */ 20135 int n_mem; 20136 int * size; /* OUT: the memory length */ 20137 int n_size; 20138 20139 for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) { 20140 for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) { 20141 for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) { 20142 mem_base = xmlMemBlocks(); 20143 cur = gen_xmlDocPtr(n_cur, 0); 20144 mem = gen_xmlChar_ptr_ptr(n_mem, 1); 20145 size = gen_int_ptr(n_size, 2); 20146 20147 xmlDocDumpMemory(cur, mem, size); 20148 call_tests++; 20149 des_xmlDocPtr(n_cur, cur, 0); 20150 des_xmlChar_ptr_ptr(n_mem, mem, 1); 20151 des_int_ptr(n_size, size, 2); 20152 xmlResetLastError(); 20153 if (mem_base != xmlMemBlocks()) { 20154 printf("Leak of %d blocks found in xmlDocDumpMemory", 20155 xmlMemBlocks() - mem_base); 20156 test_ret++; 20157 printf(" %d", n_cur); 20158 printf(" %d", n_mem); 20159 printf(" %d", n_size); 20160 printf("\n"); 20161 } 20162 } 20163 } 20164 } 20165 function_tests++; 20166 #endif 20167 20168 return(test_ret); 20169 } 20170 20171 20172 static int 20173 test_xmlDocDumpMemoryEnc(void) { 20174 int test_ret = 0; 20175 20176 #if defined(LIBXML_OUTPUT_ENABLED) 20177 int mem_base; 20178 xmlDocPtr out_doc; /* Document to generate XML text from */ 20179 int n_out_doc; 20180 xmlChar ** doc_txt_ptr; /* Memory pointer for allocated XML text */ 20181 int n_doc_txt_ptr; 20182 int * doc_txt_len; /* Length of the generated XML text */ 20183 int n_doc_txt_len; 20184 char * txt_encoding; /* Character encoding to use when generating XML text */ 20185 int n_txt_encoding; 20186 20187 for (n_out_doc = 0;n_out_doc < gen_nb_xmlDocPtr;n_out_doc++) { 20188 for (n_doc_txt_ptr = 0;n_doc_txt_ptr < gen_nb_xmlChar_ptr_ptr;n_doc_txt_ptr++) { 20189 for (n_doc_txt_len = 0;n_doc_txt_len < gen_nb_int_ptr;n_doc_txt_len++) { 20190 for (n_txt_encoding = 0;n_txt_encoding < gen_nb_const_char_ptr;n_txt_encoding++) { 20191 mem_base = xmlMemBlocks(); 20192 out_doc = gen_xmlDocPtr(n_out_doc, 0); 20193 doc_txt_ptr = gen_xmlChar_ptr_ptr(n_doc_txt_ptr, 1); 20194 doc_txt_len = gen_int_ptr(n_doc_txt_len, 2); 20195 txt_encoding = gen_const_char_ptr(n_txt_encoding, 3); 20196 20197 xmlDocDumpMemoryEnc(out_doc, doc_txt_ptr, doc_txt_len, (const char *)txt_encoding); 20198 call_tests++; 20199 des_xmlDocPtr(n_out_doc, out_doc, 0); 20200 des_xmlChar_ptr_ptr(n_doc_txt_ptr, doc_txt_ptr, 1); 20201 des_int_ptr(n_doc_txt_len, doc_txt_len, 2); 20202 des_const_char_ptr(n_txt_encoding, (const char *)txt_encoding, 3); 20203 xmlResetLastError(); 20204 if (mem_base != xmlMemBlocks()) { 20205 printf("Leak of %d blocks found in xmlDocDumpMemoryEnc", 20206 xmlMemBlocks() - mem_base); 20207 test_ret++; 20208 printf(" %d", n_out_doc); 20209 printf(" %d", n_doc_txt_ptr); 20210 printf(" %d", n_doc_txt_len); 20211 printf(" %d", n_txt_encoding); 20212 printf("\n"); 20213 } 20214 } 20215 } 20216 } 20217 } 20218 function_tests++; 20219 #endif 20220 20221 return(test_ret); 20222 } 20223 20224 20225 static int 20226 test_xmlDocFormatDump(void) { 20227 int test_ret = 0; 20228 20229 #if defined(LIBXML_OUTPUT_ENABLED) 20230 int mem_base; 20231 int ret_val; 20232 FILE * f; /* the FILE* */ 20233 int n_f; 20234 xmlDocPtr cur; /* the document */ 20235 int n_cur; 20236 int format; /* should formatting spaces been added */ 20237 int n_format; 20238 20239 for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) { 20240 for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) { 20241 for (n_format = 0;n_format < gen_nb_int;n_format++) { 20242 mem_base = xmlMemBlocks(); 20243 f = gen_FILE_ptr(n_f, 0); 20244 cur = gen_xmlDocPtr(n_cur, 1); 20245 format = gen_int(n_format, 2); 20246 20247 ret_val = xmlDocFormatDump(f, cur, format); 20248 desret_int(ret_val); 20249 call_tests++; 20250 des_FILE_ptr(n_f, f, 0); 20251 des_xmlDocPtr(n_cur, cur, 1); 20252 des_int(n_format, format, 2); 20253 xmlResetLastError(); 20254 if (mem_base != xmlMemBlocks()) { 20255 printf("Leak of %d blocks found in xmlDocFormatDump", 20256 xmlMemBlocks() - mem_base); 20257 test_ret++; 20258 printf(" %d", n_f); 20259 printf(" %d", n_cur); 20260 printf(" %d", n_format); 20261 printf("\n"); 20262 } 20263 } 20264 } 20265 } 20266 function_tests++; 20267 #endif 20268 20269 return(test_ret); 20270 } 20271 20272 20273 static int 20274 test_xmlDocGetRootElement(void) { 20275 int test_ret = 0; 20276 20277 int mem_base; 20278 xmlNodePtr ret_val; 20279 xmlDoc * doc; /* the document */ 20280 int n_doc; 20281 20282 for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) { 20283 mem_base = xmlMemBlocks(); 20284 doc = gen_const_xmlDoc_ptr(n_doc, 0); 20285 20286 ret_val = xmlDocGetRootElement((const xmlDoc *)doc); 20287 desret_xmlNodePtr(ret_val); 20288 call_tests++; 20289 des_const_xmlDoc_ptr(n_doc, (const xmlDoc *)doc, 0); 20290 xmlResetLastError(); 20291 if (mem_base != xmlMemBlocks()) { 20292 printf("Leak of %d blocks found in xmlDocGetRootElement", 20293 xmlMemBlocks() - mem_base); 20294 test_ret++; 20295 printf(" %d", n_doc); 20296 printf("\n"); 20297 } 20298 } 20299 function_tests++; 20300 20301 return(test_ret); 20302 } 20303 20304 20305 static int 20306 test_xmlDocSetRootElement(void) { 20307 int test_ret = 0; 20308 20309 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) 20310 int mem_base; 20311 xmlNodePtr ret_val; 20312 xmlDocPtr doc; /* the document */ 20313 int n_doc; 20314 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. */ 20315 int n_root; 20316 20317 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 20318 for (n_root = 0;n_root < gen_nb_xmlNodePtr_in;n_root++) { 20319 mem_base = xmlMemBlocks(); 20320 doc = gen_xmlDocPtr(n_doc, 0); 20321 root = gen_xmlNodePtr_in(n_root, 1); 20322 20323 ret_val = xmlDocSetRootElement(doc, root); 20324 if (doc == NULL) { xmlFreeNode(root) ; root = NULL ; } 20325 desret_xmlNodePtr(ret_val); 20326 call_tests++; 20327 des_xmlDocPtr(n_doc, doc, 0); 20328 des_xmlNodePtr_in(n_root, root, 1); 20329 xmlResetLastError(); 20330 if (mem_base != xmlMemBlocks()) { 20331 printf("Leak of %d blocks found in xmlDocSetRootElement", 20332 xmlMemBlocks() - mem_base); 20333 test_ret++; 20334 printf(" %d", n_doc); 20335 printf(" %d", n_root); 20336 printf("\n"); 20337 } 20338 } 20339 } 20340 function_tests++; 20341 #endif 20342 20343 return(test_ret); 20344 } 20345 20346 20347 static int 20348 test_xmlElemDump(void) { 20349 int test_ret = 0; 20350 20351 #if defined(LIBXML_OUTPUT_ENABLED) 20352 int mem_base; 20353 FILE * f; /* the FILE * for the output */ 20354 int n_f; 20355 xmlDocPtr doc; /* the document */ 20356 int n_doc; 20357 xmlNodePtr cur; /* the current node */ 20358 int n_cur; 20359 20360 for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) { 20361 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 20362 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 20363 mem_base = xmlMemBlocks(); 20364 f = gen_FILE_ptr(n_f, 0); 20365 doc = gen_xmlDocPtr(n_doc, 1); 20366 cur = gen_xmlNodePtr(n_cur, 2); 20367 20368 xmlElemDump(f, doc, cur); 20369 call_tests++; 20370 des_FILE_ptr(n_f, f, 0); 20371 des_xmlDocPtr(n_doc, doc, 1); 20372 des_xmlNodePtr(n_cur, cur, 2); 20373 xmlResetLastError(); 20374 if (mem_base != xmlMemBlocks()) { 20375 printf("Leak of %d blocks found in xmlElemDump", 20376 xmlMemBlocks() - mem_base); 20377 test_ret++; 20378 printf(" %d", n_f); 20379 printf(" %d", n_doc); 20380 printf(" %d", n_cur); 20381 printf("\n"); 20382 } 20383 } 20384 } 20385 } 20386 function_tests++; 20387 #endif 20388 20389 return(test_ret); 20390 } 20391 20392 20393 static int 20394 test_xmlFirstElementChild(void) { 20395 int test_ret = 0; 20396 20397 #if defined(LIBXML_TREE_ENABLED) 20398 int mem_base; 20399 xmlNodePtr ret_val; 20400 xmlNodePtr parent; /* the parent node */ 20401 int n_parent; 20402 20403 for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) { 20404 mem_base = xmlMemBlocks(); 20405 parent = gen_xmlNodePtr(n_parent, 0); 20406 20407 ret_val = xmlFirstElementChild(parent); 20408 desret_xmlNodePtr(ret_val); 20409 call_tests++; 20410 des_xmlNodePtr(n_parent, parent, 0); 20411 xmlResetLastError(); 20412 if (mem_base != xmlMemBlocks()) { 20413 printf("Leak of %d blocks found in xmlFirstElementChild", 20414 xmlMemBlocks() - mem_base); 20415 test_ret++; 20416 printf(" %d", n_parent); 20417 printf("\n"); 20418 } 20419 } 20420 function_tests++; 20421 #endif 20422 20423 return(test_ret); 20424 } 20425 20426 20427 static int 20428 test_xmlGetBufferAllocationScheme(void) { 20429 int test_ret = 0; 20430 20431 int mem_base; 20432 xmlBufferAllocationScheme ret_val; 20433 20434 mem_base = xmlMemBlocks(); 20435 20436 ret_val = xmlGetBufferAllocationScheme(); 20437 desret_xmlBufferAllocationScheme(ret_val); 20438 call_tests++; 20439 xmlResetLastError(); 20440 if (mem_base != xmlMemBlocks()) { 20441 printf("Leak of %d blocks found in xmlGetBufferAllocationScheme", 20442 xmlMemBlocks() - mem_base); 20443 test_ret++; 20444 printf("\n"); 20445 } 20446 function_tests++; 20447 20448 return(test_ret); 20449 } 20450 20451 20452 static int 20453 test_xmlGetCompressMode(void) { 20454 int test_ret = 0; 20455 20456 int mem_base; 20457 int ret_val; 20458 20459 mem_base = xmlMemBlocks(); 20460 20461 ret_val = xmlGetCompressMode(); 20462 desret_int(ret_val); 20463 call_tests++; 20464 xmlResetLastError(); 20465 if (mem_base != xmlMemBlocks()) { 20466 printf("Leak of %d blocks found in xmlGetCompressMode", 20467 xmlMemBlocks() - mem_base); 20468 test_ret++; 20469 printf("\n"); 20470 } 20471 function_tests++; 20472 20473 return(test_ret); 20474 } 20475 20476 20477 static int 20478 test_xmlGetDocCompressMode(void) { 20479 int test_ret = 0; 20480 20481 int mem_base; 20482 int ret_val; 20483 xmlDoc * doc; /* the document */ 20484 int n_doc; 20485 20486 for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) { 20487 mem_base = xmlMemBlocks(); 20488 doc = gen_const_xmlDoc_ptr(n_doc, 0); 20489 20490 ret_val = xmlGetDocCompressMode((const xmlDoc *)doc); 20491 desret_int(ret_val); 20492 call_tests++; 20493 des_const_xmlDoc_ptr(n_doc, (const xmlDoc *)doc, 0); 20494 xmlResetLastError(); 20495 if (mem_base != xmlMemBlocks()) { 20496 printf("Leak of %d blocks found in xmlGetDocCompressMode", 20497 xmlMemBlocks() - mem_base); 20498 test_ret++; 20499 printf(" %d", n_doc); 20500 printf("\n"); 20501 } 20502 } 20503 function_tests++; 20504 20505 return(test_ret); 20506 } 20507 20508 20509 static int 20510 test_xmlGetIntSubset(void) { 20511 int test_ret = 0; 20512 20513 int mem_base; 20514 xmlDtdPtr ret_val; 20515 xmlDoc * doc; /* the document pointer */ 20516 int n_doc; 20517 20518 for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) { 20519 mem_base = xmlMemBlocks(); 20520 doc = gen_const_xmlDoc_ptr(n_doc, 0); 20521 20522 ret_val = xmlGetIntSubset((const xmlDoc *)doc); 20523 desret_xmlDtdPtr(ret_val); 20524 call_tests++; 20525 des_const_xmlDoc_ptr(n_doc, (const xmlDoc *)doc, 0); 20526 xmlResetLastError(); 20527 if (mem_base != xmlMemBlocks()) { 20528 printf("Leak of %d blocks found in xmlGetIntSubset", 20529 xmlMemBlocks() - mem_base); 20530 test_ret++; 20531 printf(" %d", n_doc); 20532 printf("\n"); 20533 } 20534 } 20535 function_tests++; 20536 20537 return(test_ret); 20538 } 20539 20540 20541 static int 20542 test_xmlGetLastChild(void) { 20543 int test_ret = 0; 20544 20545 int mem_base; 20546 xmlNodePtr ret_val; 20547 xmlNode * parent; /* the parent node */ 20548 int n_parent; 20549 20550 for (n_parent = 0;n_parent < gen_nb_const_xmlNode_ptr;n_parent++) { 20551 mem_base = xmlMemBlocks(); 20552 parent = gen_const_xmlNode_ptr(n_parent, 0); 20553 20554 ret_val = xmlGetLastChild((const xmlNode *)parent); 20555 desret_xmlNodePtr(ret_val); 20556 call_tests++; 20557 des_const_xmlNode_ptr(n_parent, (const xmlNode *)parent, 0); 20558 xmlResetLastError(); 20559 if (mem_base != xmlMemBlocks()) { 20560 printf("Leak of %d blocks found in xmlGetLastChild", 20561 xmlMemBlocks() - mem_base); 20562 test_ret++; 20563 printf(" %d", n_parent); 20564 printf("\n"); 20565 } 20566 } 20567 function_tests++; 20568 20569 return(test_ret); 20570 } 20571 20572 20573 static int 20574 test_xmlGetLineNo(void) { 20575 int test_ret = 0; 20576 20577 int mem_base; 20578 long ret_val; 20579 xmlNode * node; /* valid node */ 20580 int n_node; 20581 20582 for (n_node = 0;n_node < gen_nb_const_xmlNode_ptr;n_node++) { 20583 mem_base = xmlMemBlocks(); 20584 node = gen_const_xmlNode_ptr(n_node, 0); 20585 20586 ret_val = xmlGetLineNo((const xmlNode *)node); 20587 desret_long(ret_val); 20588 call_tests++; 20589 des_const_xmlNode_ptr(n_node, (const xmlNode *)node, 0); 20590 xmlResetLastError(); 20591 if (mem_base != xmlMemBlocks()) { 20592 printf("Leak of %d blocks found in xmlGetLineNo", 20593 xmlMemBlocks() - mem_base); 20594 test_ret++; 20595 printf(" %d", n_node); 20596 printf("\n"); 20597 } 20598 } 20599 function_tests++; 20600 20601 return(test_ret); 20602 } 20603 20604 20605 static int 20606 test_xmlGetNoNsProp(void) { 20607 int test_ret = 0; 20608 20609 int mem_base; 20610 xmlChar * ret_val; 20611 xmlNode * node; /* the node */ 20612 int n_node; 20613 xmlChar * name; /* the attribute name */ 20614 int n_name; 20615 20616 for (n_node = 0;n_node < gen_nb_const_xmlNode_ptr;n_node++) { 20617 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 20618 mem_base = xmlMemBlocks(); 20619 node = gen_const_xmlNode_ptr(n_node, 0); 20620 name = gen_const_xmlChar_ptr(n_name, 1); 20621 20622 ret_val = xmlGetNoNsProp((const xmlNode *)node, (const xmlChar *)name); 20623 desret_xmlChar_ptr(ret_val); 20624 call_tests++; 20625 des_const_xmlNode_ptr(n_node, (const xmlNode *)node, 0); 20626 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 20627 xmlResetLastError(); 20628 if (mem_base != xmlMemBlocks()) { 20629 printf("Leak of %d blocks found in xmlGetNoNsProp", 20630 xmlMemBlocks() - mem_base); 20631 test_ret++; 20632 printf(" %d", n_node); 20633 printf(" %d", n_name); 20634 printf("\n"); 20635 } 20636 } 20637 } 20638 function_tests++; 20639 20640 return(test_ret); 20641 } 20642 20643 20644 static int 20645 test_xmlGetNodePath(void) { 20646 int test_ret = 0; 20647 20648 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) 20649 int mem_base; 20650 xmlChar * ret_val; 20651 xmlNode * node; /* a node */ 20652 int n_node; 20653 20654 for (n_node = 0;n_node < gen_nb_const_xmlNode_ptr;n_node++) { 20655 mem_base = xmlMemBlocks(); 20656 node = gen_const_xmlNode_ptr(n_node, 0); 20657 20658 ret_val = xmlGetNodePath((const xmlNode *)node); 20659 desret_xmlChar_ptr(ret_val); 20660 call_tests++; 20661 des_const_xmlNode_ptr(n_node, (const xmlNode *)node, 0); 20662 xmlResetLastError(); 20663 if (mem_base != xmlMemBlocks()) { 20664 printf("Leak of %d blocks found in xmlGetNodePath", 20665 xmlMemBlocks() - mem_base); 20666 test_ret++; 20667 printf(" %d", n_node); 20668 printf("\n"); 20669 } 20670 } 20671 function_tests++; 20672 #endif 20673 20674 return(test_ret); 20675 } 20676 20677 20678 static int 20679 test_xmlGetNsList(void) { 20680 int test_ret = 0; 20681 20682 20683 /* missing type support */ 20684 return(test_ret); 20685 } 20686 20687 20688 static int 20689 test_xmlGetNsProp(void) { 20690 int test_ret = 0; 20691 20692 int mem_base; 20693 xmlChar * ret_val; 20694 xmlNode * node; /* the node */ 20695 int n_node; 20696 xmlChar * name; /* the attribute name */ 20697 int n_name; 20698 xmlChar * nameSpace; /* the URI of the namespace */ 20699 int n_nameSpace; 20700 20701 for (n_node = 0;n_node < gen_nb_const_xmlNode_ptr;n_node++) { 20702 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 20703 for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) { 20704 mem_base = xmlMemBlocks(); 20705 node = gen_const_xmlNode_ptr(n_node, 0); 20706 name = gen_const_xmlChar_ptr(n_name, 1); 20707 nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2); 20708 20709 ret_val = xmlGetNsProp((const xmlNode *)node, (const xmlChar *)name, (const xmlChar *)nameSpace); 20710 desret_xmlChar_ptr(ret_val); 20711 call_tests++; 20712 des_const_xmlNode_ptr(n_node, (const xmlNode *)node, 0); 20713 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 20714 des_const_xmlChar_ptr(n_nameSpace, (const xmlChar *)nameSpace, 2); 20715 xmlResetLastError(); 20716 if (mem_base != xmlMemBlocks()) { 20717 printf("Leak of %d blocks found in xmlGetNsProp", 20718 xmlMemBlocks() - mem_base); 20719 test_ret++; 20720 printf(" %d", n_node); 20721 printf(" %d", n_name); 20722 printf(" %d", n_nameSpace); 20723 printf("\n"); 20724 } 20725 } 20726 } 20727 } 20728 function_tests++; 20729 20730 return(test_ret); 20731 } 20732 20733 20734 static int 20735 test_xmlGetProp(void) { 20736 int test_ret = 0; 20737 20738 int mem_base; 20739 xmlChar * ret_val; 20740 xmlNode * node; /* the node */ 20741 int n_node; 20742 xmlChar * name; /* the attribute name */ 20743 int n_name; 20744 20745 for (n_node = 0;n_node < gen_nb_const_xmlNode_ptr;n_node++) { 20746 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 20747 mem_base = xmlMemBlocks(); 20748 node = gen_const_xmlNode_ptr(n_node, 0); 20749 name = gen_const_xmlChar_ptr(n_name, 1); 20750 20751 ret_val = xmlGetProp((const xmlNode *)node, (const xmlChar *)name); 20752 desret_xmlChar_ptr(ret_val); 20753 call_tests++; 20754 des_const_xmlNode_ptr(n_node, (const xmlNode *)node, 0); 20755 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 20756 xmlResetLastError(); 20757 if (mem_base != xmlMemBlocks()) { 20758 printf("Leak of %d blocks found in xmlGetProp", 20759 xmlMemBlocks() - mem_base); 20760 test_ret++; 20761 printf(" %d", n_node); 20762 printf(" %d", n_name); 20763 printf("\n"); 20764 } 20765 } 20766 } 20767 function_tests++; 20768 20769 return(test_ret); 20770 } 20771 20772 20773 static int 20774 test_xmlHasNsProp(void) { 20775 int test_ret = 0; 20776 20777 int mem_base; 20778 xmlAttrPtr ret_val; 20779 xmlNode * node; /* the node */ 20780 int n_node; 20781 xmlChar * name; /* the attribute name */ 20782 int n_name; 20783 xmlChar * nameSpace; /* the URI of the namespace */ 20784 int n_nameSpace; 20785 20786 for (n_node = 0;n_node < gen_nb_const_xmlNode_ptr;n_node++) { 20787 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 20788 for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) { 20789 mem_base = xmlMemBlocks(); 20790 node = gen_const_xmlNode_ptr(n_node, 0); 20791 name = gen_const_xmlChar_ptr(n_name, 1); 20792 nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2); 20793 20794 ret_val = xmlHasNsProp((const xmlNode *)node, (const xmlChar *)name, (const xmlChar *)nameSpace); 20795 desret_xmlAttrPtr(ret_val); 20796 call_tests++; 20797 des_const_xmlNode_ptr(n_node, (const xmlNode *)node, 0); 20798 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 20799 des_const_xmlChar_ptr(n_nameSpace, (const xmlChar *)nameSpace, 2); 20800 xmlResetLastError(); 20801 if (mem_base != xmlMemBlocks()) { 20802 printf("Leak of %d blocks found in xmlHasNsProp", 20803 xmlMemBlocks() - mem_base); 20804 test_ret++; 20805 printf(" %d", n_node); 20806 printf(" %d", n_name); 20807 printf(" %d", n_nameSpace); 20808 printf("\n"); 20809 } 20810 } 20811 } 20812 } 20813 function_tests++; 20814 20815 return(test_ret); 20816 } 20817 20818 20819 static int 20820 test_xmlHasProp(void) { 20821 int test_ret = 0; 20822 20823 int mem_base; 20824 xmlAttrPtr ret_val; 20825 xmlNode * node; /* the node */ 20826 int n_node; 20827 xmlChar * name; /* the attribute name */ 20828 int n_name; 20829 20830 for (n_node = 0;n_node < gen_nb_const_xmlNode_ptr;n_node++) { 20831 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 20832 mem_base = xmlMemBlocks(); 20833 node = gen_const_xmlNode_ptr(n_node, 0); 20834 name = gen_const_xmlChar_ptr(n_name, 1); 20835 20836 ret_val = xmlHasProp((const xmlNode *)node, (const xmlChar *)name); 20837 desret_xmlAttrPtr(ret_val); 20838 call_tests++; 20839 des_const_xmlNode_ptr(n_node, (const xmlNode *)node, 0); 20840 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 20841 xmlResetLastError(); 20842 if (mem_base != xmlMemBlocks()) { 20843 printf("Leak of %d blocks found in xmlHasProp", 20844 xmlMemBlocks() - mem_base); 20845 test_ret++; 20846 printf(" %d", n_node); 20847 printf(" %d", n_name); 20848 printf("\n"); 20849 } 20850 } 20851 } 20852 function_tests++; 20853 20854 return(test_ret); 20855 } 20856 20857 20858 static int 20859 test_xmlIsBlankNode(void) { 20860 int test_ret = 0; 20861 20862 int mem_base; 20863 int ret_val; 20864 xmlNode * node; /* the node */ 20865 int n_node; 20866 20867 for (n_node = 0;n_node < gen_nb_const_xmlNode_ptr;n_node++) { 20868 mem_base = xmlMemBlocks(); 20869 node = gen_const_xmlNode_ptr(n_node, 0); 20870 20871 ret_val = xmlIsBlankNode((const xmlNode *)node); 20872 desret_int(ret_val); 20873 call_tests++; 20874 des_const_xmlNode_ptr(n_node, (const xmlNode *)node, 0); 20875 xmlResetLastError(); 20876 if (mem_base != xmlMemBlocks()) { 20877 printf("Leak of %d blocks found in xmlIsBlankNode", 20878 xmlMemBlocks() - mem_base); 20879 test_ret++; 20880 printf(" %d", n_node); 20881 printf("\n"); 20882 } 20883 } 20884 function_tests++; 20885 20886 return(test_ret); 20887 } 20888 20889 20890 static int 20891 test_xmlIsXHTML(void) { 20892 int test_ret = 0; 20893 20894 int mem_base; 20895 int ret_val; 20896 xmlChar * systemID; /* the system identifier */ 20897 int n_systemID; 20898 xmlChar * publicID; /* the public identifier */ 20899 int n_publicID; 20900 20901 for (n_systemID = 0;n_systemID < gen_nb_const_xmlChar_ptr;n_systemID++) { 20902 for (n_publicID = 0;n_publicID < gen_nb_const_xmlChar_ptr;n_publicID++) { 20903 mem_base = xmlMemBlocks(); 20904 systemID = gen_const_xmlChar_ptr(n_systemID, 0); 20905 publicID = gen_const_xmlChar_ptr(n_publicID, 1); 20906 20907 ret_val = xmlIsXHTML((const xmlChar *)systemID, (const xmlChar *)publicID); 20908 desret_int(ret_val); 20909 call_tests++; 20910 des_const_xmlChar_ptr(n_systemID, (const xmlChar *)systemID, 0); 20911 des_const_xmlChar_ptr(n_publicID, (const xmlChar *)publicID, 1); 20912 xmlResetLastError(); 20913 if (mem_base != xmlMemBlocks()) { 20914 printf("Leak of %d blocks found in xmlIsXHTML", 20915 xmlMemBlocks() - mem_base); 20916 test_ret++; 20917 printf(" %d", n_systemID); 20918 printf(" %d", n_publicID); 20919 printf("\n"); 20920 } 20921 } 20922 } 20923 function_tests++; 20924 20925 return(test_ret); 20926 } 20927 20928 20929 static int 20930 test_xmlLastElementChild(void) { 20931 int test_ret = 0; 20932 20933 #if defined(LIBXML_TREE_ENABLED) 20934 int mem_base; 20935 xmlNodePtr ret_val; 20936 xmlNodePtr parent; /* the parent node */ 20937 int n_parent; 20938 20939 for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) { 20940 mem_base = xmlMemBlocks(); 20941 parent = gen_xmlNodePtr(n_parent, 0); 20942 20943 ret_val = xmlLastElementChild(parent); 20944 desret_xmlNodePtr(ret_val); 20945 call_tests++; 20946 des_xmlNodePtr(n_parent, parent, 0); 20947 xmlResetLastError(); 20948 if (mem_base != xmlMemBlocks()) { 20949 printf("Leak of %d blocks found in xmlLastElementChild", 20950 xmlMemBlocks() - mem_base); 20951 test_ret++; 20952 printf(" %d", n_parent); 20953 printf("\n"); 20954 } 20955 } 20956 function_tests++; 20957 #endif 20958 20959 return(test_ret); 20960 } 20961 20962 20963 static int 20964 test_xmlNewCDataBlock(void) { 20965 int test_ret = 0; 20966 20967 int mem_base; 20968 xmlNodePtr ret_val; 20969 xmlDocPtr doc; /* the document */ 20970 int n_doc; 20971 xmlChar * content; /* the CDATA block content content */ 20972 int n_content; 20973 int len; /* the length of the block */ 20974 int n_len; 20975 20976 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 20977 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 20978 for (n_len = 0;n_len < gen_nb_int;n_len++) { 20979 mem_base = xmlMemBlocks(); 20980 doc = gen_xmlDocPtr(n_doc, 0); 20981 content = gen_const_xmlChar_ptr(n_content, 1); 20982 len = gen_int(n_len, 2); 20983 20984 ret_val = xmlNewCDataBlock(doc, (const xmlChar *)content, len); 20985 desret_xmlNodePtr(ret_val); 20986 call_tests++; 20987 des_xmlDocPtr(n_doc, doc, 0); 20988 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1); 20989 des_int(n_len, len, 2); 20990 xmlResetLastError(); 20991 if (mem_base != xmlMemBlocks()) { 20992 printf("Leak of %d blocks found in xmlNewCDataBlock", 20993 xmlMemBlocks() - mem_base); 20994 test_ret++; 20995 printf(" %d", n_doc); 20996 printf(" %d", n_content); 20997 printf(" %d", n_len); 20998 printf("\n"); 20999 } 21000 } 21001 } 21002 } 21003 function_tests++; 21004 21005 return(test_ret); 21006 } 21007 21008 21009 static int 21010 test_xmlNewCharRef(void) { 21011 int test_ret = 0; 21012 21013 int mem_base; 21014 xmlNodePtr ret_val; 21015 xmlDocPtr doc; /* the document */ 21016 int n_doc; 21017 xmlChar * name; /* the char ref string, starting with # or "&# ... ;" */ 21018 int n_name; 21019 21020 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 21021 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 21022 mem_base = xmlMemBlocks(); 21023 doc = gen_xmlDocPtr(n_doc, 0); 21024 name = gen_const_xmlChar_ptr(n_name, 1); 21025 21026 ret_val = xmlNewCharRef(doc, (const xmlChar *)name); 21027 desret_xmlNodePtr(ret_val); 21028 call_tests++; 21029 des_xmlDocPtr(n_doc, doc, 0); 21030 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 21031 xmlResetLastError(); 21032 if (mem_base != xmlMemBlocks()) { 21033 printf("Leak of %d blocks found in xmlNewCharRef", 21034 xmlMemBlocks() - mem_base); 21035 test_ret++; 21036 printf(" %d", n_doc); 21037 printf(" %d", n_name); 21038 printf("\n"); 21039 } 21040 } 21041 } 21042 function_tests++; 21043 21044 return(test_ret); 21045 } 21046 21047 21048 static int 21049 test_xmlNewChild(void) { 21050 int test_ret = 0; 21051 21052 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 21053 #ifdef LIBXML_TREE_ENABLED 21054 int mem_base; 21055 xmlNodePtr ret_val; 21056 xmlNodePtr parent; /* the parent node */ 21057 int n_parent; 21058 xmlNsPtr ns; /* a namespace if any */ 21059 int n_ns; 21060 xmlChar * name; /* the name of the child */ 21061 int n_name; 21062 xmlChar * content; /* the XML content of the child if any. */ 21063 int n_content; 21064 21065 for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) { 21066 for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) { 21067 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 21068 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 21069 mem_base = xmlMemBlocks(); 21070 parent = gen_xmlNodePtr(n_parent, 0); 21071 ns = gen_xmlNsPtr(n_ns, 1); 21072 name = gen_const_xmlChar_ptr(n_name, 2); 21073 content = gen_const_xmlChar_ptr(n_content, 3); 21074 21075 ret_val = xmlNewChild(parent, ns, (const xmlChar *)name, (const xmlChar *)content); 21076 desret_xmlNodePtr(ret_val); 21077 call_tests++; 21078 des_xmlNodePtr(n_parent, parent, 0); 21079 des_xmlNsPtr(n_ns, ns, 1); 21080 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 21081 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3); 21082 xmlResetLastError(); 21083 if (mem_base != xmlMemBlocks()) { 21084 printf("Leak of %d blocks found in xmlNewChild", 21085 xmlMemBlocks() - mem_base); 21086 test_ret++; 21087 printf(" %d", n_parent); 21088 printf(" %d", n_ns); 21089 printf(" %d", n_name); 21090 printf(" %d", n_content); 21091 printf("\n"); 21092 } 21093 } 21094 } 21095 } 21096 } 21097 function_tests++; 21098 #endif 21099 #endif 21100 21101 return(test_ret); 21102 } 21103 21104 21105 static int 21106 test_xmlNewComment(void) { 21107 int test_ret = 0; 21108 21109 int mem_base; 21110 xmlNodePtr ret_val; 21111 xmlChar * content; /* the comment content */ 21112 int n_content; 21113 21114 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 21115 mem_base = xmlMemBlocks(); 21116 content = gen_const_xmlChar_ptr(n_content, 0); 21117 21118 ret_val = xmlNewComment((const xmlChar *)content); 21119 desret_xmlNodePtr(ret_val); 21120 call_tests++; 21121 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 0); 21122 xmlResetLastError(); 21123 if (mem_base != xmlMemBlocks()) { 21124 printf("Leak of %d blocks found in xmlNewComment", 21125 xmlMemBlocks() - mem_base); 21126 test_ret++; 21127 printf(" %d", n_content); 21128 printf("\n"); 21129 } 21130 } 21131 function_tests++; 21132 21133 return(test_ret); 21134 } 21135 21136 21137 static int 21138 test_xmlNewDoc(void) { 21139 int test_ret = 0; 21140 21141 int mem_base; 21142 xmlDocPtr ret_val; 21143 xmlChar * version; /* xmlChar string giving the version of XML "1.0" */ 21144 int n_version; 21145 21146 for (n_version = 0;n_version < gen_nb_const_xmlChar_ptr;n_version++) { 21147 mem_base = xmlMemBlocks(); 21148 version = gen_const_xmlChar_ptr(n_version, 0); 21149 21150 ret_val = xmlNewDoc((const xmlChar *)version); 21151 desret_xmlDocPtr(ret_val); 21152 call_tests++; 21153 des_const_xmlChar_ptr(n_version, (const xmlChar *)version, 0); 21154 xmlResetLastError(); 21155 if (mem_base != xmlMemBlocks()) { 21156 printf("Leak of %d blocks found in xmlNewDoc", 21157 xmlMemBlocks() - mem_base); 21158 test_ret++; 21159 printf(" %d", n_version); 21160 printf("\n"); 21161 } 21162 } 21163 function_tests++; 21164 21165 return(test_ret); 21166 } 21167 21168 21169 static int 21170 test_xmlNewDocComment(void) { 21171 int test_ret = 0; 21172 21173 int mem_base; 21174 xmlNodePtr ret_val; 21175 xmlDocPtr doc; /* the document */ 21176 int n_doc; 21177 xmlChar * content; /* the comment content */ 21178 int n_content; 21179 21180 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 21181 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 21182 mem_base = xmlMemBlocks(); 21183 doc = gen_xmlDocPtr(n_doc, 0); 21184 content = gen_const_xmlChar_ptr(n_content, 1); 21185 21186 ret_val = xmlNewDocComment(doc, (const xmlChar *)content); 21187 desret_xmlNodePtr(ret_val); 21188 call_tests++; 21189 des_xmlDocPtr(n_doc, doc, 0); 21190 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1); 21191 xmlResetLastError(); 21192 if (mem_base != xmlMemBlocks()) { 21193 printf("Leak of %d blocks found in xmlNewDocComment", 21194 xmlMemBlocks() - mem_base); 21195 test_ret++; 21196 printf(" %d", n_doc); 21197 printf(" %d", n_content); 21198 printf("\n"); 21199 } 21200 } 21201 } 21202 function_tests++; 21203 21204 return(test_ret); 21205 } 21206 21207 21208 static int 21209 test_xmlNewDocFragment(void) { 21210 int test_ret = 0; 21211 21212 #if defined(LIBXML_TREE_ENABLED) 21213 int mem_base; 21214 xmlNodePtr ret_val; 21215 xmlDocPtr doc; /* the document owning the fragment */ 21216 int n_doc; 21217 21218 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 21219 mem_base = xmlMemBlocks(); 21220 doc = gen_xmlDocPtr(n_doc, 0); 21221 21222 ret_val = xmlNewDocFragment(doc); 21223 desret_xmlNodePtr(ret_val); 21224 call_tests++; 21225 des_xmlDocPtr(n_doc, doc, 0); 21226 xmlResetLastError(); 21227 if (mem_base != xmlMemBlocks()) { 21228 printf("Leak of %d blocks found in xmlNewDocFragment", 21229 xmlMemBlocks() - mem_base); 21230 test_ret++; 21231 printf(" %d", n_doc); 21232 printf("\n"); 21233 } 21234 } 21235 function_tests++; 21236 #endif 21237 21238 return(test_ret); 21239 } 21240 21241 21242 static int 21243 test_xmlNewDocNode(void) { 21244 int test_ret = 0; 21245 21246 int mem_base; 21247 xmlNodePtr ret_val; 21248 xmlDocPtr doc; /* the document */ 21249 int n_doc; 21250 xmlNsPtr ns; /* namespace if any */ 21251 int n_ns; 21252 xmlChar * name; /* the node name */ 21253 int n_name; 21254 xmlChar * content; /* the XML text content if any */ 21255 int n_content; 21256 21257 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 21258 for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) { 21259 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 21260 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 21261 mem_base = xmlMemBlocks(); 21262 doc = gen_xmlDocPtr(n_doc, 0); 21263 ns = gen_xmlNsPtr(n_ns, 1); 21264 name = gen_const_xmlChar_ptr(n_name, 2); 21265 content = gen_const_xmlChar_ptr(n_content, 3); 21266 21267 ret_val = xmlNewDocNode(doc, ns, (const xmlChar *)name, (const xmlChar *)content); 21268 desret_xmlNodePtr(ret_val); 21269 call_tests++; 21270 des_xmlDocPtr(n_doc, doc, 0); 21271 des_xmlNsPtr(n_ns, ns, 1); 21272 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 21273 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3); 21274 xmlResetLastError(); 21275 if (mem_base != xmlMemBlocks()) { 21276 printf("Leak of %d blocks found in xmlNewDocNode", 21277 xmlMemBlocks() - mem_base); 21278 test_ret++; 21279 printf(" %d", n_doc); 21280 printf(" %d", n_ns); 21281 printf(" %d", n_name); 21282 printf(" %d", n_content); 21283 printf("\n"); 21284 } 21285 } 21286 } 21287 } 21288 } 21289 function_tests++; 21290 21291 return(test_ret); 21292 } 21293 21294 21295 static int 21296 test_xmlNewDocNodeEatName(void) { 21297 int test_ret = 0; 21298 21299 int mem_base; 21300 xmlNodePtr ret_val; 21301 xmlDocPtr doc; /* the document */ 21302 int n_doc; 21303 xmlNsPtr ns; /* namespace if any */ 21304 int n_ns; 21305 xmlChar * name; /* the node name */ 21306 int n_name; 21307 xmlChar * content; /* the XML text content if any */ 21308 int n_content; 21309 21310 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 21311 for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) { 21312 for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) { 21313 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 21314 mem_base = xmlMemBlocks(); 21315 doc = gen_xmlDocPtr(n_doc, 0); 21316 ns = gen_xmlNsPtr(n_ns, 1); 21317 name = gen_eaten_name(n_name, 2); 21318 content = gen_const_xmlChar_ptr(n_content, 3); 21319 21320 ret_val = xmlNewDocNodeEatName(doc, ns, name, (const xmlChar *)content); 21321 desret_xmlNodePtr(ret_val); 21322 call_tests++; 21323 des_xmlDocPtr(n_doc, doc, 0); 21324 des_xmlNsPtr(n_ns, ns, 1); 21325 des_eaten_name(n_name, name, 2); 21326 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3); 21327 xmlResetLastError(); 21328 if (mem_base != xmlMemBlocks()) { 21329 printf("Leak of %d blocks found in xmlNewDocNodeEatName", 21330 xmlMemBlocks() - mem_base); 21331 test_ret++; 21332 printf(" %d", n_doc); 21333 printf(" %d", n_ns); 21334 printf(" %d", n_name); 21335 printf(" %d", n_content); 21336 printf("\n"); 21337 } 21338 } 21339 } 21340 } 21341 } 21342 function_tests++; 21343 21344 return(test_ret); 21345 } 21346 21347 21348 static int 21349 test_xmlNewDocPI(void) { 21350 int test_ret = 0; 21351 21352 int mem_base; 21353 xmlNodePtr ret_val; 21354 xmlDocPtr doc; /* the target document */ 21355 int n_doc; 21356 xmlChar * name; /* the processing instruction name */ 21357 int n_name; 21358 xmlChar * content; /* the PI content */ 21359 int n_content; 21360 21361 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 21362 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 21363 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 21364 mem_base = xmlMemBlocks(); 21365 doc = gen_xmlDocPtr(n_doc, 0); 21366 name = gen_const_xmlChar_ptr(n_name, 1); 21367 content = gen_const_xmlChar_ptr(n_content, 2); 21368 21369 ret_val = xmlNewDocPI(doc, (const xmlChar *)name, (const xmlChar *)content); 21370 desret_xmlNodePtr(ret_val); 21371 call_tests++; 21372 des_xmlDocPtr(n_doc, doc, 0); 21373 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 21374 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2); 21375 xmlResetLastError(); 21376 if (mem_base != xmlMemBlocks()) { 21377 printf("Leak of %d blocks found in xmlNewDocPI", 21378 xmlMemBlocks() - mem_base); 21379 test_ret++; 21380 printf(" %d", n_doc); 21381 printf(" %d", n_name); 21382 printf(" %d", n_content); 21383 printf("\n"); 21384 } 21385 } 21386 } 21387 } 21388 function_tests++; 21389 21390 return(test_ret); 21391 } 21392 21393 21394 static int 21395 test_xmlNewDocProp(void) { 21396 int test_ret = 0; 21397 21398 int mem_base; 21399 xmlAttrPtr ret_val; 21400 xmlDocPtr doc; /* the document */ 21401 int n_doc; 21402 xmlChar * name; /* the name of the attribute */ 21403 int n_name; 21404 xmlChar * value; /* the value of the attribute */ 21405 int n_value; 21406 21407 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 21408 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 21409 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 21410 mem_base = xmlMemBlocks(); 21411 doc = gen_xmlDocPtr(n_doc, 0); 21412 name = gen_const_xmlChar_ptr(n_name, 1); 21413 value = gen_const_xmlChar_ptr(n_value, 2); 21414 21415 ret_val = xmlNewDocProp(doc, (const xmlChar *)name, (const xmlChar *)value); 21416 desret_xmlAttrPtr(ret_val); 21417 call_tests++; 21418 des_xmlDocPtr(n_doc, doc, 0); 21419 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 21420 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2); 21421 xmlResetLastError(); 21422 if (mem_base != xmlMemBlocks()) { 21423 printf("Leak of %d blocks found in xmlNewDocProp", 21424 xmlMemBlocks() - mem_base); 21425 test_ret++; 21426 printf(" %d", n_doc); 21427 printf(" %d", n_name); 21428 printf(" %d", n_value); 21429 printf("\n"); 21430 } 21431 } 21432 } 21433 } 21434 function_tests++; 21435 21436 return(test_ret); 21437 } 21438 21439 21440 static int 21441 test_xmlNewDocRawNode(void) { 21442 int test_ret = 0; 21443 21444 #if defined(LIBXML_TREE_ENABLED) 21445 #ifdef LIBXML_TREE_ENABLED 21446 int mem_base; 21447 xmlNodePtr ret_val; 21448 xmlDocPtr doc; /* the document */ 21449 int n_doc; 21450 xmlNsPtr ns; /* namespace if any */ 21451 int n_ns; 21452 xmlChar * name; /* the node name */ 21453 int n_name; 21454 xmlChar * content; /* the text content if any */ 21455 int n_content; 21456 21457 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 21458 for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) { 21459 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 21460 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 21461 mem_base = xmlMemBlocks(); 21462 doc = gen_xmlDocPtr(n_doc, 0); 21463 ns = gen_xmlNsPtr(n_ns, 1); 21464 name = gen_const_xmlChar_ptr(n_name, 2); 21465 content = gen_const_xmlChar_ptr(n_content, 3); 21466 21467 ret_val = xmlNewDocRawNode(doc, ns, (const xmlChar *)name, (const xmlChar *)content); 21468 desret_xmlNodePtr(ret_val); 21469 call_tests++; 21470 des_xmlDocPtr(n_doc, doc, 0); 21471 des_xmlNsPtr(n_ns, ns, 1); 21472 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 21473 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3); 21474 xmlResetLastError(); 21475 if (mem_base != xmlMemBlocks()) { 21476 printf("Leak of %d blocks found in xmlNewDocRawNode", 21477 xmlMemBlocks() - mem_base); 21478 test_ret++; 21479 printf(" %d", n_doc); 21480 printf(" %d", n_ns); 21481 printf(" %d", n_name); 21482 printf(" %d", n_content); 21483 printf("\n"); 21484 } 21485 } 21486 } 21487 } 21488 } 21489 function_tests++; 21490 #endif 21491 #endif 21492 21493 return(test_ret); 21494 } 21495 21496 21497 static int 21498 test_xmlNewDocText(void) { 21499 int test_ret = 0; 21500 21501 int mem_base; 21502 xmlNodePtr ret_val; 21503 xmlDoc * doc; /* the document */ 21504 int n_doc; 21505 xmlChar * content; /* the text content */ 21506 int n_content; 21507 21508 for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) { 21509 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 21510 mem_base = xmlMemBlocks(); 21511 doc = gen_const_xmlDoc_ptr(n_doc, 0); 21512 content = gen_const_xmlChar_ptr(n_content, 1); 21513 21514 ret_val = xmlNewDocText((const xmlDoc *)doc, (const xmlChar *)content); 21515 desret_xmlNodePtr(ret_val); 21516 call_tests++; 21517 des_const_xmlDoc_ptr(n_doc, (const xmlDoc *)doc, 0); 21518 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1); 21519 xmlResetLastError(); 21520 if (mem_base != xmlMemBlocks()) { 21521 printf("Leak of %d blocks found in xmlNewDocText", 21522 xmlMemBlocks() - mem_base); 21523 test_ret++; 21524 printf(" %d", n_doc); 21525 printf(" %d", n_content); 21526 printf("\n"); 21527 } 21528 } 21529 } 21530 function_tests++; 21531 21532 return(test_ret); 21533 } 21534 21535 21536 static int 21537 test_xmlNewDocTextLen(void) { 21538 int test_ret = 0; 21539 21540 int mem_base; 21541 xmlNodePtr ret_val; 21542 xmlDocPtr doc; /* the document */ 21543 int n_doc; 21544 xmlChar * content; /* the text content */ 21545 int n_content; 21546 int len; /* the text len. */ 21547 int n_len; 21548 21549 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 21550 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 21551 for (n_len = 0;n_len < gen_nb_int;n_len++) { 21552 mem_base = xmlMemBlocks(); 21553 doc = gen_xmlDocPtr(n_doc, 0); 21554 content = gen_const_xmlChar_ptr(n_content, 1); 21555 len = gen_int(n_len, 2); 21556 21557 ret_val = xmlNewDocTextLen(doc, (const xmlChar *)content, len); 21558 desret_xmlNodePtr(ret_val); 21559 call_tests++; 21560 des_xmlDocPtr(n_doc, doc, 0); 21561 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1); 21562 des_int(n_len, len, 2); 21563 xmlResetLastError(); 21564 if (mem_base != xmlMemBlocks()) { 21565 printf("Leak of %d blocks found in xmlNewDocTextLen", 21566 xmlMemBlocks() - mem_base); 21567 test_ret++; 21568 printf(" %d", n_doc); 21569 printf(" %d", n_content); 21570 printf(" %d", n_len); 21571 printf("\n"); 21572 } 21573 } 21574 } 21575 } 21576 function_tests++; 21577 21578 return(test_ret); 21579 } 21580 21581 21582 static int 21583 test_xmlNewDtd(void) { 21584 int test_ret = 0; 21585 21586 int mem_base; 21587 xmlDtdPtr ret_val; 21588 xmlDocPtr doc; /* the document pointer */ 21589 int n_doc; 21590 xmlChar * name; /* the DTD name */ 21591 int n_name; 21592 xmlChar * ExternalID; /* the external ID */ 21593 int n_ExternalID; 21594 xmlChar * SystemID; /* the system ID */ 21595 int n_SystemID; 21596 21597 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 21598 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 21599 for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) { 21600 for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) { 21601 mem_base = xmlMemBlocks(); 21602 doc = gen_xmlDocPtr(n_doc, 0); 21603 name = gen_const_xmlChar_ptr(n_name, 1); 21604 ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2); 21605 SystemID = gen_const_xmlChar_ptr(n_SystemID, 3); 21606 21607 ret_val = xmlNewDtd(doc, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID); 21608 desret_xmlDtdPtr(ret_val); 21609 call_tests++; 21610 des_xmlDocPtr(n_doc, doc, 0); 21611 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 21612 des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2); 21613 des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3); 21614 xmlResetLastError(); 21615 if (mem_base != xmlMemBlocks()) { 21616 printf("Leak of %d blocks found in xmlNewDtd", 21617 xmlMemBlocks() - mem_base); 21618 test_ret++; 21619 printf(" %d", n_doc); 21620 printf(" %d", n_name); 21621 printf(" %d", n_ExternalID); 21622 printf(" %d", n_SystemID); 21623 printf("\n"); 21624 } 21625 } 21626 } 21627 } 21628 } 21629 function_tests++; 21630 21631 return(test_ret); 21632 } 21633 21634 21635 static int 21636 test_xmlNewNode(void) { 21637 int test_ret = 0; 21638 21639 int mem_base; 21640 xmlNodePtr ret_val; 21641 xmlNsPtr ns; /* namespace if any */ 21642 int n_ns; 21643 xmlChar * name; /* the node name */ 21644 int n_name; 21645 21646 for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) { 21647 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 21648 mem_base = xmlMemBlocks(); 21649 ns = gen_xmlNsPtr(n_ns, 0); 21650 name = gen_const_xmlChar_ptr(n_name, 1); 21651 21652 ret_val = xmlNewNode(ns, (const xmlChar *)name); 21653 desret_xmlNodePtr(ret_val); 21654 call_tests++; 21655 des_xmlNsPtr(n_ns, ns, 0); 21656 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 21657 xmlResetLastError(); 21658 if (mem_base != xmlMemBlocks()) { 21659 printf("Leak of %d blocks found in xmlNewNode", 21660 xmlMemBlocks() - mem_base); 21661 test_ret++; 21662 printf(" %d", n_ns); 21663 printf(" %d", n_name); 21664 printf("\n"); 21665 } 21666 } 21667 } 21668 function_tests++; 21669 21670 return(test_ret); 21671 } 21672 21673 21674 static int 21675 test_xmlNewNodeEatName(void) { 21676 int test_ret = 0; 21677 21678 int mem_base; 21679 xmlNodePtr ret_val; 21680 xmlNsPtr ns; /* namespace if any */ 21681 int n_ns; 21682 xmlChar * name; /* the node name */ 21683 int n_name; 21684 21685 for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) { 21686 for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) { 21687 mem_base = xmlMemBlocks(); 21688 ns = gen_xmlNsPtr(n_ns, 0); 21689 name = gen_eaten_name(n_name, 1); 21690 21691 ret_val = xmlNewNodeEatName(ns, name); 21692 desret_xmlNodePtr(ret_val); 21693 call_tests++; 21694 des_xmlNsPtr(n_ns, ns, 0); 21695 des_eaten_name(n_name, name, 1); 21696 xmlResetLastError(); 21697 if (mem_base != xmlMemBlocks()) { 21698 printf("Leak of %d blocks found in xmlNewNodeEatName", 21699 xmlMemBlocks() - mem_base); 21700 test_ret++; 21701 printf(" %d", n_ns); 21702 printf(" %d", n_name); 21703 printf("\n"); 21704 } 21705 } 21706 } 21707 function_tests++; 21708 21709 return(test_ret); 21710 } 21711 21712 21713 static int 21714 test_xmlNewNs(void) { 21715 int test_ret = 0; 21716 21717 int mem_base; 21718 xmlNsPtr ret_val; 21719 xmlNodePtr node; /* the element carrying the namespace */ 21720 int n_node; 21721 xmlChar * href; /* the URI associated */ 21722 int n_href; 21723 xmlChar * prefix; /* the prefix for the namespace */ 21724 int n_prefix; 21725 21726 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 21727 for (n_href = 0;n_href < gen_nb_const_xmlChar_ptr;n_href++) { 21728 for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) { 21729 mem_base = xmlMemBlocks(); 21730 node = gen_xmlNodePtr(n_node, 0); 21731 href = gen_const_xmlChar_ptr(n_href, 1); 21732 prefix = gen_const_xmlChar_ptr(n_prefix, 2); 21733 21734 ret_val = xmlNewNs(node, (const xmlChar *)href, (const xmlChar *)prefix); 21735 if ((node == NULL) && (ret_val != NULL)) xmlFreeNs(ret_val); 21736 desret_xmlNsPtr(ret_val); 21737 call_tests++; 21738 des_xmlNodePtr(n_node, node, 0); 21739 des_const_xmlChar_ptr(n_href, (const xmlChar *)href, 1); 21740 des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2); 21741 xmlResetLastError(); 21742 if (mem_base != xmlMemBlocks()) { 21743 printf("Leak of %d blocks found in xmlNewNs", 21744 xmlMemBlocks() - mem_base); 21745 test_ret++; 21746 printf(" %d", n_node); 21747 printf(" %d", n_href); 21748 printf(" %d", n_prefix); 21749 printf("\n"); 21750 } 21751 } 21752 } 21753 } 21754 function_tests++; 21755 21756 return(test_ret); 21757 } 21758 21759 21760 static int 21761 test_xmlNewNsProp(void) { 21762 int test_ret = 0; 21763 21764 int mem_base; 21765 xmlAttrPtr ret_val; 21766 xmlNodePtr node; /* the holding node */ 21767 int n_node; 21768 xmlNsPtr ns; /* the namespace */ 21769 int n_ns; 21770 xmlChar * name; /* the name of the attribute */ 21771 int n_name; 21772 xmlChar * value; /* the value of the attribute */ 21773 int n_value; 21774 21775 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 21776 for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) { 21777 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 21778 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 21779 mem_base = xmlMemBlocks(); 21780 node = gen_xmlNodePtr(n_node, 0); 21781 ns = gen_xmlNsPtr(n_ns, 1); 21782 name = gen_const_xmlChar_ptr(n_name, 2); 21783 value = gen_const_xmlChar_ptr(n_value, 3); 21784 21785 ret_val = xmlNewNsProp(node, ns, (const xmlChar *)name, (const xmlChar *)value); 21786 desret_xmlAttrPtr(ret_val); 21787 call_tests++; 21788 des_xmlNodePtr(n_node, node, 0); 21789 des_xmlNsPtr(n_ns, ns, 1); 21790 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 21791 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3); 21792 xmlResetLastError(); 21793 if (mem_base != xmlMemBlocks()) { 21794 printf("Leak of %d blocks found in xmlNewNsProp", 21795 xmlMemBlocks() - mem_base); 21796 test_ret++; 21797 printf(" %d", n_node); 21798 printf(" %d", n_ns); 21799 printf(" %d", n_name); 21800 printf(" %d", n_value); 21801 printf("\n"); 21802 } 21803 } 21804 } 21805 } 21806 } 21807 function_tests++; 21808 21809 return(test_ret); 21810 } 21811 21812 21813 static int 21814 test_xmlNewNsPropEatName(void) { 21815 int test_ret = 0; 21816 21817 int mem_base; 21818 xmlAttrPtr ret_val; 21819 xmlNodePtr node; /* the holding node */ 21820 int n_node; 21821 xmlNsPtr ns; /* the namespace */ 21822 int n_ns; 21823 xmlChar * name; /* the name of the attribute */ 21824 int n_name; 21825 xmlChar * value; /* the value of the attribute */ 21826 int n_value; 21827 21828 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 21829 for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) { 21830 for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) { 21831 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 21832 mem_base = xmlMemBlocks(); 21833 node = gen_xmlNodePtr(n_node, 0); 21834 ns = gen_xmlNsPtr(n_ns, 1); 21835 name = gen_eaten_name(n_name, 2); 21836 value = gen_const_xmlChar_ptr(n_value, 3); 21837 21838 ret_val = xmlNewNsPropEatName(node, ns, name, (const xmlChar *)value); 21839 desret_xmlAttrPtr(ret_val); 21840 call_tests++; 21841 des_xmlNodePtr(n_node, node, 0); 21842 des_xmlNsPtr(n_ns, ns, 1); 21843 des_eaten_name(n_name, name, 2); 21844 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3); 21845 xmlResetLastError(); 21846 if (mem_base != xmlMemBlocks()) { 21847 printf("Leak of %d blocks found in xmlNewNsPropEatName", 21848 xmlMemBlocks() - mem_base); 21849 test_ret++; 21850 printf(" %d", n_node); 21851 printf(" %d", n_ns); 21852 printf(" %d", n_name); 21853 printf(" %d", n_value); 21854 printf("\n"); 21855 } 21856 } 21857 } 21858 } 21859 } 21860 function_tests++; 21861 21862 return(test_ret); 21863 } 21864 21865 21866 static int 21867 test_xmlNewPI(void) { 21868 int test_ret = 0; 21869 21870 int mem_base; 21871 xmlNodePtr ret_val; 21872 xmlChar * name; /* the processing instruction name */ 21873 int n_name; 21874 xmlChar * content; /* the PI content */ 21875 int n_content; 21876 21877 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 21878 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 21879 mem_base = xmlMemBlocks(); 21880 name = gen_const_xmlChar_ptr(n_name, 0); 21881 content = gen_const_xmlChar_ptr(n_content, 1); 21882 21883 ret_val = xmlNewPI((const xmlChar *)name, (const xmlChar *)content); 21884 desret_xmlNodePtr(ret_val); 21885 call_tests++; 21886 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0); 21887 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1); 21888 xmlResetLastError(); 21889 if (mem_base != xmlMemBlocks()) { 21890 printf("Leak of %d blocks found in xmlNewPI", 21891 xmlMemBlocks() - mem_base); 21892 test_ret++; 21893 printf(" %d", n_name); 21894 printf(" %d", n_content); 21895 printf("\n"); 21896 } 21897 } 21898 } 21899 function_tests++; 21900 21901 return(test_ret); 21902 } 21903 21904 21905 static int 21906 test_xmlNewProp(void) { 21907 int test_ret = 0; 21908 21909 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 21910 #ifdef LIBXML_TREE_ENABLED 21911 int mem_base; 21912 xmlAttrPtr ret_val; 21913 xmlNodePtr node; /* the holding node */ 21914 int n_node; 21915 xmlChar * name; /* the name of the attribute */ 21916 int n_name; 21917 xmlChar * value; /* the value of the attribute */ 21918 int n_value; 21919 21920 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 21921 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 21922 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 21923 mem_base = xmlMemBlocks(); 21924 node = gen_xmlNodePtr(n_node, 0); 21925 name = gen_const_xmlChar_ptr(n_name, 1); 21926 value = gen_const_xmlChar_ptr(n_value, 2); 21927 21928 ret_val = xmlNewProp(node, (const xmlChar *)name, (const xmlChar *)value); 21929 desret_xmlAttrPtr(ret_val); 21930 call_tests++; 21931 des_xmlNodePtr(n_node, node, 0); 21932 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 21933 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2); 21934 xmlResetLastError(); 21935 if (mem_base != xmlMemBlocks()) { 21936 printf("Leak of %d blocks found in xmlNewProp", 21937 xmlMemBlocks() - mem_base); 21938 test_ret++; 21939 printf(" %d", n_node); 21940 printf(" %d", n_name); 21941 printf(" %d", n_value); 21942 printf("\n"); 21943 } 21944 } 21945 } 21946 } 21947 function_tests++; 21948 #endif 21949 #endif 21950 21951 return(test_ret); 21952 } 21953 21954 21955 static int 21956 test_xmlNewReference(void) { 21957 int test_ret = 0; 21958 21959 int mem_base; 21960 xmlNodePtr ret_val; 21961 xmlDoc * doc; /* the document */ 21962 int n_doc; 21963 xmlChar * name; /* the reference name, or the reference string with & and ; */ 21964 int n_name; 21965 21966 for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) { 21967 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 21968 mem_base = xmlMemBlocks(); 21969 doc = gen_const_xmlDoc_ptr(n_doc, 0); 21970 name = gen_const_xmlChar_ptr(n_name, 1); 21971 21972 ret_val = xmlNewReference((const xmlDoc *)doc, (const xmlChar *)name); 21973 desret_xmlNodePtr(ret_val); 21974 call_tests++; 21975 des_const_xmlDoc_ptr(n_doc, (const xmlDoc *)doc, 0); 21976 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 21977 xmlResetLastError(); 21978 if (mem_base != xmlMemBlocks()) { 21979 printf("Leak of %d blocks found in xmlNewReference", 21980 xmlMemBlocks() - mem_base); 21981 test_ret++; 21982 printf(" %d", n_doc); 21983 printf(" %d", n_name); 21984 printf("\n"); 21985 } 21986 } 21987 } 21988 function_tests++; 21989 21990 return(test_ret); 21991 } 21992 21993 21994 static int 21995 test_xmlNewText(void) { 21996 int test_ret = 0; 21997 21998 int mem_base; 21999 xmlNodePtr ret_val; 22000 xmlChar * content; /* the text content */ 22001 int n_content; 22002 22003 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 22004 mem_base = xmlMemBlocks(); 22005 content = gen_const_xmlChar_ptr(n_content, 0); 22006 22007 ret_val = xmlNewText((const xmlChar *)content); 22008 desret_xmlNodePtr(ret_val); 22009 call_tests++; 22010 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 0); 22011 xmlResetLastError(); 22012 if (mem_base != xmlMemBlocks()) { 22013 printf("Leak of %d blocks found in xmlNewText", 22014 xmlMemBlocks() - mem_base); 22015 test_ret++; 22016 printf(" %d", n_content); 22017 printf("\n"); 22018 } 22019 } 22020 function_tests++; 22021 22022 return(test_ret); 22023 } 22024 22025 22026 static int 22027 test_xmlNewTextChild(void) { 22028 int test_ret = 0; 22029 22030 #if defined(LIBXML_TREE_ENABLED) 22031 #ifdef LIBXML_TREE_ENABLED 22032 int mem_base; 22033 xmlNodePtr ret_val; 22034 xmlNodePtr parent; /* the parent node */ 22035 int n_parent; 22036 xmlNsPtr ns; /* a namespace if any */ 22037 int n_ns; 22038 xmlChar * name; /* the name of the child */ 22039 int n_name; 22040 xmlChar * content; /* the text content of the child if any. */ 22041 int n_content; 22042 22043 for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) { 22044 for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) { 22045 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 22046 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 22047 mem_base = xmlMemBlocks(); 22048 parent = gen_xmlNodePtr(n_parent, 0); 22049 ns = gen_xmlNsPtr(n_ns, 1); 22050 name = gen_const_xmlChar_ptr(n_name, 2); 22051 content = gen_const_xmlChar_ptr(n_content, 3); 22052 22053 ret_val = xmlNewTextChild(parent, ns, (const xmlChar *)name, (const xmlChar *)content); 22054 desret_xmlNodePtr(ret_val); 22055 call_tests++; 22056 des_xmlNodePtr(n_parent, parent, 0); 22057 des_xmlNsPtr(n_ns, ns, 1); 22058 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 22059 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3); 22060 xmlResetLastError(); 22061 if (mem_base != xmlMemBlocks()) { 22062 printf("Leak of %d blocks found in xmlNewTextChild", 22063 xmlMemBlocks() - mem_base); 22064 test_ret++; 22065 printf(" %d", n_parent); 22066 printf(" %d", n_ns); 22067 printf(" %d", n_name); 22068 printf(" %d", n_content); 22069 printf("\n"); 22070 } 22071 } 22072 } 22073 } 22074 } 22075 function_tests++; 22076 #endif 22077 #endif 22078 22079 return(test_ret); 22080 } 22081 22082 22083 static int 22084 test_xmlNewTextLen(void) { 22085 int test_ret = 0; 22086 22087 int mem_base; 22088 xmlNodePtr ret_val; 22089 xmlChar * content; /* the text content */ 22090 int n_content; 22091 int len; /* the text len. */ 22092 int n_len; 22093 22094 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 22095 for (n_len = 0;n_len < gen_nb_int;n_len++) { 22096 mem_base = xmlMemBlocks(); 22097 content = gen_const_xmlChar_ptr(n_content, 0); 22098 len = gen_int(n_len, 1); 22099 22100 ret_val = xmlNewTextLen((const xmlChar *)content, len); 22101 desret_xmlNodePtr(ret_val); 22102 call_tests++; 22103 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 0); 22104 des_int(n_len, len, 1); 22105 xmlResetLastError(); 22106 if (mem_base != xmlMemBlocks()) { 22107 printf("Leak of %d blocks found in xmlNewTextLen", 22108 xmlMemBlocks() - mem_base); 22109 test_ret++; 22110 printf(" %d", n_content); 22111 printf(" %d", n_len); 22112 printf("\n"); 22113 } 22114 } 22115 } 22116 function_tests++; 22117 22118 return(test_ret); 22119 } 22120 22121 22122 static int 22123 test_xmlNextElementSibling(void) { 22124 int test_ret = 0; 22125 22126 #if defined(LIBXML_TREE_ENABLED) 22127 int mem_base; 22128 xmlNodePtr ret_val; 22129 xmlNodePtr node; /* the current node */ 22130 int n_node; 22131 22132 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 22133 mem_base = xmlMemBlocks(); 22134 node = gen_xmlNodePtr(n_node, 0); 22135 22136 ret_val = xmlNextElementSibling(node); 22137 desret_xmlNodePtr(ret_val); 22138 call_tests++; 22139 des_xmlNodePtr(n_node, node, 0); 22140 xmlResetLastError(); 22141 if (mem_base != xmlMemBlocks()) { 22142 printf("Leak of %d blocks found in xmlNextElementSibling", 22143 xmlMemBlocks() - mem_base); 22144 test_ret++; 22145 printf(" %d", n_node); 22146 printf("\n"); 22147 } 22148 } 22149 function_tests++; 22150 #endif 22151 22152 return(test_ret); 22153 } 22154 22155 22156 static int 22157 test_xmlNodeAddContent(void) { 22158 int test_ret = 0; 22159 22160 int mem_base; 22161 xmlNodePtr cur; /* the node being modified */ 22162 int n_cur; 22163 xmlChar * content; /* extra content */ 22164 int n_content; 22165 22166 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 22167 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 22168 mem_base = xmlMemBlocks(); 22169 cur = gen_xmlNodePtr(n_cur, 0); 22170 content = gen_const_xmlChar_ptr(n_content, 1); 22171 22172 xmlNodeAddContent(cur, (const xmlChar *)content); 22173 call_tests++; 22174 des_xmlNodePtr(n_cur, cur, 0); 22175 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1); 22176 xmlResetLastError(); 22177 if (mem_base != xmlMemBlocks()) { 22178 printf("Leak of %d blocks found in xmlNodeAddContent", 22179 xmlMemBlocks() - mem_base); 22180 test_ret++; 22181 printf(" %d", n_cur); 22182 printf(" %d", n_content); 22183 printf("\n"); 22184 } 22185 } 22186 } 22187 function_tests++; 22188 22189 return(test_ret); 22190 } 22191 22192 22193 static int 22194 test_xmlNodeAddContentLen(void) { 22195 int test_ret = 0; 22196 22197 int mem_base; 22198 xmlNodePtr cur; /* the node being modified */ 22199 int n_cur; 22200 xmlChar * content; /* extra content */ 22201 int n_content; 22202 int len; /* the size of @content */ 22203 int n_len; 22204 22205 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 22206 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 22207 for (n_len = 0;n_len < gen_nb_int;n_len++) { 22208 mem_base = xmlMemBlocks(); 22209 cur = gen_xmlNodePtr(n_cur, 0); 22210 content = gen_const_xmlChar_ptr(n_content, 1); 22211 len = gen_int(n_len, 2); 22212 22213 xmlNodeAddContentLen(cur, (const xmlChar *)content, len); 22214 call_tests++; 22215 des_xmlNodePtr(n_cur, cur, 0); 22216 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1); 22217 des_int(n_len, len, 2); 22218 xmlResetLastError(); 22219 if (mem_base != xmlMemBlocks()) { 22220 printf("Leak of %d blocks found in xmlNodeAddContentLen", 22221 xmlMemBlocks() - mem_base); 22222 test_ret++; 22223 printf(" %d", n_cur); 22224 printf(" %d", n_content); 22225 printf(" %d", n_len); 22226 printf("\n"); 22227 } 22228 } 22229 } 22230 } 22231 function_tests++; 22232 22233 return(test_ret); 22234 } 22235 22236 22237 static int 22238 test_xmlNodeBufGetContent(void) { 22239 int test_ret = 0; 22240 22241 int mem_base; 22242 int ret_val; 22243 xmlBufferPtr buffer; /* a buffer */ 22244 int n_buffer; 22245 xmlNode * cur; /* the node being read */ 22246 int n_cur; 22247 22248 for (n_buffer = 0;n_buffer < gen_nb_xmlBufferPtr;n_buffer++) { 22249 for (n_cur = 0;n_cur < gen_nb_const_xmlNode_ptr;n_cur++) { 22250 mem_base = xmlMemBlocks(); 22251 buffer = gen_xmlBufferPtr(n_buffer, 0); 22252 cur = gen_const_xmlNode_ptr(n_cur, 1); 22253 22254 ret_val = xmlNodeBufGetContent(buffer, (const xmlNode *)cur); 22255 desret_int(ret_val); 22256 call_tests++; 22257 des_xmlBufferPtr(n_buffer, buffer, 0); 22258 des_const_xmlNode_ptr(n_cur, (const xmlNode *)cur, 1); 22259 xmlResetLastError(); 22260 if (mem_base != xmlMemBlocks()) { 22261 printf("Leak of %d blocks found in xmlNodeBufGetContent", 22262 xmlMemBlocks() - mem_base); 22263 test_ret++; 22264 printf(" %d", n_buffer); 22265 printf(" %d", n_cur); 22266 printf("\n"); 22267 } 22268 } 22269 } 22270 function_tests++; 22271 22272 return(test_ret); 22273 } 22274 22275 22276 static int 22277 test_xmlNodeDump(void) { 22278 int test_ret = 0; 22279 22280 #if defined(LIBXML_OUTPUT_ENABLED) 22281 int mem_base; 22282 int ret_val; 22283 xmlBufferPtr buf; /* the XML buffer output */ 22284 int n_buf; 22285 xmlDocPtr doc; /* the document */ 22286 int n_doc; 22287 xmlNodePtr cur; /* the current node */ 22288 int n_cur; 22289 int level; /* the imbrication level for indenting */ 22290 int n_level; 22291 int format; /* is formatting allowed */ 22292 int n_format; 22293 22294 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 22295 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 22296 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 22297 for (n_level = 0;n_level < gen_nb_int;n_level++) { 22298 for (n_format = 0;n_format < gen_nb_int;n_format++) { 22299 mem_base = xmlMemBlocks(); 22300 buf = gen_xmlBufferPtr(n_buf, 0); 22301 doc = gen_xmlDocPtr(n_doc, 1); 22302 cur = gen_xmlNodePtr(n_cur, 2); 22303 level = gen_int(n_level, 3); 22304 format = gen_int(n_format, 4); 22305 22306 ret_val = xmlNodeDump(buf, doc, cur, level, format); 22307 desret_int(ret_val); 22308 call_tests++; 22309 des_xmlBufferPtr(n_buf, buf, 0); 22310 des_xmlDocPtr(n_doc, doc, 1); 22311 des_xmlNodePtr(n_cur, cur, 2); 22312 des_int(n_level, level, 3); 22313 des_int(n_format, format, 4); 22314 xmlResetLastError(); 22315 if (mem_base != xmlMemBlocks()) { 22316 printf("Leak of %d blocks found in xmlNodeDump", 22317 xmlMemBlocks() - mem_base); 22318 test_ret++; 22319 printf(" %d", n_buf); 22320 printf(" %d", n_doc); 22321 printf(" %d", n_cur); 22322 printf(" %d", n_level); 22323 printf(" %d", n_format); 22324 printf("\n"); 22325 } 22326 } 22327 } 22328 } 22329 } 22330 } 22331 function_tests++; 22332 #endif 22333 22334 return(test_ret); 22335 } 22336 22337 22338 static int 22339 test_xmlNodeDumpOutput(void) { 22340 int test_ret = 0; 22341 22342 #if defined(LIBXML_OUTPUT_ENABLED) 22343 int mem_base; 22344 xmlOutputBufferPtr buf; /* the XML buffer output */ 22345 int n_buf; 22346 xmlDocPtr doc; /* the document */ 22347 int n_doc; 22348 xmlNodePtr cur; /* the current node */ 22349 int n_cur; 22350 int level; /* the imbrication level for indenting */ 22351 int n_level; 22352 int format; /* is formatting allowed */ 22353 int n_format; 22354 char * encoding; /* an optional encoding string */ 22355 int n_encoding; 22356 22357 for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) { 22358 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 22359 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 22360 for (n_level = 0;n_level < gen_nb_int;n_level++) { 22361 for (n_format = 0;n_format < gen_nb_int;n_format++) { 22362 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 22363 mem_base = xmlMemBlocks(); 22364 buf = gen_xmlOutputBufferPtr(n_buf, 0); 22365 doc = gen_xmlDocPtr(n_doc, 1); 22366 cur = gen_xmlNodePtr(n_cur, 2); 22367 level = gen_int(n_level, 3); 22368 format = gen_int(n_format, 4); 22369 encoding = gen_const_char_ptr(n_encoding, 5); 22370 22371 xmlNodeDumpOutput(buf, doc, cur, level, format, (const char *)encoding); 22372 call_tests++; 22373 des_xmlOutputBufferPtr(n_buf, buf, 0); 22374 des_xmlDocPtr(n_doc, doc, 1); 22375 des_xmlNodePtr(n_cur, cur, 2); 22376 des_int(n_level, level, 3); 22377 des_int(n_format, format, 4); 22378 des_const_char_ptr(n_encoding, (const char *)encoding, 5); 22379 xmlResetLastError(); 22380 if (mem_base != xmlMemBlocks()) { 22381 printf("Leak of %d blocks found in xmlNodeDumpOutput", 22382 xmlMemBlocks() - mem_base); 22383 test_ret++; 22384 printf(" %d", n_buf); 22385 printf(" %d", n_doc); 22386 printf(" %d", n_cur); 22387 printf(" %d", n_level); 22388 printf(" %d", n_format); 22389 printf(" %d", n_encoding); 22390 printf("\n"); 22391 } 22392 } 22393 } 22394 } 22395 } 22396 } 22397 } 22398 function_tests++; 22399 #endif 22400 22401 return(test_ret); 22402 } 22403 22404 22405 static int 22406 test_xmlNodeGetBase(void) { 22407 int test_ret = 0; 22408 22409 int mem_base; 22410 xmlChar * ret_val; 22411 xmlDoc * doc; /* the document the node pertains to */ 22412 int n_doc; 22413 xmlNode * cur; /* the node being checked */ 22414 int n_cur; 22415 22416 for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) { 22417 for (n_cur = 0;n_cur < gen_nb_const_xmlNode_ptr;n_cur++) { 22418 mem_base = xmlMemBlocks(); 22419 doc = gen_const_xmlDoc_ptr(n_doc, 0); 22420 cur = gen_const_xmlNode_ptr(n_cur, 1); 22421 22422 ret_val = xmlNodeGetBase((const xmlDoc *)doc, (const xmlNode *)cur); 22423 desret_xmlChar_ptr(ret_val); 22424 call_tests++; 22425 des_const_xmlDoc_ptr(n_doc, (const xmlDoc *)doc, 0); 22426 des_const_xmlNode_ptr(n_cur, (const xmlNode *)cur, 1); 22427 xmlResetLastError(); 22428 if (mem_base != xmlMemBlocks()) { 22429 printf("Leak of %d blocks found in xmlNodeGetBase", 22430 xmlMemBlocks() - mem_base); 22431 test_ret++; 22432 printf(" %d", n_doc); 22433 printf(" %d", n_cur); 22434 printf("\n"); 22435 } 22436 } 22437 } 22438 function_tests++; 22439 22440 return(test_ret); 22441 } 22442 22443 22444 static int 22445 test_xmlNodeGetContent(void) { 22446 int test_ret = 0; 22447 22448 int mem_base; 22449 xmlChar * ret_val; 22450 xmlNode * cur; /* the node being read */ 22451 int n_cur; 22452 22453 for (n_cur = 0;n_cur < gen_nb_const_xmlNode_ptr;n_cur++) { 22454 mem_base = xmlMemBlocks(); 22455 cur = gen_const_xmlNode_ptr(n_cur, 0); 22456 22457 ret_val = xmlNodeGetContent((const xmlNode *)cur); 22458 desret_xmlChar_ptr(ret_val); 22459 call_tests++; 22460 des_const_xmlNode_ptr(n_cur, (const xmlNode *)cur, 0); 22461 xmlResetLastError(); 22462 if (mem_base != xmlMemBlocks()) { 22463 printf("Leak of %d blocks found in xmlNodeGetContent", 22464 xmlMemBlocks() - mem_base); 22465 test_ret++; 22466 printf(" %d", n_cur); 22467 printf("\n"); 22468 } 22469 } 22470 function_tests++; 22471 22472 return(test_ret); 22473 } 22474 22475 22476 static int 22477 test_xmlNodeGetLang(void) { 22478 int test_ret = 0; 22479 22480 int mem_base; 22481 xmlChar * ret_val; 22482 xmlNode * cur; /* the node being checked */ 22483 int n_cur; 22484 22485 for (n_cur = 0;n_cur < gen_nb_const_xmlNode_ptr;n_cur++) { 22486 mem_base = xmlMemBlocks(); 22487 cur = gen_const_xmlNode_ptr(n_cur, 0); 22488 22489 ret_val = xmlNodeGetLang((const xmlNode *)cur); 22490 desret_xmlChar_ptr(ret_val); 22491 call_tests++; 22492 des_const_xmlNode_ptr(n_cur, (const xmlNode *)cur, 0); 22493 xmlResetLastError(); 22494 if (mem_base != xmlMemBlocks()) { 22495 printf("Leak of %d blocks found in xmlNodeGetLang", 22496 xmlMemBlocks() - mem_base); 22497 test_ret++; 22498 printf(" %d", n_cur); 22499 printf("\n"); 22500 } 22501 } 22502 function_tests++; 22503 22504 return(test_ret); 22505 } 22506 22507 22508 static int 22509 test_xmlNodeGetSpacePreserve(void) { 22510 int test_ret = 0; 22511 22512 int mem_base; 22513 int ret_val; 22514 xmlNode * cur; /* the node being checked */ 22515 int n_cur; 22516 22517 for (n_cur = 0;n_cur < gen_nb_const_xmlNode_ptr;n_cur++) { 22518 mem_base = xmlMemBlocks(); 22519 cur = gen_const_xmlNode_ptr(n_cur, 0); 22520 22521 ret_val = xmlNodeGetSpacePreserve((const xmlNode *)cur); 22522 desret_int(ret_val); 22523 call_tests++; 22524 des_const_xmlNode_ptr(n_cur, (const xmlNode *)cur, 0); 22525 xmlResetLastError(); 22526 if (mem_base != xmlMemBlocks()) { 22527 printf("Leak of %d blocks found in xmlNodeGetSpacePreserve", 22528 xmlMemBlocks() - mem_base); 22529 test_ret++; 22530 printf(" %d", n_cur); 22531 printf("\n"); 22532 } 22533 } 22534 function_tests++; 22535 22536 return(test_ret); 22537 } 22538 22539 22540 static int 22541 test_xmlNodeIsText(void) { 22542 int test_ret = 0; 22543 22544 int mem_base; 22545 int ret_val; 22546 xmlNode * node; /* the node */ 22547 int n_node; 22548 22549 for (n_node = 0;n_node < gen_nb_const_xmlNode_ptr;n_node++) { 22550 mem_base = xmlMemBlocks(); 22551 node = gen_const_xmlNode_ptr(n_node, 0); 22552 22553 ret_val = xmlNodeIsText((const xmlNode *)node); 22554 desret_int(ret_val); 22555 call_tests++; 22556 des_const_xmlNode_ptr(n_node, (const xmlNode *)node, 0); 22557 xmlResetLastError(); 22558 if (mem_base != xmlMemBlocks()) { 22559 printf("Leak of %d blocks found in xmlNodeIsText", 22560 xmlMemBlocks() - mem_base); 22561 test_ret++; 22562 printf(" %d", n_node); 22563 printf("\n"); 22564 } 22565 } 22566 function_tests++; 22567 22568 return(test_ret); 22569 } 22570 22571 22572 static int 22573 test_xmlNodeListGetRawString(void) { 22574 int test_ret = 0; 22575 22576 #if defined(LIBXML_TREE_ENABLED) 22577 int mem_base; 22578 xmlChar * ret_val; 22579 xmlDoc * doc; /* the document */ 22580 int n_doc; 22581 xmlNode * list; /* a Node list */ 22582 int n_list; 22583 int inLine; /* should we replace entity contents or show their external form */ 22584 int n_inLine; 22585 22586 for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) { 22587 for (n_list = 0;n_list < gen_nb_const_xmlNode_ptr;n_list++) { 22588 for (n_inLine = 0;n_inLine < gen_nb_int;n_inLine++) { 22589 mem_base = xmlMemBlocks(); 22590 doc = gen_const_xmlDoc_ptr(n_doc, 0); 22591 list = gen_const_xmlNode_ptr(n_list, 1); 22592 inLine = gen_int(n_inLine, 2); 22593 22594 ret_val = xmlNodeListGetRawString((const xmlDoc *)doc, (const xmlNode *)list, inLine); 22595 desret_xmlChar_ptr(ret_val); 22596 call_tests++; 22597 des_const_xmlDoc_ptr(n_doc, (const xmlDoc *)doc, 0); 22598 des_const_xmlNode_ptr(n_list, (const xmlNode *)list, 1); 22599 des_int(n_inLine, inLine, 2); 22600 xmlResetLastError(); 22601 if (mem_base != xmlMemBlocks()) { 22602 printf("Leak of %d blocks found in xmlNodeListGetRawString", 22603 xmlMemBlocks() - mem_base); 22604 test_ret++; 22605 printf(" %d", n_doc); 22606 printf(" %d", n_list); 22607 printf(" %d", n_inLine); 22608 printf("\n"); 22609 } 22610 } 22611 } 22612 } 22613 function_tests++; 22614 #endif 22615 22616 return(test_ret); 22617 } 22618 22619 22620 static int 22621 test_xmlNodeListGetString(void) { 22622 int test_ret = 0; 22623 22624 int mem_base; 22625 xmlChar * ret_val; 22626 xmlDocPtr doc; /* the document */ 22627 int n_doc; 22628 xmlNode * list; /* a Node list */ 22629 int n_list; 22630 int inLine; /* should we replace entity contents or show their external form */ 22631 int n_inLine; 22632 22633 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 22634 for (n_list = 0;n_list < gen_nb_const_xmlNode_ptr;n_list++) { 22635 for (n_inLine = 0;n_inLine < gen_nb_int;n_inLine++) { 22636 mem_base = xmlMemBlocks(); 22637 doc = gen_xmlDocPtr(n_doc, 0); 22638 list = gen_const_xmlNode_ptr(n_list, 1); 22639 inLine = gen_int(n_inLine, 2); 22640 22641 ret_val = xmlNodeListGetString(doc, (const xmlNode *)list, inLine); 22642 desret_xmlChar_ptr(ret_val); 22643 call_tests++; 22644 des_xmlDocPtr(n_doc, doc, 0); 22645 des_const_xmlNode_ptr(n_list, (const xmlNode *)list, 1); 22646 des_int(n_inLine, inLine, 2); 22647 xmlResetLastError(); 22648 if (mem_base != xmlMemBlocks()) { 22649 printf("Leak of %d blocks found in xmlNodeListGetString", 22650 xmlMemBlocks() - mem_base); 22651 test_ret++; 22652 printf(" %d", n_doc); 22653 printf(" %d", n_list); 22654 printf(" %d", n_inLine); 22655 printf("\n"); 22656 } 22657 } 22658 } 22659 } 22660 function_tests++; 22661 22662 return(test_ret); 22663 } 22664 22665 22666 static int 22667 test_xmlNodeSetBase(void) { 22668 int test_ret = 0; 22669 22670 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) 22671 int mem_base; 22672 xmlNodePtr cur; /* the node being changed */ 22673 int n_cur; 22674 xmlChar * uri; /* the new base URI */ 22675 int n_uri; 22676 22677 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 22678 for (n_uri = 0;n_uri < gen_nb_const_xmlChar_ptr;n_uri++) { 22679 mem_base = xmlMemBlocks(); 22680 cur = gen_xmlNodePtr(n_cur, 0); 22681 uri = gen_const_xmlChar_ptr(n_uri, 1); 22682 22683 xmlNodeSetBase(cur, (const xmlChar *)uri); 22684 call_tests++; 22685 des_xmlNodePtr(n_cur, cur, 0); 22686 des_const_xmlChar_ptr(n_uri, (const xmlChar *)uri, 1); 22687 xmlResetLastError(); 22688 if (mem_base != xmlMemBlocks()) { 22689 printf("Leak of %d blocks found in xmlNodeSetBase", 22690 xmlMemBlocks() - mem_base); 22691 test_ret++; 22692 printf(" %d", n_cur); 22693 printf(" %d", n_uri); 22694 printf("\n"); 22695 } 22696 } 22697 } 22698 function_tests++; 22699 #endif 22700 22701 return(test_ret); 22702 } 22703 22704 22705 static int 22706 test_xmlNodeSetContent(void) { 22707 int test_ret = 0; 22708 22709 int mem_base; 22710 xmlNodePtr cur; /* the node being modified */ 22711 int n_cur; 22712 xmlChar * content; /* the new value of the content */ 22713 int n_content; 22714 22715 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 22716 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 22717 mem_base = xmlMemBlocks(); 22718 cur = gen_xmlNodePtr(n_cur, 0); 22719 content = gen_const_xmlChar_ptr(n_content, 1); 22720 22721 xmlNodeSetContent(cur, (const xmlChar *)content); 22722 call_tests++; 22723 des_xmlNodePtr(n_cur, cur, 0); 22724 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1); 22725 xmlResetLastError(); 22726 if (mem_base != xmlMemBlocks()) { 22727 printf("Leak of %d blocks found in xmlNodeSetContent", 22728 xmlMemBlocks() - mem_base); 22729 test_ret++; 22730 printf(" %d", n_cur); 22731 printf(" %d", n_content); 22732 printf("\n"); 22733 } 22734 } 22735 } 22736 function_tests++; 22737 22738 return(test_ret); 22739 } 22740 22741 22742 static int 22743 test_xmlNodeSetContentLen(void) { 22744 int test_ret = 0; 22745 22746 #if defined(LIBXML_TREE_ENABLED) 22747 int mem_base; 22748 xmlNodePtr cur; /* the node being modified */ 22749 int n_cur; 22750 xmlChar * content; /* the new value of the content */ 22751 int n_content; 22752 int len; /* the size of @content */ 22753 int n_len; 22754 22755 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 22756 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 22757 for (n_len = 0;n_len < gen_nb_int;n_len++) { 22758 mem_base = xmlMemBlocks(); 22759 cur = gen_xmlNodePtr(n_cur, 0); 22760 content = gen_const_xmlChar_ptr(n_content, 1); 22761 len = gen_int(n_len, 2); 22762 22763 xmlNodeSetContentLen(cur, (const xmlChar *)content, len); 22764 call_tests++; 22765 des_xmlNodePtr(n_cur, cur, 0); 22766 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1); 22767 des_int(n_len, len, 2); 22768 xmlResetLastError(); 22769 if (mem_base != xmlMemBlocks()) { 22770 printf("Leak of %d blocks found in xmlNodeSetContentLen", 22771 xmlMemBlocks() - mem_base); 22772 test_ret++; 22773 printf(" %d", n_cur); 22774 printf(" %d", n_content); 22775 printf(" %d", n_len); 22776 printf("\n"); 22777 } 22778 } 22779 } 22780 } 22781 function_tests++; 22782 #endif 22783 22784 return(test_ret); 22785 } 22786 22787 22788 static int 22789 test_xmlNodeSetLang(void) { 22790 int test_ret = 0; 22791 22792 #if defined(LIBXML_TREE_ENABLED) 22793 int mem_base; 22794 xmlNodePtr cur; /* the node being changed */ 22795 int n_cur; 22796 xmlChar * lang; /* the language description */ 22797 int n_lang; 22798 22799 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 22800 for (n_lang = 0;n_lang < gen_nb_const_xmlChar_ptr;n_lang++) { 22801 mem_base = xmlMemBlocks(); 22802 cur = gen_xmlNodePtr(n_cur, 0); 22803 lang = gen_const_xmlChar_ptr(n_lang, 1); 22804 22805 xmlNodeSetLang(cur, (const xmlChar *)lang); 22806 call_tests++; 22807 des_xmlNodePtr(n_cur, cur, 0); 22808 des_const_xmlChar_ptr(n_lang, (const xmlChar *)lang, 1); 22809 xmlResetLastError(); 22810 if (mem_base != xmlMemBlocks()) { 22811 printf("Leak of %d blocks found in xmlNodeSetLang", 22812 xmlMemBlocks() - mem_base); 22813 test_ret++; 22814 printf(" %d", n_cur); 22815 printf(" %d", n_lang); 22816 printf("\n"); 22817 } 22818 } 22819 } 22820 function_tests++; 22821 #endif 22822 22823 return(test_ret); 22824 } 22825 22826 22827 static int 22828 test_xmlNodeSetName(void) { 22829 int test_ret = 0; 22830 22831 #if defined(LIBXML_TREE_ENABLED) 22832 int mem_base; 22833 xmlNodePtr cur; /* the node being changed */ 22834 int n_cur; 22835 xmlChar * name; /* the new tag name */ 22836 int n_name; 22837 22838 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 22839 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 22840 mem_base = xmlMemBlocks(); 22841 cur = gen_xmlNodePtr(n_cur, 0); 22842 name = gen_const_xmlChar_ptr(n_name, 1); 22843 22844 xmlNodeSetName(cur, (const xmlChar *)name); 22845 call_tests++; 22846 des_xmlNodePtr(n_cur, cur, 0); 22847 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 22848 xmlResetLastError(); 22849 if (mem_base != xmlMemBlocks()) { 22850 printf("Leak of %d blocks found in xmlNodeSetName", 22851 xmlMemBlocks() - mem_base); 22852 test_ret++; 22853 printf(" %d", n_cur); 22854 printf(" %d", n_name); 22855 printf("\n"); 22856 } 22857 } 22858 } 22859 function_tests++; 22860 #endif 22861 22862 return(test_ret); 22863 } 22864 22865 22866 static int 22867 test_xmlNodeSetSpacePreserve(void) { 22868 int test_ret = 0; 22869 22870 #if defined(LIBXML_TREE_ENABLED) 22871 int mem_base; 22872 xmlNodePtr cur; /* the node being changed */ 22873 int n_cur; 22874 int val; /* the xml:space value ("0": default, 1: "preserve") */ 22875 int n_val; 22876 22877 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 22878 for (n_val = 0;n_val < gen_nb_int;n_val++) { 22879 mem_base = xmlMemBlocks(); 22880 cur = gen_xmlNodePtr(n_cur, 0); 22881 val = gen_int(n_val, 1); 22882 22883 xmlNodeSetSpacePreserve(cur, val); 22884 call_tests++; 22885 des_xmlNodePtr(n_cur, cur, 0); 22886 des_int(n_val, val, 1); 22887 xmlResetLastError(); 22888 if (mem_base != xmlMemBlocks()) { 22889 printf("Leak of %d blocks found in xmlNodeSetSpacePreserve", 22890 xmlMemBlocks() - mem_base); 22891 test_ret++; 22892 printf(" %d", n_cur); 22893 printf(" %d", n_val); 22894 printf("\n"); 22895 } 22896 } 22897 } 22898 function_tests++; 22899 #endif 22900 22901 return(test_ret); 22902 } 22903 22904 22905 static int 22906 test_xmlPreviousElementSibling(void) { 22907 int test_ret = 0; 22908 22909 #if defined(LIBXML_TREE_ENABLED) 22910 int mem_base; 22911 xmlNodePtr ret_val; 22912 xmlNodePtr node; /* the current node */ 22913 int n_node; 22914 22915 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 22916 mem_base = xmlMemBlocks(); 22917 node = gen_xmlNodePtr(n_node, 0); 22918 22919 ret_val = xmlPreviousElementSibling(node); 22920 desret_xmlNodePtr(ret_val); 22921 call_tests++; 22922 des_xmlNodePtr(n_node, node, 0); 22923 xmlResetLastError(); 22924 if (mem_base != xmlMemBlocks()) { 22925 printf("Leak of %d blocks found in xmlPreviousElementSibling", 22926 xmlMemBlocks() - mem_base); 22927 test_ret++; 22928 printf(" %d", n_node); 22929 printf("\n"); 22930 } 22931 } 22932 function_tests++; 22933 #endif 22934 22935 return(test_ret); 22936 } 22937 22938 22939 static int 22940 test_xmlReconciliateNs(void) { 22941 int test_ret = 0; 22942 22943 #if defined(LIBXML_TREE_ENABLED) 22944 #ifdef LIBXML_TREE_ENABLED 22945 int mem_base; 22946 int ret_val; 22947 xmlDocPtr doc; /* the document */ 22948 int n_doc; 22949 xmlNodePtr tree; /* a node defining the subtree to reconciliate */ 22950 int n_tree; 22951 22952 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 22953 for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) { 22954 mem_base = xmlMemBlocks(); 22955 doc = gen_xmlDocPtr(n_doc, 0); 22956 tree = gen_xmlNodePtr(n_tree, 1); 22957 22958 ret_val = xmlReconciliateNs(doc, tree); 22959 desret_int(ret_val); 22960 call_tests++; 22961 des_xmlDocPtr(n_doc, doc, 0); 22962 des_xmlNodePtr(n_tree, tree, 1); 22963 xmlResetLastError(); 22964 if (mem_base != xmlMemBlocks()) { 22965 printf("Leak of %d blocks found in xmlReconciliateNs", 22966 xmlMemBlocks() - mem_base); 22967 test_ret++; 22968 printf(" %d", n_doc); 22969 printf(" %d", n_tree); 22970 printf("\n"); 22971 } 22972 } 22973 } 22974 function_tests++; 22975 #endif 22976 #endif 22977 22978 return(test_ret); 22979 } 22980 22981 22982 static int 22983 test_xmlRemoveProp(void) { 22984 int test_ret = 0; 22985 22986 int mem_base; 22987 int ret_val; 22988 xmlAttrPtr cur; /* an attribute */ 22989 int n_cur; 22990 22991 for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) { 22992 mem_base = xmlMemBlocks(); 22993 cur = gen_xmlAttrPtr(n_cur, 0); 22994 22995 ret_val = xmlRemoveProp(cur); 22996 cur = NULL; 22997 desret_int(ret_val); 22998 call_tests++; 22999 des_xmlAttrPtr(n_cur, cur, 0); 23000 xmlResetLastError(); 23001 if (mem_base != xmlMemBlocks()) { 23002 printf("Leak of %d blocks found in xmlRemoveProp", 23003 xmlMemBlocks() - mem_base); 23004 test_ret++; 23005 printf(" %d", n_cur); 23006 printf("\n"); 23007 } 23008 } 23009 function_tests++; 23010 23011 return(test_ret); 23012 } 23013 23014 23015 static int 23016 test_xmlReplaceNode(void) { 23017 int test_ret = 0; 23018 23019 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) 23020 int mem_base; 23021 xmlNodePtr ret_val; 23022 xmlNodePtr old; /* the old node */ 23023 int n_old; 23024 xmlNodePtr cur; /* the node */ 23025 int n_cur; 23026 23027 for (n_old = 0;n_old < gen_nb_xmlNodePtr;n_old++) { 23028 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) { 23029 mem_base = xmlMemBlocks(); 23030 old = gen_xmlNodePtr(n_old, 0); 23031 cur = gen_xmlNodePtr_in(n_cur, 1); 23032 23033 ret_val = xmlReplaceNode(old, cur); 23034 if (cur != NULL) { 23035 xmlUnlinkNode(cur); 23036 xmlFreeNode(cur) ; cur = NULL ; } 23037 if (old != NULL) { 23038 xmlUnlinkNode(old); 23039 xmlFreeNode(old) ; old = NULL ; } 23040 ret_val = NULL; 23041 desret_xmlNodePtr(ret_val); 23042 call_tests++; 23043 des_xmlNodePtr(n_old, old, 0); 23044 des_xmlNodePtr_in(n_cur, cur, 1); 23045 xmlResetLastError(); 23046 if (mem_base != xmlMemBlocks()) { 23047 printf("Leak of %d blocks found in xmlReplaceNode", 23048 xmlMemBlocks() - mem_base); 23049 test_ret++; 23050 printf(" %d", n_old); 23051 printf(" %d", n_cur); 23052 printf("\n"); 23053 } 23054 } 23055 } 23056 function_tests++; 23057 #endif 23058 23059 return(test_ret); 23060 } 23061 23062 23063 static int 23064 test_xmlSaveFile(void) { 23065 int test_ret = 0; 23066 23067 #if defined(LIBXML_OUTPUT_ENABLED) 23068 int mem_base; 23069 int ret_val; 23070 const char * filename; /* the filename (or URL) */ 23071 int n_filename; 23072 xmlDocPtr cur; /* the document */ 23073 int n_cur; 23074 23075 for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) { 23076 for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) { 23077 mem_base = xmlMemBlocks(); 23078 filename = gen_fileoutput(n_filename, 0); 23079 cur = gen_xmlDocPtr(n_cur, 1); 23080 23081 ret_val = xmlSaveFile(filename, cur); 23082 desret_int(ret_val); 23083 call_tests++; 23084 des_fileoutput(n_filename, filename, 0); 23085 des_xmlDocPtr(n_cur, cur, 1); 23086 xmlResetLastError(); 23087 if (mem_base != xmlMemBlocks()) { 23088 printf("Leak of %d blocks found in xmlSaveFile", 23089 xmlMemBlocks() - mem_base); 23090 test_ret++; 23091 printf(" %d", n_filename); 23092 printf(" %d", n_cur); 23093 printf("\n"); 23094 } 23095 } 23096 } 23097 function_tests++; 23098 #endif 23099 23100 return(test_ret); 23101 } 23102 23103 23104 static int 23105 test_xmlSaveFileEnc(void) { 23106 int test_ret = 0; 23107 23108 #if defined(LIBXML_OUTPUT_ENABLED) 23109 int mem_base; 23110 int ret_val; 23111 const char * filename; /* the filename (or URL) */ 23112 int n_filename; 23113 xmlDocPtr cur; /* the document */ 23114 int n_cur; 23115 char * encoding; /* the name of an encoding (or NULL) */ 23116 int n_encoding; 23117 23118 for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) { 23119 for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) { 23120 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 23121 mem_base = xmlMemBlocks(); 23122 filename = gen_fileoutput(n_filename, 0); 23123 cur = gen_xmlDocPtr(n_cur, 1); 23124 encoding = gen_const_char_ptr(n_encoding, 2); 23125 23126 ret_val = xmlSaveFileEnc(filename, cur, (const char *)encoding); 23127 desret_int(ret_val); 23128 call_tests++; 23129 des_fileoutput(n_filename, filename, 0); 23130 des_xmlDocPtr(n_cur, cur, 1); 23131 des_const_char_ptr(n_encoding, (const char *)encoding, 2); 23132 xmlResetLastError(); 23133 if (mem_base != xmlMemBlocks()) { 23134 printf("Leak of %d blocks found in xmlSaveFileEnc", 23135 xmlMemBlocks() - mem_base); 23136 test_ret++; 23137 printf(" %d", n_filename); 23138 printf(" %d", n_cur); 23139 printf(" %d", n_encoding); 23140 printf("\n"); 23141 } 23142 } 23143 } 23144 } 23145 function_tests++; 23146 #endif 23147 23148 return(test_ret); 23149 } 23150 23151 23152 static int 23153 test_xmlSaveFileTo(void) { 23154 int test_ret = 0; 23155 23156 #if defined(LIBXML_OUTPUT_ENABLED) 23157 int mem_base; 23158 int ret_val; 23159 xmlOutputBufferPtr buf; /* an output I/O buffer */ 23160 int n_buf; 23161 xmlDocPtr cur; /* the document */ 23162 int n_cur; 23163 char * encoding; /* the encoding if any assuming the I/O layer handles the trancoding */ 23164 int n_encoding; 23165 23166 for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) { 23167 for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) { 23168 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 23169 mem_base = xmlMemBlocks(); 23170 buf = gen_xmlOutputBufferPtr(n_buf, 0); 23171 cur = gen_xmlDocPtr(n_cur, 1); 23172 encoding = gen_const_char_ptr(n_encoding, 2); 23173 23174 ret_val = xmlSaveFileTo(buf, cur, (const char *)encoding); 23175 buf = NULL; 23176 desret_int(ret_val); 23177 call_tests++; 23178 des_xmlOutputBufferPtr(n_buf, buf, 0); 23179 des_xmlDocPtr(n_cur, cur, 1); 23180 des_const_char_ptr(n_encoding, (const char *)encoding, 2); 23181 xmlResetLastError(); 23182 if (mem_base != xmlMemBlocks()) { 23183 printf("Leak of %d blocks found in xmlSaveFileTo", 23184 xmlMemBlocks() - mem_base); 23185 test_ret++; 23186 printf(" %d", n_buf); 23187 printf(" %d", n_cur); 23188 printf(" %d", n_encoding); 23189 printf("\n"); 23190 } 23191 } 23192 } 23193 } 23194 function_tests++; 23195 #endif 23196 23197 return(test_ret); 23198 } 23199 23200 23201 static int 23202 test_xmlSaveFormatFile(void) { 23203 int test_ret = 0; 23204 23205 #if defined(LIBXML_OUTPUT_ENABLED) 23206 int mem_base; 23207 int ret_val; 23208 const char * filename; /* the filename (or URL) */ 23209 int n_filename; 23210 xmlDocPtr cur; /* the document */ 23211 int n_cur; 23212 int format; /* should formatting spaces been added */ 23213 int n_format; 23214 23215 for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) { 23216 for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) { 23217 for (n_format = 0;n_format < gen_nb_int;n_format++) { 23218 mem_base = xmlMemBlocks(); 23219 filename = gen_fileoutput(n_filename, 0); 23220 cur = gen_xmlDocPtr(n_cur, 1); 23221 format = gen_int(n_format, 2); 23222 23223 ret_val = xmlSaveFormatFile(filename, cur, format); 23224 desret_int(ret_val); 23225 call_tests++; 23226 des_fileoutput(n_filename, filename, 0); 23227 des_xmlDocPtr(n_cur, cur, 1); 23228 des_int(n_format, format, 2); 23229 xmlResetLastError(); 23230 if (mem_base != xmlMemBlocks()) { 23231 printf("Leak of %d blocks found in xmlSaveFormatFile", 23232 xmlMemBlocks() - mem_base); 23233 test_ret++; 23234 printf(" %d", n_filename); 23235 printf(" %d", n_cur); 23236 printf(" %d", n_format); 23237 printf("\n"); 23238 } 23239 } 23240 } 23241 } 23242 function_tests++; 23243 #endif 23244 23245 return(test_ret); 23246 } 23247 23248 23249 static int 23250 test_xmlSaveFormatFileEnc(void) { 23251 int test_ret = 0; 23252 23253 #if defined(LIBXML_OUTPUT_ENABLED) 23254 int mem_base; 23255 int ret_val; 23256 const char * filename; /* the filename or URL to output */ 23257 int n_filename; 23258 xmlDocPtr cur; /* the document being saved */ 23259 int n_cur; 23260 char * encoding; /* the name of the encoding to use or NULL. */ 23261 int n_encoding; 23262 int format; /* should formatting spaces be added. */ 23263 int n_format; 23264 23265 for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) { 23266 for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) { 23267 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 23268 for (n_format = 0;n_format < gen_nb_int;n_format++) { 23269 mem_base = xmlMemBlocks(); 23270 filename = gen_fileoutput(n_filename, 0); 23271 cur = gen_xmlDocPtr(n_cur, 1); 23272 encoding = gen_const_char_ptr(n_encoding, 2); 23273 format = gen_int(n_format, 3); 23274 23275 ret_val = xmlSaveFormatFileEnc(filename, cur, (const char *)encoding, format); 23276 desret_int(ret_val); 23277 call_tests++; 23278 des_fileoutput(n_filename, filename, 0); 23279 des_xmlDocPtr(n_cur, cur, 1); 23280 des_const_char_ptr(n_encoding, (const char *)encoding, 2); 23281 des_int(n_format, format, 3); 23282 xmlResetLastError(); 23283 if (mem_base != xmlMemBlocks()) { 23284 printf("Leak of %d blocks found in xmlSaveFormatFileEnc", 23285 xmlMemBlocks() - mem_base); 23286 test_ret++; 23287 printf(" %d", n_filename); 23288 printf(" %d", n_cur); 23289 printf(" %d", n_encoding); 23290 printf(" %d", n_format); 23291 printf("\n"); 23292 } 23293 } 23294 } 23295 } 23296 } 23297 function_tests++; 23298 #endif 23299 23300 return(test_ret); 23301 } 23302 23303 23304 static int 23305 test_xmlSaveFormatFileTo(void) { 23306 int test_ret = 0; 23307 23308 #if defined(LIBXML_OUTPUT_ENABLED) 23309 int mem_base; 23310 int ret_val; 23311 xmlOutputBufferPtr buf; /* an output I/O buffer */ 23312 int n_buf; 23313 xmlDocPtr cur; /* the document */ 23314 int n_cur; 23315 char * encoding; /* the encoding if any assuming the I/O layer handles the trancoding */ 23316 int n_encoding; 23317 int format; /* should formatting spaces been added */ 23318 int n_format; 23319 23320 for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) { 23321 for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) { 23322 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 23323 for (n_format = 0;n_format < gen_nb_int;n_format++) { 23324 mem_base = xmlMemBlocks(); 23325 buf = gen_xmlOutputBufferPtr(n_buf, 0); 23326 cur = gen_xmlDocPtr(n_cur, 1); 23327 encoding = gen_const_char_ptr(n_encoding, 2); 23328 format = gen_int(n_format, 3); 23329 23330 ret_val = xmlSaveFormatFileTo(buf, cur, (const char *)encoding, format); 23331 buf = NULL; 23332 desret_int(ret_val); 23333 call_tests++; 23334 des_xmlOutputBufferPtr(n_buf, buf, 0); 23335 des_xmlDocPtr(n_cur, cur, 1); 23336 des_const_char_ptr(n_encoding, (const char *)encoding, 2); 23337 des_int(n_format, format, 3); 23338 xmlResetLastError(); 23339 if (mem_base != xmlMemBlocks()) { 23340 printf("Leak of %d blocks found in xmlSaveFormatFileTo", 23341 xmlMemBlocks() - mem_base); 23342 test_ret++; 23343 printf(" %d", n_buf); 23344 printf(" %d", n_cur); 23345 printf(" %d", n_encoding); 23346 printf(" %d", n_format); 23347 printf("\n"); 23348 } 23349 } 23350 } 23351 } 23352 } 23353 function_tests++; 23354 #endif 23355 23356 return(test_ret); 23357 } 23358 23359 23360 static int 23361 test_xmlSearchNs(void) { 23362 int test_ret = 0; 23363 23364 int mem_base; 23365 xmlNsPtr ret_val; 23366 xmlDocPtr doc; /* the document */ 23367 int n_doc; 23368 xmlNodePtr node; /* the current node */ 23369 int n_node; 23370 xmlChar * nameSpace; /* the namespace prefix */ 23371 int n_nameSpace; 23372 23373 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 23374 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 23375 for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) { 23376 mem_base = xmlMemBlocks(); 23377 doc = gen_xmlDocPtr(n_doc, 0); 23378 node = gen_xmlNodePtr(n_node, 1); 23379 nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2); 23380 23381 ret_val = xmlSearchNs(doc, node, (const xmlChar *)nameSpace); 23382 desret_xmlNsPtr(ret_val); 23383 call_tests++; 23384 des_xmlDocPtr(n_doc, doc, 0); 23385 des_xmlNodePtr(n_node, node, 1); 23386 des_const_xmlChar_ptr(n_nameSpace, (const xmlChar *)nameSpace, 2); 23387 xmlResetLastError(); 23388 if (mem_base != xmlMemBlocks()) { 23389 printf("Leak of %d blocks found in xmlSearchNs", 23390 xmlMemBlocks() - mem_base); 23391 test_ret++; 23392 printf(" %d", n_doc); 23393 printf(" %d", n_node); 23394 printf(" %d", n_nameSpace); 23395 printf("\n"); 23396 } 23397 } 23398 } 23399 } 23400 function_tests++; 23401 23402 return(test_ret); 23403 } 23404 23405 23406 static int 23407 test_xmlSearchNsByHref(void) { 23408 int test_ret = 0; 23409 23410 int mem_base; 23411 xmlNsPtr ret_val; 23412 xmlDocPtr doc; /* the document */ 23413 int n_doc; 23414 xmlNodePtr node; /* the current node */ 23415 int n_node; 23416 xmlChar * href; /* the namespace value */ 23417 int n_href; 23418 23419 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 23420 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 23421 for (n_href = 0;n_href < gen_nb_const_xmlChar_ptr;n_href++) { 23422 mem_base = xmlMemBlocks(); 23423 doc = gen_xmlDocPtr(n_doc, 0); 23424 node = gen_xmlNodePtr(n_node, 1); 23425 href = gen_const_xmlChar_ptr(n_href, 2); 23426 23427 ret_val = xmlSearchNsByHref(doc, node, (const xmlChar *)href); 23428 desret_xmlNsPtr(ret_val); 23429 call_tests++; 23430 des_xmlDocPtr(n_doc, doc, 0); 23431 des_xmlNodePtr(n_node, node, 1); 23432 des_const_xmlChar_ptr(n_href, (const xmlChar *)href, 2); 23433 xmlResetLastError(); 23434 if (mem_base != xmlMemBlocks()) { 23435 printf("Leak of %d blocks found in xmlSearchNsByHref", 23436 xmlMemBlocks() - mem_base); 23437 test_ret++; 23438 printf(" %d", n_doc); 23439 printf(" %d", n_node); 23440 printf(" %d", n_href); 23441 printf("\n"); 23442 } 23443 } 23444 } 23445 } 23446 function_tests++; 23447 23448 return(test_ret); 23449 } 23450 23451 23452 static int 23453 test_xmlSetBufferAllocationScheme(void) { 23454 int test_ret = 0; 23455 23456 int mem_base; 23457 xmlBufferAllocationScheme scheme; /* allocation method to use */ 23458 int n_scheme; 23459 23460 for (n_scheme = 0;n_scheme < gen_nb_xmlBufferAllocationScheme;n_scheme++) { 23461 mem_base = xmlMemBlocks(); 23462 scheme = gen_xmlBufferAllocationScheme(n_scheme, 0); 23463 23464 xmlSetBufferAllocationScheme(scheme); 23465 call_tests++; 23466 des_xmlBufferAllocationScheme(n_scheme, scheme, 0); 23467 xmlResetLastError(); 23468 if (mem_base != xmlMemBlocks()) { 23469 printf("Leak of %d blocks found in xmlSetBufferAllocationScheme", 23470 xmlMemBlocks() - mem_base); 23471 test_ret++; 23472 printf(" %d", n_scheme); 23473 printf("\n"); 23474 } 23475 } 23476 function_tests++; 23477 23478 return(test_ret); 23479 } 23480 23481 23482 static int 23483 test_xmlSetCompressMode(void) { 23484 int test_ret = 0; 23485 23486 int mem_base; 23487 int mode; /* the compression ratio */ 23488 int n_mode; 23489 23490 for (n_mode = 0;n_mode < gen_nb_int;n_mode++) { 23491 mem_base = xmlMemBlocks(); 23492 mode = gen_int(n_mode, 0); 23493 23494 xmlSetCompressMode(mode); 23495 call_tests++; 23496 des_int(n_mode, mode, 0); 23497 xmlResetLastError(); 23498 if (mem_base != xmlMemBlocks()) { 23499 printf("Leak of %d blocks found in xmlSetCompressMode", 23500 xmlMemBlocks() - mem_base); 23501 test_ret++; 23502 printf(" %d", n_mode); 23503 printf("\n"); 23504 } 23505 } 23506 function_tests++; 23507 23508 return(test_ret); 23509 } 23510 23511 23512 static int 23513 test_xmlSetDocCompressMode(void) { 23514 int test_ret = 0; 23515 23516 int mem_base; 23517 xmlDocPtr doc; /* the document */ 23518 int n_doc; 23519 int mode; /* the compression ratio */ 23520 int n_mode; 23521 23522 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 23523 for (n_mode = 0;n_mode < gen_nb_int;n_mode++) { 23524 mem_base = xmlMemBlocks(); 23525 doc = gen_xmlDocPtr(n_doc, 0); 23526 mode = gen_int(n_mode, 1); 23527 23528 xmlSetDocCompressMode(doc, mode); 23529 call_tests++; 23530 des_xmlDocPtr(n_doc, doc, 0); 23531 des_int(n_mode, mode, 1); 23532 xmlResetLastError(); 23533 if (mem_base != xmlMemBlocks()) { 23534 printf("Leak of %d blocks found in xmlSetDocCompressMode", 23535 xmlMemBlocks() - mem_base); 23536 test_ret++; 23537 printf(" %d", n_doc); 23538 printf(" %d", n_mode); 23539 printf("\n"); 23540 } 23541 } 23542 } 23543 function_tests++; 23544 23545 return(test_ret); 23546 } 23547 23548 23549 static int 23550 test_xmlSetNs(void) { 23551 int test_ret = 0; 23552 23553 int mem_base; 23554 xmlNodePtr node; /* a node in the document */ 23555 int n_node; 23556 xmlNsPtr ns; /* a namespace pointer */ 23557 int n_ns; 23558 23559 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 23560 for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) { 23561 mem_base = xmlMemBlocks(); 23562 node = gen_xmlNodePtr(n_node, 0); 23563 ns = gen_xmlNsPtr(n_ns, 1); 23564 23565 xmlSetNs(node, ns); 23566 call_tests++; 23567 des_xmlNodePtr(n_node, node, 0); 23568 des_xmlNsPtr(n_ns, ns, 1); 23569 xmlResetLastError(); 23570 if (mem_base != xmlMemBlocks()) { 23571 printf("Leak of %d blocks found in xmlSetNs", 23572 xmlMemBlocks() - mem_base); 23573 test_ret++; 23574 printf(" %d", n_node); 23575 printf(" %d", n_ns); 23576 printf("\n"); 23577 } 23578 } 23579 } 23580 function_tests++; 23581 23582 return(test_ret); 23583 } 23584 23585 23586 static int 23587 test_xmlSetNsProp(void) { 23588 int test_ret = 0; 23589 23590 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) 23591 int mem_base; 23592 xmlAttrPtr ret_val; 23593 xmlNodePtr node; /* the node */ 23594 int n_node; 23595 xmlNsPtr ns; /* the namespace definition */ 23596 int n_ns; 23597 xmlChar * name; /* the attribute name */ 23598 int n_name; 23599 xmlChar * value; /* the attribute value */ 23600 int n_value; 23601 23602 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 23603 for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) { 23604 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 23605 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 23606 mem_base = xmlMemBlocks(); 23607 node = gen_xmlNodePtr(n_node, 0); 23608 ns = gen_xmlNsPtr(n_ns, 1); 23609 name = gen_const_xmlChar_ptr(n_name, 2); 23610 value = gen_const_xmlChar_ptr(n_value, 3); 23611 23612 ret_val = xmlSetNsProp(node, ns, (const xmlChar *)name, (const xmlChar *)value); 23613 desret_xmlAttrPtr(ret_val); 23614 call_tests++; 23615 des_xmlNodePtr(n_node, node, 0); 23616 des_xmlNsPtr(n_ns, ns, 1); 23617 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 23618 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3); 23619 xmlResetLastError(); 23620 if (mem_base != xmlMemBlocks()) { 23621 printf("Leak of %d blocks found in xmlSetNsProp", 23622 xmlMemBlocks() - mem_base); 23623 test_ret++; 23624 printf(" %d", n_node); 23625 printf(" %d", n_ns); 23626 printf(" %d", n_name); 23627 printf(" %d", n_value); 23628 printf("\n"); 23629 } 23630 } 23631 } 23632 } 23633 } 23634 function_tests++; 23635 #endif 23636 23637 return(test_ret); 23638 } 23639 23640 23641 static int 23642 test_xmlSetProp(void) { 23643 int test_ret = 0; 23644 23645 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) 23646 int mem_base; 23647 xmlAttrPtr ret_val; 23648 xmlNodePtr node; /* the node */ 23649 int n_node; 23650 xmlChar * name; /* the attribute name (a QName) */ 23651 int n_name; 23652 xmlChar * value; /* the attribute value */ 23653 int n_value; 23654 23655 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 23656 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 23657 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 23658 mem_base = xmlMemBlocks(); 23659 node = gen_xmlNodePtr(n_node, 0); 23660 name = gen_const_xmlChar_ptr(n_name, 1); 23661 value = gen_const_xmlChar_ptr(n_value, 2); 23662 23663 ret_val = xmlSetProp(node, (const xmlChar *)name, (const xmlChar *)value); 23664 desret_xmlAttrPtr(ret_val); 23665 call_tests++; 23666 des_xmlNodePtr(n_node, node, 0); 23667 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 23668 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2); 23669 xmlResetLastError(); 23670 if (mem_base != xmlMemBlocks()) { 23671 printf("Leak of %d blocks found in xmlSetProp", 23672 xmlMemBlocks() - mem_base); 23673 test_ret++; 23674 printf(" %d", n_node); 23675 printf(" %d", n_name); 23676 printf(" %d", n_value); 23677 printf("\n"); 23678 } 23679 } 23680 } 23681 } 23682 function_tests++; 23683 #endif 23684 23685 return(test_ret); 23686 } 23687 23688 23689 static int 23690 test_xmlSplitQName2(void) { 23691 int test_ret = 0; 23692 23693 int mem_base; 23694 xmlChar * ret_val; 23695 xmlChar * name; /* the full QName */ 23696 int n_name; 23697 xmlChar ** prefix; /* a xmlChar ** */ 23698 int n_prefix; 23699 23700 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 23701 for (n_prefix = 0;n_prefix < gen_nb_xmlChar_ptr_ptr;n_prefix++) { 23702 mem_base = xmlMemBlocks(); 23703 name = gen_const_xmlChar_ptr(n_name, 0); 23704 prefix = gen_xmlChar_ptr_ptr(n_prefix, 1); 23705 23706 ret_val = xmlSplitQName2((const xmlChar *)name, prefix); 23707 desret_xmlChar_ptr(ret_val); 23708 call_tests++; 23709 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0); 23710 des_xmlChar_ptr_ptr(n_prefix, prefix, 1); 23711 xmlResetLastError(); 23712 if (mem_base != xmlMemBlocks()) { 23713 printf("Leak of %d blocks found in xmlSplitQName2", 23714 xmlMemBlocks() - mem_base); 23715 test_ret++; 23716 printf(" %d", n_name); 23717 printf(" %d", n_prefix); 23718 printf("\n"); 23719 } 23720 } 23721 } 23722 function_tests++; 23723 23724 return(test_ret); 23725 } 23726 23727 23728 static int 23729 test_xmlSplitQName3(void) { 23730 int test_ret = 0; 23731 23732 int mem_base; 23733 const xmlChar * ret_val; 23734 xmlChar * name; /* the full QName */ 23735 int n_name; 23736 int * len; /* an int * */ 23737 int n_len; 23738 23739 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 23740 for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) { 23741 mem_base = xmlMemBlocks(); 23742 name = gen_const_xmlChar_ptr(n_name, 0); 23743 len = gen_int_ptr(n_len, 1); 23744 23745 ret_val = xmlSplitQName3((const xmlChar *)name, len); 23746 desret_const_xmlChar_ptr(ret_val); 23747 call_tests++; 23748 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0); 23749 des_int_ptr(n_len, len, 1); 23750 xmlResetLastError(); 23751 if (mem_base != xmlMemBlocks()) { 23752 printf("Leak of %d blocks found in xmlSplitQName3", 23753 xmlMemBlocks() - mem_base); 23754 test_ret++; 23755 printf(" %d", n_name); 23756 printf(" %d", n_len); 23757 printf("\n"); 23758 } 23759 } 23760 } 23761 function_tests++; 23762 23763 return(test_ret); 23764 } 23765 23766 23767 static int 23768 test_xmlStringGetNodeList(void) { 23769 int test_ret = 0; 23770 23771 int mem_base; 23772 xmlNodePtr ret_val; 23773 xmlDoc * doc; /* the document */ 23774 int n_doc; 23775 xmlChar * value; /* the value of the attribute */ 23776 int n_value; 23777 23778 for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) { 23779 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 23780 mem_base = xmlMemBlocks(); 23781 doc = gen_const_xmlDoc_ptr(n_doc, 0); 23782 value = gen_const_xmlChar_ptr(n_value, 1); 23783 23784 ret_val = xmlStringGetNodeList((const xmlDoc *)doc, (const xmlChar *)value); 23785 desret_xmlNodePtr(ret_val); 23786 call_tests++; 23787 des_const_xmlDoc_ptr(n_doc, (const xmlDoc *)doc, 0); 23788 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1); 23789 xmlResetLastError(); 23790 if (mem_base != xmlMemBlocks()) { 23791 printf("Leak of %d blocks found in xmlStringGetNodeList", 23792 xmlMemBlocks() - mem_base); 23793 test_ret++; 23794 printf(" %d", n_doc); 23795 printf(" %d", n_value); 23796 printf("\n"); 23797 } 23798 } 23799 } 23800 function_tests++; 23801 23802 return(test_ret); 23803 } 23804 23805 23806 static int 23807 test_xmlStringLenGetNodeList(void) { 23808 int test_ret = 0; 23809 23810 int mem_base; 23811 xmlNodePtr ret_val; 23812 xmlDoc * doc; /* the document */ 23813 int n_doc; 23814 xmlChar * value; /* the value of the text */ 23815 int n_value; 23816 int len; /* the length of the string value */ 23817 int n_len; 23818 23819 for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) { 23820 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 23821 for (n_len = 0;n_len < gen_nb_int;n_len++) { 23822 mem_base = xmlMemBlocks(); 23823 doc = gen_const_xmlDoc_ptr(n_doc, 0); 23824 value = gen_const_xmlChar_ptr(n_value, 1); 23825 len = gen_int(n_len, 2); 23826 23827 ret_val = xmlStringLenGetNodeList((const xmlDoc *)doc, (const xmlChar *)value, len); 23828 desret_xmlNodePtr(ret_val); 23829 call_tests++; 23830 des_const_xmlDoc_ptr(n_doc, (const xmlDoc *)doc, 0); 23831 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1); 23832 des_int(n_len, len, 2); 23833 xmlResetLastError(); 23834 if (mem_base != xmlMemBlocks()) { 23835 printf("Leak of %d blocks found in xmlStringLenGetNodeList", 23836 xmlMemBlocks() - mem_base); 23837 test_ret++; 23838 printf(" %d", n_doc); 23839 printf(" %d", n_value); 23840 printf(" %d", n_len); 23841 printf("\n"); 23842 } 23843 } 23844 } 23845 } 23846 function_tests++; 23847 23848 return(test_ret); 23849 } 23850 23851 23852 static int 23853 test_xmlTextConcat(void) { 23854 int test_ret = 0; 23855 23856 int mem_base; 23857 int ret_val; 23858 xmlNodePtr node; /* the node */ 23859 int n_node; 23860 xmlChar * content; /* the content */ 23861 int n_content; 23862 int len; /* @content length */ 23863 int n_len; 23864 23865 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 23866 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 23867 for (n_len = 0;n_len < gen_nb_int;n_len++) { 23868 mem_base = xmlMemBlocks(); 23869 node = gen_xmlNodePtr(n_node, 0); 23870 content = gen_const_xmlChar_ptr(n_content, 1); 23871 len = gen_int(n_len, 2); 23872 23873 ret_val = xmlTextConcat(node, (const xmlChar *)content, len); 23874 desret_int(ret_val); 23875 call_tests++; 23876 des_xmlNodePtr(n_node, node, 0); 23877 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1); 23878 des_int(n_len, len, 2); 23879 xmlResetLastError(); 23880 if (mem_base != xmlMemBlocks()) { 23881 printf("Leak of %d blocks found in xmlTextConcat", 23882 xmlMemBlocks() - mem_base); 23883 test_ret++; 23884 printf(" %d", n_node); 23885 printf(" %d", n_content); 23886 printf(" %d", n_len); 23887 printf("\n"); 23888 } 23889 } 23890 } 23891 } 23892 function_tests++; 23893 23894 return(test_ret); 23895 } 23896 23897 23898 static int 23899 test_xmlTextMerge(void) { 23900 int test_ret = 0; 23901 23902 int mem_base; 23903 xmlNodePtr ret_val; 23904 xmlNodePtr first; /* the first text node */ 23905 int n_first; 23906 xmlNodePtr second; /* the second text node being merged */ 23907 int n_second; 23908 23909 for (n_first = 0;n_first < gen_nb_xmlNodePtr_in;n_first++) { 23910 for (n_second = 0;n_second < gen_nb_xmlNodePtr_in;n_second++) { 23911 mem_base = xmlMemBlocks(); 23912 first = gen_xmlNodePtr_in(n_first, 0); 23913 second = gen_xmlNodePtr_in(n_second, 1); 23914 23915 ret_val = xmlTextMerge(first, second); 23916 if ((first != NULL) && (first->type != XML_TEXT_NODE)) { 23917 xmlUnlinkNode(second); 23918 xmlFreeNode(second) ; second = NULL ; } 23919 desret_xmlNodePtr(ret_val); 23920 call_tests++; 23921 des_xmlNodePtr_in(n_first, first, 0); 23922 des_xmlNodePtr_in(n_second, second, 1); 23923 xmlResetLastError(); 23924 if (mem_base != xmlMemBlocks()) { 23925 printf("Leak of %d blocks found in xmlTextMerge", 23926 xmlMemBlocks() - mem_base); 23927 test_ret++; 23928 printf(" %d", n_first); 23929 printf(" %d", n_second); 23930 printf("\n"); 23931 } 23932 } 23933 } 23934 function_tests++; 23935 23936 return(test_ret); 23937 } 23938 23939 23940 static int 23941 test_xmlUnsetNsProp(void) { 23942 int test_ret = 0; 23943 23944 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 23945 int mem_base; 23946 int ret_val; 23947 xmlNodePtr node; /* the node */ 23948 int n_node; 23949 xmlNsPtr ns; /* the namespace definition */ 23950 int n_ns; 23951 xmlChar * name; /* the attribute name */ 23952 int n_name; 23953 23954 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 23955 for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) { 23956 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 23957 mem_base = xmlMemBlocks(); 23958 node = gen_xmlNodePtr(n_node, 0); 23959 ns = gen_xmlNsPtr(n_ns, 1); 23960 name = gen_const_xmlChar_ptr(n_name, 2); 23961 23962 ret_val = xmlUnsetNsProp(node, ns, (const xmlChar *)name); 23963 desret_int(ret_val); 23964 call_tests++; 23965 des_xmlNodePtr(n_node, node, 0); 23966 des_xmlNsPtr(n_ns, ns, 1); 23967 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 23968 xmlResetLastError(); 23969 if (mem_base != xmlMemBlocks()) { 23970 printf("Leak of %d blocks found in xmlUnsetNsProp", 23971 xmlMemBlocks() - mem_base); 23972 test_ret++; 23973 printf(" %d", n_node); 23974 printf(" %d", n_ns); 23975 printf(" %d", n_name); 23976 printf("\n"); 23977 } 23978 } 23979 } 23980 } 23981 function_tests++; 23982 #endif 23983 23984 return(test_ret); 23985 } 23986 23987 23988 static int 23989 test_xmlUnsetProp(void) { 23990 int test_ret = 0; 23991 23992 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 23993 int mem_base; 23994 int ret_val; 23995 xmlNodePtr node; /* the node */ 23996 int n_node; 23997 xmlChar * name; /* the attribute name */ 23998 int n_name; 23999 24000 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 24001 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 24002 mem_base = xmlMemBlocks(); 24003 node = gen_xmlNodePtr(n_node, 0); 24004 name = gen_const_xmlChar_ptr(n_name, 1); 24005 24006 ret_val = xmlUnsetProp(node, (const xmlChar *)name); 24007 desret_int(ret_val); 24008 call_tests++; 24009 des_xmlNodePtr(n_node, node, 0); 24010 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 24011 xmlResetLastError(); 24012 if (mem_base != xmlMemBlocks()) { 24013 printf("Leak of %d blocks found in xmlUnsetProp", 24014 xmlMemBlocks() - mem_base); 24015 test_ret++; 24016 printf(" %d", n_node); 24017 printf(" %d", n_name); 24018 printf("\n"); 24019 } 24020 } 24021 } 24022 function_tests++; 24023 #endif 24024 24025 return(test_ret); 24026 } 24027 24028 24029 static int 24030 test_xmlValidateNCName(void) { 24031 int test_ret = 0; 24032 24033 #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) || defined(LIBXML_LEGACY_ENABLED) 24034 #ifdef LIBXML_TREE_ENABLED 24035 int mem_base; 24036 int ret_val; 24037 xmlChar * value; /* the value to check */ 24038 int n_value; 24039 int space; /* allow spaces in front and end of the string */ 24040 int n_space; 24041 24042 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 24043 for (n_space = 0;n_space < gen_nb_int;n_space++) { 24044 mem_base = xmlMemBlocks(); 24045 value = gen_const_xmlChar_ptr(n_value, 0); 24046 space = gen_int(n_space, 1); 24047 24048 ret_val = xmlValidateNCName((const xmlChar *)value, space); 24049 desret_int(ret_val); 24050 call_tests++; 24051 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0); 24052 des_int(n_space, space, 1); 24053 xmlResetLastError(); 24054 if (mem_base != xmlMemBlocks()) { 24055 printf("Leak of %d blocks found in xmlValidateNCName", 24056 xmlMemBlocks() - mem_base); 24057 test_ret++; 24058 printf(" %d", n_value); 24059 printf(" %d", n_space); 24060 printf("\n"); 24061 } 24062 } 24063 } 24064 function_tests++; 24065 #endif 24066 #endif 24067 24068 return(test_ret); 24069 } 24070 24071 24072 static int 24073 test_xmlValidateNMToken(void) { 24074 int test_ret = 0; 24075 24076 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 24077 #ifdef LIBXML_TREE_ENABLED 24078 int mem_base; 24079 int ret_val; 24080 xmlChar * value; /* the value to check */ 24081 int n_value; 24082 int space; /* allow spaces in front and end of the string */ 24083 int n_space; 24084 24085 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 24086 for (n_space = 0;n_space < gen_nb_int;n_space++) { 24087 mem_base = xmlMemBlocks(); 24088 value = gen_const_xmlChar_ptr(n_value, 0); 24089 space = gen_int(n_space, 1); 24090 24091 ret_val = xmlValidateNMToken((const xmlChar *)value, space); 24092 desret_int(ret_val); 24093 call_tests++; 24094 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0); 24095 des_int(n_space, space, 1); 24096 xmlResetLastError(); 24097 if (mem_base != xmlMemBlocks()) { 24098 printf("Leak of %d blocks found in xmlValidateNMToken", 24099 xmlMemBlocks() - mem_base); 24100 test_ret++; 24101 printf(" %d", n_value); 24102 printf(" %d", n_space); 24103 printf("\n"); 24104 } 24105 } 24106 } 24107 function_tests++; 24108 #endif 24109 #endif 24110 24111 return(test_ret); 24112 } 24113 24114 24115 static int 24116 test_xmlValidateName(void) { 24117 int test_ret = 0; 24118 24119 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 24120 #ifdef LIBXML_TREE_ENABLED 24121 int mem_base; 24122 int ret_val; 24123 xmlChar * value; /* the value to check */ 24124 int n_value; 24125 int space; /* allow spaces in front and end of the string */ 24126 int n_space; 24127 24128 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 24129 for (n_space = 0;n_space < gen_nb_int;n_space++) { 24130 mem_base = xmlMemBlocks(); 24131 value = gen_const_xmlChar_ptr(n_value, 0); 24132 space = gen_int(n_space, 1); 24133 24134 ret_val = xmlValidateName((const xmlChar *)value, space); 24135 desret_int(ret_val); 24136 call_tests++; 24137 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0); 24138 des_int(n_space, space, 1); 24139 xmlResetLastError(); 24140 if (mem_base != xmlMemBlocks()) { 24141 printf("Leak of %d blocks found in xmlValidateName", 24142 xmlMemBlocks() - mem_base); 24143 test_ret++; 24144 printf(" %d", n_value); 24145 printf(" %d", n_space); 24146 printf("\n"); 24147 } 24148 } 24149 } 24150 function_tests++; 24151 #endif 24152 #endif 24153 24154 return(test_ret); 24155 } 24156 24157 24158 static int 24159 test_xmlValidateQName(void) { 24160 int test_ret = 0; 24161 24162 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 24163 #ifdef LIBXML_TREE_ENABLED 24164 int mem_base; 24165 int ret_val; 24166 xmlChar * value; /* the value to check */ 24167 int n_value; 24168 int space; /* allow spaces in front and end of the string */ 24169 int n_space; 24170 24171 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 24172 for (n_space = 0;n_space < gen_nb_int;n_space++) { 24173 mem_base = xmlMemBlocks(); 24174 value = gen_const_xmlChar_ptr(n_value, 0); 24175 space = gen_int(n_space, 1); 24176 24177 ret_val = xmlValidateQName((const xmlChar *)value, space); 24178 desret_int(ret_val); 24179 call_tests++; 24180 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0); 24181 des_int(n_space, space, 1); 24182 xmlResetLastError(); 24183 if (mem_base != xmlMemBlocks()) { 24184 printf("Leak of %d blocks found in xmlValidateQName", 24185 xmlMemBlocks() - mem_base); 24186 test_ret++; 24187 printf(" %d", n_value); 24188 printf(" %d", n_space); 24189 printf("\n"); 24190 } 24191 } 24192 } 24193 function_tests++; 24194 #endif 24195 #endif 24196 24197 return(test_ret); 24198 } 24199 24200 static int 24201 test_tree(void) { 24202 int test_ret = 0; 24203 24204 if (quiet == 0) printf("Testing tree : 142 of 164 functions ...\n"); 24205 test_ret += test_xmlAddChild(); 24206 test_ret += test_xmlAddChildList(); 24207 test_ret += test_xmlAddNextSibling(); 24208 test_ret += test_xmlAddPrevSibling(); 24209 test_ret += test_xmlAddSibling(); 24210 test_ret += test_xmlAttrSerializeTxtContent(); 24211 test_ret += test_xmlBufContent(); 24212 test_ret += test_xmlBufEnd(); 24213 test_ret += test_xmlBufGetNodeContent(); 24214 test_ret += test_xmlBufNodeDump(); 24215 test_ret += test_xmlBufShrink(); 24216 test_ret += test_xmlBufUse(); 24217 test_ret += test_xmlBufferAdd(); 24218 test_ret += test_xmlBufferAddHead(); 24219 test_ret += test_xmlBufferCCat(); 24220 test_ret += test_xmlBufferCat(); 24221 test_ret += test_xmlBufferContent(); 24222 test_ret += test_xmlBufferCreate(); 24223 test_ret += test_xmlBufferCreateSize(); 24224 test_ret += test_xmlBufferCreateStatic(); 24225 test_ret += test_xmlBufferDetach(); 24226 test_ret += test_xmlBufferEmpty(); 24227 test_ret += test_xmlBufferGrow(); 24228 test_ret += test_xmlBufferLength(); 24229 test_ret += test_xmlBufferResize(); 24230 test_ret += test_xmlBufferSetAllocationScheme(); 24231 test_ret += test_xmlBufferShrink(); 24232 test_ret += test_xmlBufferWriteCHAR(); 24233 test_ret += test_xmlBufferWriteChar(); 24234 test_ret += test_xmlBufferWriteQuotedString(); 24235 test_ret += test_xmlBuildQName(); 24236 test_ret += test_xmlChildElementCount(); 24237 test_ret += test_xmlCopyDoc(); 24238 test_ret += test_xmlCopyDtd(); 24239 test_ret += test_xmlCopyNamespace(); 24240 test_ret += test_xmlCopyNamespaceList(); 24241 test_ret += test_xmlCopyNode(); 24242 test_ret += test_xmlCopyNodeList(); 24243 test_ret += test_xmlCopyProp(); 24244 test_ret += test_xmlCopyPropList(); 24245 test_ret += test_xmlCreateIntSubset(); 24246 test_ret += test_xmlDOMWrapAdoptNode(); 24247 test_ret += test_xmlDOMWrapCloneNode(); 24248 test_ret += test_xmlDOMWrapNewCtxt(); 24249 test_ret += test_xmlDOMWrapReconcileNamespaces(); 24250 test_ret += test_xmlDOMWrapRemoveNode(); 24251 test_ret += test_xmlDocCopyNode(); 24252 test_ret += test_xmlDocCopyNodeList(); 24253 test_ret += test_xmlDocDump(); 24254 test_ret += test_xmlDocDumpFormatMemory(); 24255 test_ret += test_xmlDocDumpFormatMemoryEnc(); 24256 test_ret += test_xmlDocDumpMemory(); 24257 test_ret += test_xmlDocDumpMemoryEnc(); 24258 test_ret += test_xmlDocFormatDump(); 24259 test_ret += test_xmlDocGetRootElement(); 24260 test_ret += test_xmlDocSetRootElement(); 24261 test_ret += test_xmlElemDump(); 24262 test_ret += test_xmlFirstElementChild(); 24263 test_ret += test_xmlGetBufferAllocationScheme(); 24264 test_ret += test_xmlGetCompressMode(); 24265 test_ret += test_xmlGetDocCompressMode(); 24266 test_ret += test_xmlGetIntSubset(); 24267 test_ret += test_xmlGetLastChild(); 24268 test_ret += test_xmlGetLineNo(); 24269 test_ret += test_xmlGetNoNsProp(); 24270 test_ret += test_xmlGetNodePath(); 24271 test_ret += test_xmlGetNsList(); 24272 test_ret += test_xmlGetNsProp(); 24273 test_ret += test_xmlGetProp(); 24274 test_ret += test_xmlHasNsProp(); 24275 test_ret += test_xmlHasProp(); 24276 test_ret += test_xmlIsBlankNode(); 24277 test_ret += test_xmlIsXHTML(); 24278 test_ret += test_xmlLastElementChild(); 24279 test_ret += test_xmlNewCDataBlock(); 24280 test_ret += test_xmlNewCharRef(); 24281 test_ret += test_xmlNewChild(); 24282 test_ret += test_xmlNewComment(); 24283 test_ret += test_xmlNewDoc(); 24284 test_ret += test_xmlNewDocComment(); 24285 test_ret += test_xmlNewDocFragment(); 24286 test_ret += test_xmlNewDocNode(); 24287 test_ret += test_xmlNewDocNodeEatName(); 24288 test_ret += test_xmlNewDocPI(); 24289 test_ret += test_xmlNewDocProp(); 24290 test_ret += test_xmlNewDocRawNode(); 24291 test_ret += test_xmlNewDocText(); 24292 test_ret += test_xmlNewDocTextLen(); 24293 test_ret += test_xmlNewDtd(); 24294 test_ret += test_xmlNewNode(); 24295 test_ret += test_xmlNewNodeEatName(); 24296 test_ret += test_xmlNewNs(); 24297 test_ret += test_xmlNewNsProp(); 24298 test_ret += test_xmlNewNsPropEatName(); 24299 test_ret += test_xmlNewPI(); 24300 test_ret += test_xmlNewProp(); 24301 test_ret += test_xmlNewReference(); 24302 test_ret += test_xmlNewText(); 24303 test_ret += test_xmlNewTextChild(); 24304 test_ret += test_xmlNewTextLen(); 24305 test_ret += test_xmlNextElementSibling(); 24306 test_ret += test_xmlNodeAddContent(); 24307 test_ret += test_xmlNodeAddContentLen(); 24308 test_ret += test_xmlNodeBufGetContent(); 24309 test_ret += test_xmlNodeDump(); 24310 test_ret += test_xmlNodeDumpOutput(); 24311 test_ret += test_xmlNodeGetBase(); 24312 test_ret += test_xmlNodeGetContent(); 24313 test_ret += test_xmlNodeGetLang(); 24314 test_ret += test_xmlNodeGetSpacePreserve(); 24315 test_ret += test_xmlNodeIsText(); 24316 test_ret += test_xmlNodeListGetRawString(); 24317 test_ret += test_xmlNodeListGetString(); 24318 test_ret += test_xmlNodeSetBase(); 24319 test_ret += test_xmlNodeSetContent(); 24320 test_ret += test_xmlNodeSetContentLen(); 24321 test_ret += test_xmlNodeSetLang(); 24322 test_ret += test_xmlNodeSetName(); 24323 test_ret += test_xmlNodeSetSpacePreserve(); 24324 test_ret += test_xmlPreviousElementSibling(); 24325 test_ret += test_xmlReconciliateNs(); 24326 test_ret += test_xmlRemoveProp(); 24327 test_ret += test_xmlReplaceNode(); 24328 test_ret += test_xmlSaveFile(); 24329 test_ret += test_xmlSaveFileEnc(); 24330 test_ret += test_xmlSaveFileTo(); 24331 test_ret += test_xmlSaveFormatFile(); 24332 test_ret += test_xmlSaveFormatFileEnc(); 24333 test_ret += test_xmlSaveFormatFileTo(); 24334 test_ret += test_xmlSearchNs(); 24335 test_ret += test_xmlSearchNsByHref(); 24336 test_ret += test_xmlSetBufferAllocationScheme(); 24337 test_ret += test_xmlSetCompressMode(); 24338 test_ret += test_xmlSetDocCompressMode(); 24339 test_ret += test_xmlSetNs(); 24340 test_ret += test_xmlSetNsProp(); 24341 test_ret += test_xmlSetProp(); 24342 test_ret += test_xmlSplitQName2(); 24343 test_ret += test_xmlSplitQName3(); 24344 test_ret += test_xmlStringGetNodeList(); 24345 test_ret += test_xmlStringLenGetNodeList(); 24346 test_ret += test_xmlTextConcat(); 24347 test_ret += test_xmlTextMerge(); 24348 test_ret += test_xmlUnsetNsProp(); 24349 test_ret += test_xmlUnsetProp(); 24350 test_ret += test_xmlValidateNCName(); 24351 test_ret += test_xmlValidateNMToken(); 24352 test_ret += test_xmlValidateName(); 24353 test_ret += test_xmlValidateQName(); 24354 24355 if (test_ret != 0) 24356 printf("Module tree: %d errors\n", test_ret); 24357 return(test_ret); 24358 } 24359 24360 static int 24361 test_xmlBuildRelativeURI(void) { 24362 int test_ret = 0; 24363 24364 int mem_base; 24365 xmlChar * ret_val; 24366 xmlChar * URI; /* the URI reference under consideration */ 24367 int n_URI; 24368 xmlChar * base; /* the base value */ 24369 int n_base; 24370 24371 for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) { 24372 for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) { 24373 mem_base = xmlMemBlocks(); 24374 URI = gen_const_xmlChar_ptr(n_URI, 0); 24375 base = gen_const_xmlChar_ptr(n_base, 1); 24376 24377 ret_val = xmlBuildRelativeURI((const xmlChar *)URI, (const xmlChar *)base); 24378 desret_xmlChar_ptr(ret_val); 24379 call_tests++; 24380 des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0); 24381 des_const_xmlChar_ptr(n_base, (const xmlChar *)base, 1); 24382 xmlResetLastError(); 24383 if (mem_base != xmlMemBlocks()) { 24384 printf("Leak of %d blocks found in xmlBuildRelativeURI", 24385 xmlMemBlocks() - mem_base); 24386 test_ret++; 24387 printf(" %d", n_URI); 24388 printf(" %d", n_base); 24389 printf("\n"); 24390 } 24391 } 24392 } 24393 function_tests++; 24394 24395 return(test_ret); 24396 } 24397 24398 24399 static int 24400 test_xmlBuildURI(void) { 24401 int test_ret = 0; 24402 24403 int mem_base; 24404 xmlChar * ret_val; 24405 xmlChar * URI; /* the URI instance found in the document */ 24406 int n_URI; 24407 xmlChar * base; /* the base value */ 24408 int n_base; 24409 24410 for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) { 24411 for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) { 24412 mem_base = xmlMemBlocks(); 24413 URI = gen_const_xmlChar_ptr(n_URI, 0); 24414 base = gen_const_xmlChar_ptr(n_base, 1); 24415 24416 ret_val = xmlBuildURI((const xmlChar *)URI, (const xmlChar *)base); 24417 desret_xmlChar_ptr(ret_val); 24418 call_tests++; 24419 des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0); 24420 des_const_xmlChar_ptr(n_base, (const xmlChar *)base, 1); 24421 xmlResetLastError(); 24422 if (mem_base != xmlMemBlocks()) { 24423 printf("Leak of %d blocks found in xmlBuildURI", 24424 xmlMemBlocks() - mem_base); 24425 test_ret++; 24426 printf(" %d", n_URI); 24427 printf(" %d", n_base); 24428 printf("\n"); 24429 } 24430 } 24431 } 24432 function_tests++; 24433 24434 return(test_ret); 24435 } 24436 24437 24438 static int 24439 test_xmlCanonicPath(void) { 24440 int test_ret = 0; 24441 24442 int mem_base; 24443 xmlChar * ret_val; 24444 xmlChar * path; /* the resource locator in a filesystem notation */ 24445 int n_path; 24446 24447 for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) { 24448 mem_base = xmlMemBlocks(); 24449 path = gen_const_xmlChar_ptr(n_path, 0); 24450 24451 ret_val = xmlCanonicPath((const xmlChar *)path); 24452 desret_xmlChar_ptr(ret_val); 24453 call_tests++; 24454 des_const_xmlChar_ptr(n_path, (const xmlChar *)path, 0); 24455 xmlResetLastError(); 24456 if (mem_base != xmlMemBlocks()) { 24457 printf("Leak of %d blocks found in xmlCanonicPath", 24458 xmlMemBlocks() - mem_base); 24459 test_ret++; 24460 printf(" %d", n_path); 24461 printf("\n"); 24462 } 24463 } 24464 function_tests++; 24465 24466 return(test_ret); 24467 } 24468 24469 24470 static int 24471 test_xmlCreateURI(void) { 24472 int test_ret = 0; 24473 24474 24475 /* missing type support */ 24476 return(test_ret); 24477 } 24478 24479 24480 static int 24481 test_xmlNormalizeURIPath(void) { 24482 int test_ret = 0; 24483 24484 int mem_base; 24485 int ret_val; 24486 char * path; /* pointer to the path string */ 24487 int n_path; 24488 24489 for (n_path = 0;n_path < gen_nb_char_ptr;n_path++) { 24490 mem_base = xmlMemBlocks(); 24491 path = gen_char_ptr(n_path, 0); 24492 24493 ret_val = xmlNormalizeURIPath(path); 24494 desret_int(ret_val); 24495 call_tests++; 24496 des_char_ptr(n_path, path, 0); 24497 xmlResetLastError(); 24498 if (mem_base != xmlMemBlocks()) { 24499 printf("Leak of %d blocks found in xmlNormalizeURIPath", 24500 xmlMemBlocks() - mem_base); 24501 test_ret++; 24502 printf(" %d", n_path); 24503 printf("\n"); 24504 } 24505 } 24506 function_tests++; 24507 24508 return(test_ret); 24509 } 24510 24511 24512 static int 24513 test_xmlParseURI(void) { 24514 int test_ret = 0; 24515 24516 24517 /* missing type support */ 24518 return(test_ret); 24519 } 24520 24521 24522 static int 24523 test_xmlParseURIRaw(void) { 24524 int test_ret = 0; 24525 24526 24527 /* missing type support */ 24528 return(test_ret); 24529 } 24530 24531 24532 #define gen_nb_xmlURIPtr 1 24533 static xmlURIPtr gen_xmlURIPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 24534 return(NULL); 24535 } 24536 static void des_xmlURIPtr(int no ATTRIBUTE_UNUSED, xmlURIPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 24537 } 24538 24539 static int 24540 test_xmlParseURIReference(void) { 24541 int test_ret = 0; 24542 24543 int mem_base; 24544 int ret_val; 24545 xmlURIPtr uri; /* pointer to an URI structure */ 24546 int n_uri; 24547 char * str; /* the string to analyze */ 24548 int n_str; 24549 24550 for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) { 24551 for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) { 24552 mem_base = xmlMemBlocks(); 24553 uri = gen_xmlURIPtr(n_uri, 0); 24554 str = gen_const_char_ptr(n_str, 1); 24555 24556 ret_val = xmlParseURIReference(uri, (const char *)str); 24557 desret_int(ret_val); 24558 call_tests++; 24559 des_xmlURIPtr(n_uri, uri, 0); 24560 des_const_char_ptr(n_str, (const char *)str, 1); 24561 xmlResetLastError(); 24562 if (mem_base != xmlMemBlocks()) { 24563 printf("Leak of %d blocks found in xmlParseURIReference", 24564 xmlMemBlocks() - mem_base); 24565 test_ret++; 24566 printf(" %d", n_uri); 24567 printf(" %d", n_str); 24568 printf("\n"); 24569 } 24570 } 24571 } 24572 function_tests++; 24573 24574 return(test_ret); 24575 } 24576 24577 24578 static int 24579 test_xmlPathToURI(void) { 24580 int test_ret = 0; 24581 24582 int mem_base; 24583 xmlChar * ret_val; 24584 xmlChar * path; /* the resource locator in a filesystem notation */ 24585 int n_path; 24586 24587 for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) { 24588 mem_base = xmlMemBlocks(); 24589 path = gen_const_xmlChar_ptr(n_path, 0); 24590 24591 ret_val = xmlPathToURI((const xmlChar *)path); 24592 desret_xmlChar_ptr(ret_val); 24593 call_tests++; 24594 des_const_xmlChar_ptr(n_path, (const xmlChar *)path, 0); 24595 xmlResetLastError(); 24596 if (mem_base != xmlMemBlocks()) { 24597 printf("Leak of %d blocks found in xmlPathToURI", 24598 xmlMemBlocks() - mem_base); 24599 test_ret++; 24600 printf(" %d", n_path); 24601 printf("\n"); 24602 } 24603 } 24604 function_tests++; 24605 24606 return(test_ret); 24607 } 24608 24609 24610 static int 24611 test_xmlPrintURI(void) { 24612 int test_ret = 0; 24613 24614 int mem_base; 24615 FILE * stream; /* a FILE* for the output */ 24616 int n_stream; 24617 xmlURIPtr uri; /* pointer to an xmlURI */ 24618 int n_uri; 24619 24620 for (n_stream = 0;n_stream < gen_nb_FILE_ptr;n_stream++) { 24621 for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) { 24622 mem_base = xmlMemBlocks(); 24623 stream = gen_FILE_ptr(n_stream, 0); 24624 uri = gen_xmlURIPtr(n_uri, 1); 24625 24626 xmlPrintURI(stream, uri); 24627 call_tests++; 24628 des_FILE_ptr(n_stream, stream, 0); 24629 des_xmlURIPtr(n_uri, uri, 1); 24630 xmlResetLastError(); 24631 if (mem_base != xmlMemBlocks()) { 24632 printf("Leak of %d blocks found in xmlPrintURI", 24633 xmlMemBlocks() - mem_base); 24634 test_ret++; 24635 printf(" %d", n_stream); 24636 printf(" %d", n_uri); 24637 printf("\n"); 24638 } 24639 } 24640 } 24641 function_tests++; 24642 24643 return(test_ret); 24644 } 24645 24646 24647 static int 24648 test_xmlSaveUri(void) { 24649 int test_ret = 0; 24650 24651 int mem_base; 24652 xmlChar * ret_val; 24653 xmlURIPtr uri; /* pointer to an xmlURI */ 24654 int n_uri; 24655 24656 for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) { 24657 mem_base = xmlMemBlocks(); 24658 uri = gen_xmlURIPtr(n_uri, 0); 24659 24660 ret_val = xmlSaveUri(uri); 24661 desret_xmlChar_ptr(ret_val); 24662 call_tests++; 24663 des_xmlURIPtr(n_uri, uri, 0); 24664 xmlResetLastError(); 24665 if (mem_base != xmlMemBlocks()) { 24666 printf("Leak of %d blocks found in xmlSaveUri", 24667 xmlMemBlocks() - mem_base); 24668 test_ret++; 24669 printf(" %d", n_uri); 24670 printf("\n"); 24671 } 24672 } 24673 function_tests++; 24674 24675 return(test_ret); 24676 } 24677 24678 24679 static int 24680 test_xmlURIEscape(void) { 24681 int test_ret = 0; 24682 24683 int mem_base; 24684 xmlChar * ret_val; 24685 xmlChar * str; /* the string of the URI to escape */ 24686 int n_str; 24687 24688 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 24689 mem_base = xmlMemBlocks(); 24690 str = gen_const_xmlChar_ptr(n_str, 0); 24691 24692 ret_val = xmlURIEscape((const xmlChar *)str); 24693 desret_xmlChar_ptr(ret_val); 24694 call_tests++; 24695 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); 24696 xmlResetLastError(); 24697 if (mem_base != xmlMemBlocks()) { 24698 printf("Leak of %d blocks found in xmlURIEscape", 24699 xmlMemBlocks() - mem_base); 24700 test_ret++; 24701 printf(" %d", n_str); 24702 printf("\n"); 24703 } 24704 } 24705 function_tests++; 24706 24707 return(test_ret); 24708 } 24709 24710 24711 static int 24712 test_xmlURIEscapeStr(void) { 24713 int test_ret = 0; 24714 24715 int mem_base; 24716 xmlChar * ret_val; 24717 xmlChar * str; /* string to escape */ 24718 int n_str; 24719 xmlChar * list; /* exception list string of chars not to escape */ 24720 int n_list; 24721 24722 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 24723 for (n_list = 0;n_list < gen_nb_const_xmlChar_ptr;n_list++) { 24724 mem_base = xmlMemBlocks(); 24725 str = gen_const_xmlChar_ptr(n_str, 0); 24726 list = gen_const_xmlChar_ptr(n_list, 1); 24727 24728 ret_val = xmlURIEscapeStr((const xmlChar *)str, (const xmlChar *)list); 24729 desret_xmlChar_ptr(ret_val); 24730 call_tests++; 24731 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); 24732 des_const_xmlChar_ptr(n_list, (const xmlChar *)list, 1); 24733 xmlResetLastError(); 24734 if (mem_base != xmlMemBlocks()) { 24735 printf("Leak of %d blocks found in xmlURIEscapeStr", 24736 xmlMemBlocks() - mem_base); 24737 test_ret++; 24738 printf(" %d", n_str); 24739 printf(" %d", n_list); 24740 printf("\n"); 24741 } 24742 } 24743 } 24744 function_tests++; 24745 24746 return(test_ret); 24747 } 24748 24749 24750 static int 24751 test_xmlURIUnescapeString(void) { 24752 int test_ret = 0; 24753 24754 24755 /* missing type support */ 24756 return(test_ret); 24757 } 24758 24759 static int 24760 test_uri(void) { 24761 int test_ret = 0; 24762 24763 if (quiet == 0) printf("Testing uri : 10 of 15 functions ...\n"); 24764 test_ret += test_xmlBuildRelativeURI(); 24765 test_ret += test_xmlBuildURI(); 24766 test_ret += test_xmlCanonicPath(); 24767 test_ret += test_xmlCreateURI(); 24768 test_ret += test_xmlNormalizeURIPath(); 24769 test_ret += test_xmlParseURI(); 24770 test_ret += test_xmlParseURIRaw(); 24771 test_ret += test_xmlParseURIReference(); 24772 test_ret += test_xmlPathToURI(); 24773 test_ret += test_xmlPrintURI(); 24774 test_ret += test_xmlSaveUri(); 24775 test_ret += test_xmlURIEscape(); 24776 test_ret += test_xmlURIEscapeStr(); 24777 test_ret += test_xmlURIUnescapeString(); 24778 24779 if (test_ret != 0) 24780 printf("Module uri: %d errors\n", test_ret); 24781 return(test_ret); 24782 } 24783 24784 static int 24785 test_xmlAddAttributeDecl(void) { 24786 int test_ret = 0; 24787 24788 int mem_base; 24789 xmlAttributePtr ret_val; 24790 xmlValidCtxtPtr ctxt; /* the validation context */ 24791 int n_ctxt; 24792 xmlDtdPtr dtd; /* pointer to the DTD */ 24793 int n_dtd; 24794 xmlChar * elem; /* the element name */ 24795 int n_elem; 24796 xmlChar * name; /* the attribute name */ 24797 int n_name; 24798 xmlChar * ns; /* the attribute namespace prefix */ 24799 int n_ns; 24800 xmlAttributeType type; /* the attribute type */ 24801 int n_type; 24802 xmlAttributeDefault def; /* the attribute default type */ 24803 int n_def; 24804 xmlChar * defaultValue; /* the attribute default value */ 24805 int n_defaultValue; 24806 xmlEnumerationPtr tree; /* if it's an enumeration, the associated list */ 24807 int n_tree; 24808 24809 for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { 24810 for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) { 24811 for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) { 24812 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 24813 for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) { 24814 for (n_type = 0;n_type < gen_nb_xmlAttributeType;n_type++) { 24815 for (n_def = 0;n_def < gen_nb_xmlAttributeDefault;n_def++) { 24816 for (n_defaultValue = 0;n_defaultValue < gen_nb_const_xmlChar_ptr;n_defaultValue++) { 24817 for (n_tree = 0;n_tree < gen_nb_xmlEnumerationPtr;n_tree++) { 24818 mem_base = xmlMemBlocks(); 24819 ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0); 24820 dtd = gen_xmlDtdPtr(n_dtd, 1); 24821 elem = gen_const_xmlChar_ptr(n_elem, 2); 24822 name = gen_const_xmlChar_ptr(n_name, 3); 24823 ns = gen_const_xmlChar_ptr(n_ns, 4); 24824 type = gen_xmlAttributeType(n_type, 5); 24825 def = gen_xmlAttributeDefault(n_def, 6); 24826 defaultValue = gen_const_xmlChar_ptr(n_defaultValue, 7); 24827 tree = gen_xmlEnumerationPtr(n_tree, 8); 24828 24829 ret_val = xmlAddAttributeDecl(ctxt, dtd, (const xmlChar *)elem, (const xmlChar *)name, (const xmlChar *)ns, type, def, (const xmlChar *)defaultValue, tree); 24830 desret_xmlAttributePtr(ret_val); 24831 call_tests++; 24832 des_xmlValidCtxtPtr(n_ctxt, ctxt, 0); 24833 des_xmlDtdPtr(n_dtd, dtd, 1); 24834 des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 2); 24835 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 3); 24836 des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 4); 24837 des_xmlAttributeType(n_type, type, 5); 24838 des_xmlAttributeDefault(n_def, def, 6); 24839 des_const_xmlChar_ptr(n_defaultValue, (const xmlChar *)defaultValue, 7); 24840 des_xmlEnumerationPtr(n_tree, tree, 8); 24841 xmlResetLastError(); 24842 if (mem_base != xmlMemBlocks()) { 24843 printf("Leak of %d blocks found in xmlAddAttributeDecl", 24844 xmlMemBlocks() - mem_base); 24845 test_ret++; 24846 printf(" %d", n_ctxt); 24847 printf(" %d", n_dtd); 24848 printf(" %d", n_elem); 24849 printf(" %d", n_name); 24850 printf(" %d", n_ns); 24851 printf(" %d", n_type); 24852 printf(" %d", n_def); 24853 printf(" %d", n_defaultValue); 24854 printf(" %d", n_tree); 24855 printf("\n"); 24856 } 24857 } 24858 } 24859 } 24860 } 24861 } 24862 } 24863 } 24864 } 24865 } 24866 function_tests++; 24867 24868 return(test_ret); 24869 } 24870 24871 24872 static int 24873 test_xmlAddElementDecl(void) { 24874 int test_ret = 0; 24875 24876 int mem_base; 24877 xmlElementPtr ret_val; 24878 xmlValidCtxtPtr ctxt; /* the validation context */ 24879 int n_ctxt; 24880 xmlDtdPtr dtd; /* pointer to the DTD */ 24881 int n_dtd; 24882 xmlChar * name; /* the entity name */ 24883 int n_name; 24884 xmlElementTypeVal type; /* the element type */ 24885 int n_type; 24886 xmlElementContentPtr content; /* the element content tree or NULL */ 24887 int n_content; 24888 24889 for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { 24890 for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) { 24891 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 24892 for (n_type = 0;n_type < gen_nb_xmlElementTypeVal;n_type++) { 24893 for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) { 24894 mem_base = xmlMemBlocks(); 24895 ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0); 24896 dtd = gen_xmlDtdPtr(n_dtd, 1); 24897 name = gen_const_xmlChar_ptr(n_name, 2); 24898 type = gen_xmlElementTypeVal(n_type, 3); 24899 content = gen_xmlElementContentPtr(n_content, 4); 24900 24901 ret_val = xmlAddElementDecl(ctxt, dtd, (const xmlChar *)name, type, content); 24902 desret_xmlElementPtr(ret_val); 24903 call_tests++; 24904 des_xmlValidCtxtPtr(n_ctxt, ctxt, 0); 24905 des_xmlDtdPtr(n_dtd, dtd, 1); 24906 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 24907 des_xmlElementTypeVal(n_type, type, 3); 24908 des_xmlElementContentPtr(n_content, content, 4); 24909 xmlResetLastError(); 24910 if (mem_base != xmlMemBlocks()) { 24911 printf("Leak of %d blocks found in xmlAddElementDecl", 24912 xmlMemBlocks() - mem_base); 24913 test_ret++; 24914 printf(" %d", n_ctxt); 24915 printf(" %d", n_dtd); 24916 printf(" %d", n_name); 24917 printf(" %d", n_type); 24918 printf(" %d", n_content); 24919 printf("\n"); 24920 } 24921 } 24922 } 24923 } 24924 } 24925 } 24926 function_tests++; 24927 24928 return(test_ret); 24929 } 24930 24931 24932 static int 24933 test_xmlAddID(void) { 24934 int test_ret = 0; 24935 24936 24937 /* missing type support */ 24938 return(test_ret); 24939 } 24940 24941 24942 static int 24943 test_xmlAddNotationDecl(void) { 24944 int test_ret = 0; 24945 24946 24947 /* missing type support */ 24948 return(test_ret); 24949 } 24950 24951 24952 static int 24953 test_xmlAddRef(void) { 24954 int test_ret = 0; 24955 24956 24957 /* missing type support */ 24958 return(test_ret); 24959 } 24960 24961 24962 #define gen_nb_xmlAttributeTablePtr 1 24963 static xmlAttributeTablePtr gen_xmlAttributeTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 24964 return(NULL); 24965 } 24966 static void des_xmlAttributeTablePtr(int no ATTRIBUTE_UNUSED, xmlAttributeTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 24967 } 24968 24969 static int 24970 test_xmlCopyAttributeTable(void) { 24971 int test_ret = 0; 24972 24973 24974 /* missing type support */ 24975 return(test_ret); 24976 } 24977 24978 24979 static int 24980 test_xmlCopyDocElementContent(void) { 24981 int test_ret = 0; 24982 24983 int mem_base; 24984 xmlElementContentPtr ret_val; 24985 xmlDocPtr doc; /* the document owning the element declaration */ 24986 int n_doc; 24987 xmlElementContentPtr cur; /* An element content pointer. */ 24988 int n_cur; 24989 24990 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 24991 for (n_cur = 0;n_cur < gen_nb_xmlElementContentPtr;n_cur++) { 24992 mem_base = xmlMemBlocks(); 24993 doc = gen_xmlDocPtr(n_doc, 0); 24994 cur = gen_xmlElementContentPtr(n_cur, 1); 24995 24996 ret_val = xmlCopyDocElementContent(doc, cur); 24997 desret_xmlElementContentPtr(ret_val); 24998 call_tests++; 24999 des_xmlDocPtr(n_doc, doc, 0); 25000 des_xmlElementContentPtr(n_cur, cur, 1); 25001 xmlResetLastError(); 25002 if (mem_base != xmlMemBlocks()) { 25003 printf("Leak of %d blocks found in xmlCopyDocElementContent", 25004 xmlMemBlocks() - mem_base); 25005 test_ret++; 25006 printf(" %d", n_doc); 25007 printf(" %d", n_cur); 25008 printf("\n"); 25009 } 25010 } 25011 } 25012 function_tests++; 25013 25014 return(test_ret); 25015 } 25016 25017 25018 static int 25019 test_xmlCopyElementContent(void) { 25020 int test_ret = 0; 25021 25022 int mem_base; 25023 xmlElementContentPtr ret_val; 25024 xmlElementContentPtr cur; /* An element content pointer. */ 25025 int n_cur; 25026 25027 for (n_cur = 0;n_cur < gen_nb_xmlElementContentPtr;n_cur++) { 25028 mem_base = xmlMemBlocks(); 25029 cur = gen_xmlElementContentPtr(n_cur, 0); 25030 25031 ret_val = xmlCopyElementContent(cur); 25032 desret_xmlElementContentPtr(ret_val); 25033 call_tests++; 25034 des_xmlElementContentPtr(n_cur, cur, 0); 25035 xmlResetLastError(); 25036 if (mem_base != xmlMemBlocks()) { 25037 printf("Leak of %d blocks found in xmlCopyElementContent", 25038 xmlMemBlocks() - mem_base); 25039 test_ret++; 25040 printf(" %d", n_cur); 25041 printf("\n"); 25042 } 25043 } 25044 function_tests++; 25045 25046 return(test_ret); 25047 } 25048 25049 25050 #define gen_nb_xmlElementTablePtr 1 25051 static xmlElementTablePtr gen_xmlElementTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 25052 return(NULL); 25053 } 25054 static void des_xmlElementTablePtr(int no ATTRIBUTE_UNUSED, xmlElementTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 25055 } 25056 25057 static int 25058 test_xmlCopyElementTable(void) { 25059 int test_ret = 0; 25060 25061 25062 /* missing type support */ 25063 return(test_ret); 25064 } 25065 25066 25067 static int 25068 test_xmlCopyEnumeration(void) { 25069 int test_ret = 0; 25070 25071 25072 /* missing type support */ 25073 return(test_ret); 25074 } 25075 25076 25077 #define gen_nb_xmlNotationTablePtr 1 25078 static xmlNotationTablePtr gen_xmlNotationTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 25079 return(NULL); 25080 } 25081 static void des_xmlNotationTablePtr(int no ATTRIBUTE_UNUSED, xmlNotationTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 25082 } 25083 25084 static int 25085 test_xmlCopyNotationTable(void) { 25086 int test_ret = 0; 25087 25088 25089 /* missing type support */ 25090 return(test_ret); 25091 } 25092 25093 25094 static int 25095 test_xmlCreateEnumeration(void) { 25096 int test_ret = 0; 25097 25098 25099 /* missing type support */ 25100 return(test_ret); 25101 } 25102 25103 25104 #define gen_nb_xmlAttributePtr 1 25105 static xmlAttributePtr gen_xmlAttributePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 25106 return(NULL); 25107 } 25108 static void des_xmlAttributePtr(int no ATTRIBUTE_UNUSED, xmlAttributePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 25109 } 25110 25111 static int 25112 test_xmlDumpAttributeDecl(void) { 25113 int test_ret = 0; 25114 25115 #if defined(LIBXML_OUTPUT_ENABLED) 25116 int mem_base; 25117 xmlBufferPtr buf; /* the XML buffer output */ 25118 int n_buf; 25119 xmlAttributePtr attr; /* An attribute declaration */ 25120 int n_attr; 25121 25122 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 25123 for (n_attr = 0;n_attr < gen_nb_xmlAttributePtr;n_attr++) { 25124 mem_base = xmlMemBlocks(); 25125 buf = gen_xmlBufferPtr(n_buf, 0); 25126 attr = gen_xmlAttributePtr(n_attr, 1); 25127 25128 xmlDumpAttributeDecl(buf, attr); 25129 call_tests++; 25130 des_xmlBufferPtr(n_buf, buf, 0); 25131 des_xmlAttributePtr(n_attr, attr, 1); 25132 xmlResetLastError(); 25133 if (mem_base != xmlMemBlocks()) { 25134 printf("Leak of %d blocks found in xmlDumpAttributeDecl", 25135 xmlMemBlocks() - mem_base); 25136 test_ret++; 25137 printf(" %d", n_buf); 25138 printf(" %d", n_attr); 25139 printf("\n"); 25140 } 25141 } 25142 } 25143 function_tests++; 25144 #endif 25145 25146 return(test_ret); 25147 } 25148 25149 25150 static int 25151 test_xmlDumpAttributeTable(void) { 25152 int test_ret = 0; 25153 25154 #if defined(LIBXML_OUTPUT_ENABLED) 25155 int mem_base; 25156 xmlBufferPtr buf; /* the XML buffer output */ 25157 int n_buf; 25158 xmlAttributeTablePtr table; /* An attribute table */ 25159 int n_table; 25160 25161 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 25162 for (n_table = 0;n_table < gen_nb_xmlAttributeTablePtr;n_table++) { 25163 mem_base = xmlMemBlocks(); 25164 buf = gen_xmlBufferPtr(n_buf, 0); 25165 table = gen_xmlAttributeTablePtr(n_table, 1); 25166 25167 xmlDumpAttributeTable(buf, table); 25168 call_tests++; 25169 des_xmlBufferPtr(n_buf, buf, 0); 25170 des_xmlAttributeTablePtr(n_table, table, 1); 25171 xmlResetLastError(); 25172 if (mem_base != xmlMemBlocks()) { 25173 printf("Leak of %d blocks found in xmlDumpAttributeTable", 25174 xmlMemBlocks() - mem_base); 25175 test_ret++; 25176 printf(" %d", n_buf); 25177 printf(" %d", n_table); 25178 printf("\n"); 25179 } 25180 } 25181 } 25182 function_tests++; 25183 #endif 25184 25185 return(test_ret); 25186 } 25187 25188 25189 #define gen_nb_xmlElementPtr 1 25190 static xmlElementPtr gen_xmlElementPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 25191 return(NULL); 25192 } 25193 static void des_xmlElementPtr(int no ATTRIBUTE_UNUSED, xmlElementPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 25194 } 25195 25196 static int 25197 test_xmlDumpElementDecl(void) { 25198 int test_ret = 0; 25199 25200 #if defined(LIBXML_OUTPUT_ENABLED) 25201 int mem_base; 25202 xmlBufferPtr buf; /* the XML buffer output */ 25203 int n_buf; 25204 xmlElementPtr elem; /* An element table */ 25205 int n_elem; 25206 25207 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 25208 for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) { 25209 mem_base = xmlMemBlocks(); 25210 buf = gen_xmlBufferPtr(n_buf, 0); 25211 elem = gen_xmlElementPtr(n_elem, 1); 25212 25213 xmlDumpElementDecl(buf, elem); 25214 call_tests++; 25215 des_xmlBufferPtr(n_buf, buf, 0); 25216 des_xmlElementPtr(n_elem, elem, 1); 25217 xmlResetLastError(); 25218 if (mem_base != xmlMemBlocks()) { 25219 printf("Leak of %d blocks found in xmlDumpElementDecl", 25220 xmlMemBlocks() - mem_base); 25221 test_ret++; 25222 printf(" %d", n_buf); 25223 printf(" %d", n_elem); 25224 printf("\n"); 25225 } 25226 } 25227 } 25228 function_tests++; 25229 #endif 25230 25231 return(test_ret); 25232 } 25233 25234 25235 static int 25236 test_xmlDumpElementTable(void) { 25237 int test_ret = 0; 25238 25239 #if defined(LIBXML_OUTPUT_ENABLED) 25240 int mem_base; 25241 xmlBufferPtr buf; /* the XML buffer output */ 25242 int n_buf; 25243 xmlElementTablePtr table; /* An element table */ 25244 int n_table; 25245 25246 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 25247 for (n_table = 0;n_table < gen_nb_xmlElementTablePtr;n_table++) { 25248 mem_base = xmlMemBlocks(); 25249 buf = gen_xmlBufferPtr(n_buf, 0); 25250 table = gen_xmlElementTablePtr(n_table, 1); 25251 25252 xmlDumpElementTable(buf, table); 25253 call_tests++; 25254 des_xmlBufferPtr(n_buf, buf, 0); 25255 des_xmlElementTablePtr(n_table, table, 1); 25256 xmlResetLastError(); 25257 if (mem_base != xmlMemBlocks()) { 25258 printf("Leak of %d blocks found in xmlDumpElementTable", 25259 xmlMemBlocks() - mem_base); 25260 test_ret++; 25261 printf(" %d", n_buf); 25262 printf(" %d", n_table); 25263 printf("\n"); 25264 } 25265 } 25266 } 25267 function_tests++; 25268 #endif 25269 25270 return(test_ret); 25271 } 25272 25273 25274 #define gen_nb_xmlNotationPtr 1 25275 static xmlNotationPtr gen_xmlNotationPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 25276 return(NULL); 25277 } 25278 static void des_xmlNotationPtr(int no ATTRIBUTE_UNUSED, xmlNotationPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 25279 } 25280 25281 static int 25282 test_xmlDumpNotationDecl(void) { 25283 int test_ret = 0; 25284 25285 #if defined(LIBXML_OUTPUT_ENABLED) 25286 int mem_base; 25287 xmlBufferPtr buf; /* the XML buffer output */ 25288 int n_buf; 25289 xmlNotationPtr nota; /* A notation declaration */ 25290 int n_nota; 25291 25292 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 25293 for (n_nota = 0;n_nota < gen_nb_xmlNotationPtr;n_nota++) { 25294 mem_base = xmlMemBlocks(); 25295 buf = gen_xmlBufferPtr(n_buf, 0); 25296 nota = gen_xmlNotationPtr(n_nota, 1); 25297 25298 xmlDumpNotationDecl(buf, nota); 25299 call_tests++; 25300 des_xmlBufferPtr(n_buf, buf, 0); 25301 des_xmlNotationPtr(n_nota, nota, 1); 25302 xmlResetLastError(); 25303 if (mem_base != xmlMemBlocks()) { 25304 printf("Leak of %d blocks found in xmlDumpNotationDecl", 25305 xmlMemBlocks() - mem_base); 25306 test_ret++; 25307 printf(" %d", n_buf); 25308 printf(" %d", n_nota); 25309 printf("\n"); 25310 } 25311 } 25312 } 25313 function_tests++; 25314 #endif 25315 25316 return(test_ret); 25317 } 25318 25319 25320 static int 25321 test_xmlDumpNotationTable(void) { 25322 int test_ret = 0; 25323 25324 #if defined(LIBXML_OUTPUT_ENABLED) 25325 int mem_base; 25326 xmlBufferPtr buf; /* the XML buffer output */ 25327 int n_buf; 25328 xmlNotationTablePtr table; /* A notation table */ 25329 int n_table; 25330 25331 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 25332 for (n_table = 0;n_table < gen_nb_xmlNotationTablePtr;n_table++) { 25333 mem_base = xmlMemBlocks(); 25334 buf = gen_xmlBufferPtr(n_buf, 0); 25335 table = gen_xmlNotationTablePtr(n_table, 1); 25336 25337 xmlDumpNotationTable(buf, table); 25338 call_tests++; 25339 des_xmlBufferPtr(n_buf, buf, 0); 25340 des_xmlNotationTablePtr(n_table, table, 1); 25341 xmlResetLastError(); 25342 if (mem_base != xmlMemBlocks()) { 25343 printf("Leak of %d blocks found in xmlDumpNotationTable", 25344 xmlMemBlocks() - mem_base); 25345 test_ret++; 25346 printf(" %d", n_buf); 25347 printf(" %d", n_table); 25348 printf("\n"); 25349 } 25350 } 25351 } 25352 function_tests++; 25353 #endif 25354 25355 return(test_ret); 25356 } 25357 25358 25359 static int 25360 test_xmlGetDtdAttrDesc(void) { 25361 int test_ret = 0; 25362 25363 int mem_base; 25364 xmlAttributePtr ret_val; 25365 xmlDtdPtr dtd; /* a pointer to the DtD to search */ 25366 int n_dtd; 25367 xmlChar * elem; /* the element name */ 25368 int n_elem; 25369 xmlChar * name; /* the attribute name */ 25370 int n_name; 25371 25372 for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) { 25373 for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) { 25374 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 25375 mem_base = xmlMemBlocks(); 25376 dtd = gen_xmlDtdPtr(n_dtd, 0); 25377 elem = gen_const_xmlChar_ptr(n_elem, 1); 25378 name = gen_const_xmlChar_ptr(n_name, 2); 25379 25380 ret_val = xmlGetDtdAttrDesc(dtd, (const xmlChar *)elem, (const xmlChar *)name); 25381 desret_xmlAttributePtr(ret_val); 25382 call_tests++; 25383 des_xmlDtdPtr(n_dtd, dtd, 0); 25384 des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 1); 25385 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 25386 xmlResetLastError(); 25387 if (mem_base != xmlMemBlocks()) { 25388 printf("Leak of %d blocks found in xmlGetDtdAttrDesc", 25389 xmlMemBlocks() - mem_base); 25390 test_ret++; 25391 printf(" %d", n_dtd); 25392 printf(" %d", n_elem); 25393 printf(" %d", n_name); 25394 printf("\n"); 25395 } 25396 } 25397 } 25398 } 25399 function_tests++; 25400 25401 return(test_ret); 25402 } 25403 25404 25405 static int 25406 test_xmlGetDtdElementDesc(void) { 25407 int test_ret = 0; 25408 25409 int mem_base; 25410 xmlElementPtr ret_val; 25411 xmlDtdPtr dtd; /* a pointer to the DtD to search */ 25412 int n_dtd; 25413 xmlChar * name; /* the element name */ 25414 int n_name; 25415 25416 for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) { 25417 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 25418 mem_base = xmlMemBlocks(); 25419 dtd = gen_xmlDtdPtr(n_dtd, 0); 25420 name = gen_const_xmlChar_ptr(n_name, 1); 25421 25422 ret_val = xmlGetDtdElementDesc(dtd, (const xmlChar *)name); 25423 desret_xmlElementPtr(ret_val); 25424 call_tests++; 25425 des_xmlDtdPtr(n_dtd, dtd, 0); 25426 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 25427 xmlResetLastError(); 25428 if (mem_base != xmlMemBlocks()) { 25429 printf("Leak of %d blocks found in xmlGetDtdElementDesc", 25430 xmlMemBlocks() - mem_base); 25431 test_ret++; 25432 printf(" %d", n_dtd); 25433 printf(" %d", n_name); 25434 printf("\n"); 25435 } 25436 } 25437 } 25438 function_tests++; 25439 25440 return(test_ret); 25441 } 25442 25443 25444 static int 25445 test_xmlGetDtdNotationDesc(void) { 25446 int test_ret = 0; 25447 25448 25449 /* missing type support */ 25450 return(test_ret); 25451 } 25452 25453 25454 static int 25455 test_xmlGetDtdQAttrDesc(void) { 25456 int test_ret = 0; 25457 25458 int mem_base; 25459 xmlAttributePtr ret_val; 25460 xmlDtdPtr dtd; /* a pointer to the DtD to search */ 25461 int n_dtd; 25462 xmlChar * elem; /* the element name */ 25463 int n_elem; 25464 xmlChar * name; /* the attribute name */ 25465 int n_name; 25466 xmlChar * prefix; /* the attribute namespace prefix */ 25467 int n_prefix; 25468 25469 for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) { 25470 for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) { 25471 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 25472 for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) { 25473 mem_base = xmlMemBlocks(); 25474 dtd = gen_xmlDtdPtr(n_dtd, 0); 25475 elem = gen_const_xmlChar_ptr(n_elem, 1); 25476 name = gen_const_xmlChar_ptr(n_name, 2); 25477 prefix = gen_const_xmlChar_ptr(n_prefix, 3); 25478 25479 ret_val = xmlGetDtdQAttrDesc(dtd, (const xmlChar *)elem, (const xmlChar *)name, (const xmlChar *)prefix); 25480 desret_xmlAttributePtr(ret_val); 25481 call_tests++; 25482 des_xmlDtdPtr(n_dtd, dtd, 0); 25483 des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 1); 25484 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 25485 des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 3); 25486 xmlResetLastError(); 25487 if (mem_base != xmlMemBlocks()) { 25488 printf("Leak of %d blocks found in xmlGetDtdQAttrDesc", 25489 xmlMemBlocks() - mem_base); 25490 test_ret++; 25491 printf(" %d", n_dtd); 25492 printf(" %d", n_elem); 25493 printf(" %d", n_name); 25494 printf(" %d", n_prefix); 25495 printf("\n"); 25496 } 25497 } 25498 } 25499 } 25500 } 25501 function_tests++; 25502 25503 return(test_ret); 25504 } 25505 25506 25507 static int 25508 test_xmlGetDtdQElementDesc(void) { 25509 int test_ret = 0; 25510 25511 int mem_base; 25512 xmlElementPtr ret_val; 25513 xmlDtdPtr dtd; /* a pointer to the DtD to search */ 25514 int n_dtd; 25515 xmlChar * name; /* the element name */ 25516 int n_name; 25517 xmlChar * prefix; /* the element namespace prefix */ 25518 int n_prefix; 25519 25520 for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) { 25521 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 25522 for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) { 25523 mem_base = xmlMemBlocks(); 25524 dtd = gen_xmlDtdPtr(n_dtd, 0); 25525 name = gen_const_xmlChar_ptr(n_name, 1); 25526 prefix = gen_const_xmlChar_ptr(n_prefix, 2); 25527 25528 ret_val = xmlGetDtdQElementDesc(dtd, (const xmlChar *)name, (const xmlChar *)prefix); 25529 desret_xmlElementPtr(ret_val); 25530 call_tests++; 25531 des_xmlDtdPtr(n_dtd, dtd, 0); 25532 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 25533 des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2); 25534 xmlResetLastError(); 25535 if (mem_base != xmlMemBlocks()) { 25536 printf("Leak of %d blocks found in xmlGetDtdQElementDesc", 25537 xmlMemBlocks() - mem_base); 25538 test_ret++; 25539 printf(" %d", n_dtd); 25540 printf(" %d", n_name); 25541 printf(" %d", n_prefix); 25542 printf("\n"); 25543 } 25544 } 25545 } 25546 } 25547 function_tests++; 25548 25549 return(test_ret); 25550 } 25551 25552 25553 static int 25554 test_xmlGetID(void) { 25555 int test_ret = 0; 25556 25557 int mem_base; 25558 xmlAttrPtr ret_val; 25559 xmlDocPtr doc; /* pointer to the document */ 25560 int n_doc; 25561 xmlChar * ID; /* the ID value */ 25562 int n_ID; 25563 25564 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 25565 for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) { 25566 mem_base = xmlMemBlocks(); 25567 doc = gen_xmlDocPtr(n_doc, 0); 25568 ID = gen_const_xmlChar_ptr(n_ID, 1); 25569 25570 ret_val = xmlGetID(doc, (const xmlChar *)ID); 25571 desret_xmlAttrPtr(ret_val); 25572 call_tests++; 25573 des_xmlDocPtr(n_doc, doc, 0); 25574 des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 1); 25575 xmlResetLastError(); 25576 if (mem_base != xmlMemBlocks()) { 25577 printf("Leak of %d blocks found in xmlGetID", 25578 xmlMemBlocks() - mem_base); 25579 test_ret++; 25580 printf(" %d", n_doc); 25581 printf(" %d", n_ID); 25582 printf("\n"); 25583 } 25584 } 25585 } 25586 function_tests++; 25587 25588 return(test_ret); 25589 } 25590 25591 25592 static int 25593 test_xmlGetRefs(void) { 25594 int test_ret = 0; 25595 25596 25597 /* missing type support */ 25598 return(test_ret); 25599 } 25600 25601 25602 static int 25603 test_xmlIsID(void) { 25604 int test_ret = 0; 25605 25606 int mem_base; 25607 int ret_val; 25608 xmlDocPtr doc; /* the document */ 25609 int n_doc; 25610 xmlNodePtr elem; /* the element carrying the attribute */ 25611 int n_elem; 25612 xmlAttrPtr attr; /* the attribute */ 25613 int n_attr; 25614 25615 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 25616 for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) { 25617 for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) { 25618 mem_base = xmlMemBlocks(); 25619 doc = gen_xmlDocPtr(n_doc, 0); 25620 elem = gen_xmlNodePtr(n_elem, 1); 25621 attr = gen_xmlAttrPtr(n_attr, 2); 25622 25623 ret_val = xmlIsID(doc, elem, attr); 25624 desret_int(ret_val); 25625 call_tests++; 25626 des_xmlDocPtr(n_doc, doc, 0); 25627 des_xmlNodePtr(n_elem, elem, 1); 25628 des_xmlAttrPtr(n_attr, attr, 2); 25629 xmlResetLastError(); 25630 if (mem_base != xmlMemBlocks()) { 25631 printf("Leak of %d blocks found in xmlIsID", 25632 xmlMemBlocks() - mem_base); 25633 test_ret++; 25634 printf(" %d", n_doc); 25635 printf(" %d", n_elem); 25636 printf(" %d", n_attr); 25637 printf("\n"); 25638 } 25639 } 25640 } 25641 } 25642 function_tests++; 25643 25644 return(test_ret); 25645 } 25646 25647 25648 static int 25649 test_xmlIsMixedElement(void) { 25650 int test_ret = 0; 25651 25652 int mem_base; 25653 int ret_val; 25654 xmlDocPtr doc; /* the document */ 25655 int n_doc; 25656 xmlChar * name; /* the element name */ 25657 int n_name; 25658 25659 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 25660 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 25661 mem_base = xmlMemBlocks(); 25662 doc = gen_xmlDocPtr(n_doc, 0); 25663 name = gen_const_xmlChar_ptr(n_name, 1); 25664 25665 ret_val = xmlIsMixedElement(doc, (const xmlChar *)name); 25666 desret_int(ret_val); 25667 call_tests++; 25668 des_xmlDocPtr(n_doc, doc, 0); 25669 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 25670 xmlResetLastError(); 25671 if (mem_base != xmlMemBlocks()) { 25672 printf("Leak of %d blocks found in xmlIsMixedElement", 25673 xmlMemBlocks() - mem_base); 25674 test_ret++; 25675 printf(" %d", n_doc); 25676 printf(" %d", n_name); 25677 printf("\n"); 25678 } 25679 } 25680 } 25681 function_tests++; 25682 25683 return(test_ret); 25684 } 25685 25686 25687 static int 25688 test_xmlIsRef(void) { 25689 int test_ret = 0; 25690 25691 int mem_base; 25692 int ret_val; 25693 xmlDocPtr doc; /* the document */ 25694 int n_doc; 25695 xmlNodePtr elem; /* the element carrying the attribute */ 25696 int n_elem; 25697 xmlAttrPtr attr; /* the attribute */ 25698 int n_attr; 25699 25700 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 25701 for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) { 25702 for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) { 25703 mem_base = xmlMemBlocks(); 25704 doc = gen_xmlDocPtr(n_doc, 0); 25705 elem = gen_xmlNodePtr(n_elem, 1); 25706 attr = gen_xmlAttrPtr(n_attr, 2); 25707 25708 ret_val = xmlIsRef(doc, elem, attr); 25709 desret_int(ret_val); 25710 call_tests++; 25711 des_xmlDocPtr(n_doc, doc, 0); 25712 des_xmlNodePtr(n_elem, elem, 1); 25713 des_xmlAttrPtr(n_attr, attr, 2); 25714 xmlResetLastError(); 25715 if (mem_base != xmlMemBlocks()) { 25716 printf("Leak of %d blocks found in xmlIsRef", 25717 xmlMemBlocks() - mem_base); 25718 test_ret++; 25719 printf(" %d", n_doc); 25720 printf(" %d", n_elem); 25721 printf(" %d", n_attr); 25722 printf("\n"); 25723 } 25724 } 25725 } 25726 } 25727 function_tests++; 25728 25729 return(test_ret); 25730 } 25731 25732 25733 static int 25734 test_xmlNewDocElementContent(void) { 25735 int test_ret = 0; 25736 25737 int mem_base; 25738 xmlElementContentPtr ret_val; 25739 xmlDocPtr doc; /* the document */ 25740 int n_doc; 25741 xmlChar * name; /* the subelement name or NULL */ 25742 int n_name; 25743 xmlElementContentType type; /* the type of element content decl */ 25744 int n_type; 25745 25746 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 25747 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 25748 for (n_type = 0;n_type < gen_nb_xmlElementContentType;n_type++) { 25749 mem_base = xmlMemBlocks(); 25750 doc = gen_xmlDocPtr(n_doc, 0); 25751 name = gen_const_xmlChar_ptr(n_name, 1); 25752 type = gen_xmlElementContentType(n_type, 2); 25753 25754 ret_val = xmlNewDocElementContent(doc, (const xmlChar *)name, type); 25755 xmlFreeDocElementContent(doc, ret_val); ret_val = NULL; 25756 desret_xmlElementContentPtr(ret_val); 25757 call_tests++; 25758 des_xmlDocPtr(n_doc, doc, 0); 25759 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 25760 des_xmlElementContentType(n_type, type, 2); 25761 xmlResetLastError(); 25762 if (mem_base != xmlMemBlocks()) { 25763 printf("Leak of %d blocks found in xmlNewDocElementContent", 25764 xmlMemBlocks() - mem_base); 25765 test_ret++; 25766 printf(" %d", n_doc); 25767 printf(" %d", n_name); 25768 printf(" %d", n_type); 25769 printf("\n"); 25770 } 25771 } 25772 } 25773 } 25774 function_tests++; 25775 25776 return(test_ret); 25777 } 25778 25779 25780 static int 25781 test_xmlNewElementContent(void) { 25782 int test_ret = 0; 25783 25784 int mem_base; 25785 xmlElementContentPtr ret_val; 25786 xmlChar * name; /* the subelement name or NULL */ 25787 int n_name; 25788 xmlElementContentType type; /* the type of element content decl */ 25789 int n_type; 25790 25791 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 25792 for (n_type = 0;n_type < gen_nb_xmlElementContentType;n_type++) { 25793 mem_base = xmlMemBlocks(); 25794 name = gen_const_xmlChar_ptr(n_name, 0); 25795 type = gen_xmlElementContentType(n_type, 1); 25796 25797 ret_val = xmlNewElementContent((const xmlChar *)name, type); 25798 desret_xmlElementContentPtr(ret_val); 25799 call_tests++; 25800 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0); 25801 des_xmlElementContentType(n_type, type, 1); 25802 xmlResetLastError(); 25803 if (mem_base != xmlMemBlocks()) { 25804 printf("Leak of %d blocks found in xmlNewElementContent", 25805 xmlMemBlocks() - mem_base); 25806 test_ret++; 25807 printf(" %d", n_name); 25808 printf(" %d", n_type); 25809 printf("\n"); 25810 } 25811 } 25812 } 25813 function_tests++; 25814 25815 return(test_ret); 25816 } 25817 25818 25819 static int 25820 test_xmlNewValidCtxt(void) { 25821 int test_ret = 0; 25822 25823 25824 /* missing type support */ 25825 return(test_ret); 25826 } 25827 25828 25829 static int 25830 test_xmlRemoveID(void) { 25831 int test_ret = 0; 25832 25833 int mem_base; 25834 int ret_val; 25835 xmlDocPtr doc; /* the document */ 25836 int n_doc; 25837 xmlAttrPtr attr; /* the attribute */ 25838 int n_attr; 25839 25840 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 25841 for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) { 25842 mem_base = xmlMemBlocks(); 25843 doc = gen_xmlDocPtr(n_doc, 0); 25844 attr = gen_xmlAttrPtr(n_attr, 1); 25845 25846 ret_val = xmlRemoveID(doc, attr); 25847 desret_int(ret_val); 25848 call_tests++; 25849 des_xmlDocPtr(n_doc, doc, 0); 25850 des_xmlAttrPtr(n_attr, attr, 1); 25851 xmlResetLastError(); 25852 if (mem_base != xmlMemBlocks()) { 25853 printf("Leak of %d blocks found in xmlRemoveID", 25854 xmlMemBlocks() - mem_base); 25855 test_ret++; 25856 printf(" %d", n_doc); 25857 printf(" %d", n_attr); 25858 printf("\n"); 25859 } 25860 } 25861 } 25862 function_tests++; 25863 25864 return(test_ret); 25865 } 25866 25867 25868 static int 25869 test_xmlRemoveRef(void) { 25870 int test_ret = 0; 25871 25872 int mem_base; 25873 int ret_val; 25874 xmlDocPtr doc; /* the document */ 25875 int n_doc; 25876 xmlAttrPtr attr; /* the attribute */ 25877 int n_attr; 25878 25879 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 25880 for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) { 25881 mem_base = xmlMemBlocks(); 25882 doc = gen_xmlDocPtr(n_doc, 0); 25883 attr = gen_xmlAttrPtr(n_attr, 1); 25884 25885 ret_val = xmlRemoveRef(doc, attr); 25886 desret_int(ret_val); 25887 call_tests++; 25888 des_xmlDocPtr(n_doc, doc, 0); 25889 des_xmlAttrPtr(n_attr, attr, 1); 25890 xmlResetLastError(); 25891 if (mem_base != xmlMemBlocks()) { 25892 printf("Leak of %d blocks found in xmlRemoveRef", 25893 xmlMemBlocks() - mem_base); 25894 test_ret++; 25895 printf(" %d", n_doc); 25896 printf(" %d", n_attr); 25897 printf("\n"); 25898 } 25899 } 25900 } 25901 function_tests++; 25902 25903 return(test_ret); 25904 } 25905 25906 25907 static int 25908 test_xmlSnprintfElementContent(void) { 25909 int test_ret = 0; 25910 25911 int mem_base; 25912 char * buf; /* an output buffer */ 25913 int n_buf; 25914 int size; /* the buffer size */ 25915 int n_size; 25916 xmlElementContentPtr content; /* An element table */ 25917 int n_content; 25918 int englob; /* 1 if one must print the englobing parenthesis, 0 otherwise */ 25919 int n_englob; 25920 25921 for (n_buf = 0;n_buf < gen_nb_char_ptr;n_buf++) { 25922 for (n_size = 0;n_size < gen_nb_int;n_size++) { 25923 for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) { 25924 for (n_englob = 0;n_englob < gen_nb_int;n_englob++) { 25925 mem_base = xmlMemBlocks(); 25926 buf = gen_char_ptr(n_buf, 0); 25927 size = gen_int(n_size, 1); 25928 content = gen_xmlElementContentPtr(n_content, 2); 25929 englob = gen_int(n_englob, 3); 25930 25931 xmlSnprintfElementContent(buf, size, content, englob); 25932 call_tests++; 25933 des_char_ptr(n_buf, buf, 0); 25934 des_int(n_size, size, 1); 25935 des_xmlElementContentPtr(n_content, content, 2); 25936 des_int(n_englob, englob, 3); 25937 xmlResetLastError(); 25938 if (mem_base != xmlMemBlocks()) { 25939 printf("Leak of %d blocks found in xmlSnprintfElementContent", 25940 xmlMemBlocks() - mem_base); 25941 test_ret++; 25942 printf(" %d", n_buf); 25943 printf(" %d", n_size); 25944 printf(" %d", n_content); 25945 printf(" %d", n_englob); 25946 printf("\n"); 25947 } 25948 } 25949 } 25950 } 25951 } 25952 function_tests++; 25953 25954 return(test_ret); 25955 } 25956 25957 25958 static int 25959 test_xmlSprintfElementContent(void) { 25960 int test_ret = 0; 25961 25962 #if defined(LIBXML_OUTPUT_ENABLED) 25963 #ifdef LIBXML_OUTPUT_ENABLED 25964 int mem_base; 25965 char * buf; /* an output buffer */ 25966 int n_buf; 25967 xmlElementContentPtr content; /* An element table */ 25968 int n_content; 25969 int englob; /* 1 if one must print the englobing parenthesis, 0 otherwise */ 25970 int n_englob; 25971 25972 for (n_buf = 0;n_buf < gen_nb_char_ptr;n_buf++) { 25973 for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) { 25974 for (n_englob = 0;n_englob < gen_nb_int;n_englob++) { 25975 mem_base = xmlMemBlocks(); 25976 buf = gen_char_ptr(n_buf, 0); 25977 content = gen_xmlElementContentPtr(n_content, 1); 25978 englob = gen_int(n_englob, 2); 25979 25980 xmlSprintfElementContent(buf, content, englob); 25981 call_tests++; 25982 des_char_ptr(n_buf, buf, 0); 25983 des_xmlElementContentPtr(n_content, content, 1); 25984 des_int(n_englob, englob, 2); 25985 xmlResetLastError(); 25986 if (mem_base != xmlMemBlocks()) { 25987 printf("Leak of %d blocks found in xmlSprintfElementContent", 25988 xmlMemBlocks() - mem_base); 25989 test_ret++; 25990 printf(" %d", n_buf); 25991 printf(" %d", n_content); 25992 printf(" %d", n_englob); 25993 printf("\n"); 25994 } 25995 } 25996 } 25997 } 25998 function_tests++; 25999 #endif 26000 #endif 26001 26002 return(test_ret); 26003 } 26004 26005 26006 static int 26007 test_xmlValidBuildContentModel(void) { 26008 int test_ret = 0; 26009 26010 #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED) 26011 int mem_base; 26012 int ret_val; 26013 xmlValidCtxtPtr ctxt; /* a validation context */ 26014 int n_ctxt; 26015 xmlElementPtr elem; /* an element declaration node */ 26016 int n_elem; 26017 26018 for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { 26019 for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) { 26020 mem_base = xmlMemBlocks(); 26021 ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0); 26022 elem = gen_xmlElementPtr(n_elem, 1); 26023 26024 ret_val = xmlValidBuildContentModel(ctxt, elem); 26025 desret_int(ret_val); 26026 call_tests++; 26027 des_xmlValidCtxtPtr(n_ctxt, ctxt, 0); 26028 des_xmlElementPtr(n_elem, elem, 1); 26029 xmlResetLastError(); 26030 if (mem_base != xmlMemBlocks()) { 26031 printf("Leak of %d blocks found in xmlValidBuildContentModel", 26032 xmlMemBlocks() - mem_base); 26033 test_ret++; 26034 printf(" %d", n_ctxt); 26035 printf(" %d", n_elem); 26036 printf("\n"); 26037 } 26038 } 26039 } 26040 function_tests++; 26041 #endif 26042 26043 return(test_ret); 26044 } 26045 26046 26047 static int 26048 test_xmlValidCtxtNormalizeAttributeValue(void) { 26049 int test_ret = 0; 26050 26051 #if defined(LIBXML_VALID_ENABLED) 26052 int mem_base; 26053 xmlChar * ret_val; 26054 xmlValidCtxtPtr ctxt; /* the validation context or NULL */ 26055 int n_ctxt; 26056 xmlDocPtr doc; /* the document */ 26057 int n_doc; 26058 xmlNodePtr elem; /* the parent */ 26059 int n_elem; 26060 xmlChar * name; /* the attribute name */ 26061 int n_name; 26062 xmlChar * value; /* the attribute value */ 26063 int n_value; 26064 26065 for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { 26066 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 26067 for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) { 26068 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 26069 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 26070 mem_base = xmlMemBlocks(); 26071 ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0); 26072 doc = gen_xmlDocPtr(n_doc, 1); 26073 elem = gen_xmlNodePtr(n_elem, 2); 26074 name = gen_const_xmlChar_ptr(n_name, 3); 26075 value = gen_const_xmlChar_ptr(n_value, 4); 26076 26077 ret_val = xmlValidCtxtNormalizeAttributeValue(ctxt, doc, elem, (const xmlChar *)name, (const xmlChar *)value); 26078 desret_xmlChar_ptr(ret_val); 26079 call_tests++; 26080 des_xmlValidCtxtPtr(n_ctxt, ctxt, 0); 26081 des_xmlDocPtr(n_doc, doc, 1); 26082 des_xmlNodePtr(n_elem, elem, 2); 26083 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 3); 26084 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 4); 26085 xmlResetLastError(); 26086 if (mem_base != xmlMemBlocks()) { 26087 printf("Leak of %d blocks found in xmlValidCtxtNormalizeAttributeValue", 26088 xmlMemBlocks() - mem_base); 26089 test_ret++; 26090 printf(" %d", n_ctxt); 26091 printf(" %d", n_doc); 26092 printf(" %d", n_elem); 26093 printf(" %d", n_name); 26094 printf(" %d", n_value); 26095 printf("\n"); 26096 } 26097 } 26098 } 26099 } 26100 } 26101 } 26102 function_tests++; 26103 #endif 26104 26105 return(test_ret); 26106 } 26107 26108 26109 #define gen_nb_xmlElementContent_ptr 1 26110 static xmlElementContent * gen_xmlElementContent_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 26111 return(NULL); 26112 } 26113 static void des_xmlElementContent_ptr(int no ATTRIBUTE_UNUSED, xmlElementContent * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 26114 } 26115 26116 static int 26117 test_xmlValidGetPotentialChildren(void) { 26118 int test_ret = 0; 26119 26120 #if defined(LIBXML_VALID_ENABLED) 26121 #ifdef LIBXML_VALID_ENABLED 26122 int mem_base; 26123 int ret_val; 26124 xmlElementContent * ctree; /* an element content tree */ 26125 int n_ctree; 26126 xmlChar ** names; /* an array to store the list of child names */ 26127 int n_names; 26128 int * len; /* a pointer to the number of element in the list */ 26129 int n_len; 26130 int max; /* the size of the array */ 26131 int n_max; 26132 26133 for (n_ctree = 0;n_ctree < gen_nb_xmlElementContent_ptr;n_ctree++) { 26134 for (n_names = 0;n_names < gen_nb_const_xmlChar_ptr_ptr;n_names++) { 26135 for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) { 26136 for (n_max = 0;n_max < gen_nb_int;n_max++) { 26137 mem_base = xmlMemBlocks(); 26138 ctree = gen_xmlElementContent_ptr(n_ctree, 0); 26139 names = gen_const_xmlChar_ptr_ptr(n_names, 1); 26140 len = gen_int_ptr(n_len, 2); 26141 max = gen_int(n_max, 3); 26142 26143 ret_val = xmlValidGetPotentialChildren(ctree, (const xmlChar **)names, len, max); 26144 desret_int(ret_val); 26145 call_tests++; 26146 des_xmlElementContent_ptr(n_ctree, ctree, 0); 26147 des_const_xmlChar_ptr_ptr(n_names, (const xmlChar **)names, 1); 26148 des_int_ptr(n_len, len, 2); 26149 des_int(n_max, max, 3); 26150 xmlResetLastError(); 26151 if (mem_base != xmlMemBlocks()) { 26152 printf("Leak of %d blocks found in xmlValidGetPotentialChildren", 26153 xmlMemBlocks() - mem_base); 26154 test_ret++; 26155 printf(" %d", n_ctree); 26156 printf(" %d", n_names); 26157 printf(" %d", n_len); 26158 printf(" %d", n_max); 26159 printf("\n"); 26160 } 26161 } 26162 } 26163 } 26164 } 26165 function_tests++; 26166 #endif 26167 #endif 26168 26169 return(test_ret); 26170 } 26171 26172 26173 static int 26174 test_xmlValidGetValidElements(void) { 26175 int test_ret = 0; 26176 26177 #if defined(LIBXML_VALID_ENABLED) 26178 #ifdef LIBXML_VALID_ENABLED 26179 int mem_base; 26180 int ret_val; 26181 xmlNode * prev; /* an element to insert after */ 26182 int n_prev; 26183 xmlNode * next; /* an element to insert next */ 26184 int n_next; 26185 xmlChar ** names; /* an array to store the list of child names */ 26186 int n_names; 26187 int max; /* the size of the array */ 26188 int n_max; 26189 26190 for (n_prev = 0;n_prev < gen_nb_xmlNodePtr;n_prev++) { 26191 for (n_next = 0;n_next < gen_nb_xmlNodePtr;n_next++) { 26192 for (n_names = 0;n_names < gen_nb_const_xmlChar_ptr_ptr;n_names++) { 26193 for (n_max = 0;n_max < gen_nb_int;n_max++) { 26194 mem_base = xmlMemBlocks(); 26195 prev = gen_xmlNodePtr(n_prev, 0); 26196 next = gen_xmlNodePtr(n_next, 1); 26197 names = gen_const_xmlChar_ptr_ptr(n_names, 2); 26198 max = gen_int(n_max, 3); 26199 26200 ret_val = xmlValidGetValidElements(prev, next, (const xmlChar **)names, max); 26201 desret_int(ret_val); 26202 call_tests++; 26203 des_xmlNodePtr(n_prev, prev, 0); 26204 des_xmlNodePtr(n_next, next, 1); 26205 des_const_xmlChar_ptr_ptr(n_names, (const xmlChar **)names, 2); 26206 des_int(n_max, max, 3); 26207 xmlResetLastError(); 26208 if (mem_base != xmlMemBlocks()) { 26209 printf("Leak of %d blocks found in xmlValidGetValidElements", 26210 xmlMemBlocks() - mem_base); 26211 test_ret++; 26212 printf(" %d", n_prev); 26213 printf(" %d", n_next); 26214 printf(" %d", n_names); 26215 printf(" %d", n_max); 26216 printf("\n"); 26217 } 26218 } 26219 } 26220 } 26221 } 26222 function_tests++; 26223 #endif 26224 #endif 26225 26226 return(test_ret); 26227 } 26228 26229 26230 static int 26231 test_xmlValidNormalizeAttributeValue(void) { 26232 int test_ret = 0; 26233 26234 #if defined(LIBXML_VALID_ENABLED) 26235 int mem_base; 26236 xmlChar * ret_val; 26237 xmlDocPtr doc; /* the document */ 26238 int n_doc; 26239 xmlNodePtr elem; /* the parent */ 26240 int n_elem; 26241 xmlChar * name; /* the attribute name */ 26242 int n_name; 26243 xmlChar * value; /* the attribute value */ 26244 int n_value; 26245 26246 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 26247 for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) { 26248 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 26249 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 26250 mem_base = xmlMemBlocks(); 26251 doc = gen_xmlDocPtr(n_doc, 0); 26252 elem = gen_xmlNodePtr(n_elem, 1); 26253 name = gen_const_xmlChar_ptr(n_name, 2); 26254 value = gen_const_xmlChar_ptr(n_value, 3); 26255 26256 ret_val = xmlValidNormalizeAttributeValue(doc, elem, (const xmlChar *)name, (const xmlChar *)value); 26257 desret_xmlChar_ptr(ret_val); 26258 call_tests++; 26259 des_xmlDocPtr(n_doc, doc, 0); 26260 des_xmlNodePtr(n_elem, elem, 1); 26261 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 26262 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3); 26263 xmlResetLastError(); 26264 if (mem_base != xmlMemBlocks()) { 26265 printf("Leak of %d blocks found in xmlValidNormalizeAttributeValue", 26266 xmlMemBlocks() - mem_base); 26267 test_ret++; 26268 printf(" %d", n_doc); 26269 printf(" %d", n_elem); 26270 printf(" %d", n_name); 26271 printf(" %d", n_value); 26272 printf("\n"); 26273 } 26274 } 26275 } 26276 } 26277 } 26278 function_tests++; 26279 #endif 26280 26281 return(test_ret); 26282 } 26283 26284 26285 static int 26286 test_xmlValidateAttributeDecl(void) { 26287 int test_ret = 0; 26288 26289 #if defined(LIBXML_VALID_ENABLED) 26290 int mem_base; 26291 int ret_val; 26292 xmlValidCtxtPtr ctxt; /* the validation context */ 26293 int n_ctxt; 26294 xmlDocPtr doc; /* a document instance */ 26295 int n_doc; 26296 xmlAttributePtr attr; /* an attribute definition */ 26297 int n_attr; 26298 26299 for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { 26300 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 26301 for (n_attr = 0;n_attr < gen_nb_xmlAttributePtr;n_attr++) { 26302 mem_base = xmlMemBlocks(); 26303 ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0); 26304 doc = gen_xmlDocPtr(n_doc, 1); 26305 attr = gen_xmlAttributePtr(n_attr, 2); 26306 26307 ret_val = xmlValidateAttributeDecl(ctxt, doc, attr); 26308 desret_int(ret_val); 26309 call_tests++; 26310 des_xmlValidCtxtPtr(n_ctxt, ctxt, 0); 26311 des_xmlDocPtr(n_doc, doc, 1); 26312 des_xmlAttributePtr(n_attr, attr, 2); 26313 xmlResetLastError(); 26314 if (mem_base != xmlMemBlocks()) { 26315 printf("Leak of %d blocks found in xmlValidateAttributeDecl", 26316 xmlMemBlocks() - mem_base); 26317 test_ret++; 26318 printf(" %d", n_ctxt); 26319 printf(" %d", n_doc); 26320 printf(" %d", n_attr); 26321 printf("\n"); 26322 } 26323 } 26324 } 26325 } 26326 function_tests++; 26327 #endif 26328 26329 return(test_ret); 26330 } 26331 26332 26333 static int 26334 test_xmlValidateAttributeValue(void) { 26335 int test_ret = 0; 26336 26337 #if defined(LIBXML_VALID_ENABLED) 26338 int mem_base; 26339 int ret_val; 26340 xmlAttributeType type; /* an attribute type */ 26341 int n_type; 26342 xmlChar * value; /* an attribute value */ 26343 int n_value; 26344 26345 for (n_type = 0;n_type < gen_nb_xmlAttributeType;n_type++) { 26346 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 26347 mem_base = xmlMemBlocks(); 26348 type = gen_xmlAttributeType(n_type, 0); 26349 value = gen_const_xmlChar_ptr(n_value, 1); 26350 26351 ret_val = xmlValidateAttributeValue(type, (const xmlChar *)value); 26352 desret_int(ret_val); 26353 call_tests++; 26354 des_xmlAttributeType(n_type, type, 0); 26355 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1); 26356 xmlResetLastError(); 26357 if (mem_base != xmlMemBlocks()) { 26358 printf("Leak of %d blocks found in xmlValidateAttributeValue", 26359 xmlMemBlocks() - mem_base); 26360 test_ret++; 26361 printf(" %d", n_type); 26362 printf(" %d", n_value); 26363 printf("\n"); 26364 } 26365 } 26366 } 26367 function_tests++; 26368 #endif 26369 26370 return(test_ret); 26371 } 26372 26373 26374 static int 26375 test_xmlValidateDocument(void) { 26376 int test_ret = 0; 26377 26378 #if defined(LIBXML_VALID_ENABLED) 26379 int mem_base; 26380 int ret_val; 26381 xmlValidCtxtPtr ctxt; /* the validation context */ 26382 int n_ctxt; 26383 xmlDocPtr doc; /* a document instance */ 26384 int n_doc; 26385 26386 for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { 26387 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 26388 mem_base = xmlMemBlocks(); 26389 ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0); 26390 doc = gen_xmlDocPtr(n_doc, 1); 26391 26392 ret_val = xmlValidateDocument(ctxt, doc); 26393 desret_int(ret_val); 26394 call_tests++; 26395 des_xmlValidCtxtPtr(n_ctxt, ctxt, 0); 26396 des_xmlDocPtr(n_doc, doc, 1); 26397 xmlResetLastError(); 26398 if (mem_base != xmlMemBlocks()) { 26399 printf("Leak of %d blocks found in xmlValidateDocument", 26400 xmlMemBlocks() - mem_base); 26401 test_ret++; 26402 printf(" %d", n_ctxt); 26403 printf(" %d", n_doc); 26404 printf("\n"); 26405 } 26406 } 26407 } 26408 function_tests++; 26409 #endif 26410 26411 return(test_ret); 26412 } 26413 26414 26415 static int 26416 test_xmlValidateDocumentFinal(void) { 26417 int test_ret = 0; 26418 26419 #if defined(LIBXML_VALID_ENABLED) 26420 int mem_base; 26421 int ret_val; 26422 xmlValidCtxtPtr ctxt; /* the validation context */ 26423 int n_ctxt; 26424 xmlDocPtr doc; /* a document instance */ 26425 int n_doc; 26426 26427 for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { 26428 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 26429 mem_base = xmlMemBlocks(); 26430 ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0); 26431 doc = gen_xmlDocPtr(n_doc, 1); 26432 26433 ret_val = xmlValidateDocumentFinal(ctxt, doc); 26434 desret_int(ret_val); 26435 call_tests++; 26436 des_xmlValidCtxtPtr(n_ctxt, ctxt, 0); 26437 des_xmlDocPtr(n_doc, doc, 1); 26438 xmlResetLastError(); 26439 if (mem_base != xmlMemBlocks()) { 26440 printf("Leak of %d blocks found in xmlValidateDocumentFinal", 26441 xmlMemBlocks() - mem_base); 26442 test_ret++; 26443 printf(" %d", n_ctxt); 26444 printf(" %d", n_doc); 26445 printf("\n"); 26446 } 26447 } 26448 } 26449 function_tests++; 26450 #endif 26451 26452 return(test_ret); 26453 } 26454 26455 26456 static int 26457 test_xmlValidateDtd(void) { 26458 int test_ret = 0; 26459 26460 #if defined(LIBXML_VALID_ENABLED) 26461 int mem_base; 26462 int ret_val; 26463 xmlValidCtxtPtr ctxt; /* the validation context */ 26464 int n_ctxt; 26465 xmlDocPtr doc; /* a document instance */ 26466 int n_doc; 26467 xmlDtdPtr dtd; /* a dtd instance */ 26468 int n_dtd; 26469 26470 for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { 26471 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 26472 for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) { 26473 mem_base = xmlMemBlocks(); 26474 ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0); 26475 doc = gen_xmlDocPtr(n_doc, 1); 26476 dtd = gen_xmlDtdPtr(n_dtd, 2); 26477 26478 ret_val = xmlValidateDtd(ctxt, doc, dtd); 26479 desret_int(ret_val); 26480 call_tests++; 26481 des_xmlValidCtxtPtr(n_ctxt, ctxt, 0); 26482 des_xmlDocPtr(n_doc, doc, 1); 26483 des_xmlDtdPtr(n_dtd, dtd, 2); 26484 xmlResetLastError(); 26485 if (mem_base != xmlMemBlocks()) { 26486 printf("Leak of %d blocks found in xmlValidateDtd", 26487 xmlMemBlocks() - mem_base); 26488 test_ret++; 26489 printf(" %d", n_ctxt); 26490 printf(" %d", n_doc); 26491 printf(" %d", n_dtd); 26492 printf("\n"); 26493 } 26494 } 26495 } 26496 } 26497 function_tests++; 26498 #endif 26499 26500 return(test_ret); 26501 } 26502 26503 26504 static int 26505 test_xmlValidateDtdFinal(void) { 26506 int test_ret = 0; 26507 26508 #if defined(LIBXML_VALID_ENABLED) 26509 int mem_base; 26510 int ret_val; 26511 xmlValidCtxtPtr ctxt; /* the validation context */ 26512 int n_ctxt; 26513 xmlDocPtr doc; /* a document instance */ 26514 int n_doc; 26515 26516 for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { 26517 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 26518 mem_base = xmlMemBlocks(); 26519 ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0); 26520 doc = gen_xmlDocPtr(n_doc, 1); 26521 26522 ret_val = xmlValidateDtdFinal(ctxt, doc); 26523 desret_int(ret_val); 26524 call_tests++; 26525 des_xmlValidCtxtPtr(n_ctxt, ctxt, 0); 26526 des_xmlDocPtr(n_doc, doc, 1); 26527 xmlResetLastError(); 26528 if (mem_base != xmlMemBlocks()) { 26529 printf("Leak of %d blocks found in xmlValidateDtdFinal", 26530 xmlMemBlocks() - mem_base); 26531 test_ret++; 26532 printf(" %d", n_ctxt); 26533 printf(" %d", n_doc); 26534 printf("\n"); 26535 } 26536 } 26537 } 26538 function_tests++; 26539 #endif 26540 26541 return(test_ret); 26542 } 26543 26544 26545 static int 26546 test_xmlValidateElement(void) { 26547 int test_ret = 0; 26548 26549 #if defined(LIBXML_VALID_ENABLED) 26550 int mem_base; 26551 int ret_val; 26552 xmlValidCtxtPtr ctxt; /* the validation context */ 26553 int n_ctxt; 26554 xmlDocPtr doc; /* a document instance */ 26555 int n_doc; 26556 xmlNodePtr elem; /* an element instance */ 26557 int n_elem; 26558 26559 for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { 26560 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 26561 for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) { 26562 mem_base = xmlMemBlocks(); 26563 ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0); 26564 doc = gen_xmlDocPtr(n_doc, 1); 26565 elem = gen_xmlNodePtr(n_elem, 2); 26566 26567 ret_val = xmlValidateElement(ctxt, doc, elem); 26568 desret_int(ret_val); 26569 call_tests++; 26570 des_xmlValidCtxtPtr(n_ctxt, ctxt, 0); 26571 des_xmlDocPtr(n_doc, doc, 1); 26572 des_xmlNodePtr(n_elem, elem, 2); 26573 xmlResetLastError(); 26574 if (mem_base != xmlMemBlocks()) { 26575 printf("Leak of %d blocks found in xmlValidateElement", 26576 xmlMemBlocks() - mem_base); 26577 test_ret++; 26578 printf(" %d", n_ctxt); 26579 printf(" %d", n_doc); 26580 printf(" %d", n_elem); 26581 printf("\n"); 26582 } 26583 } 26584 } 26585 } 26586 function_tests++; 26587 #endif 26588 26589 return(test_ret); 26590 } 26591 26592 26593 static int 26594 test_xmlValidateElementDecl(void) { 26595 int test_ret = 0; 26596 26597 #if defined(LIBXML_VALID_ENABLED) 26598 int mem_base; 26599 int ret_val; 26600 xmlValidCtxtPtr ctxt; /* the validation context */ 26601 int n_ctxt; 26602 xmlDocPtr doc; /* a document instance */ 26603 int n_doc; 26604 xmlElementPtr elem; /* an element definition */ 26605 int n_elem; 26606 26607 for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { 26608 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 26609 for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) { 26610 mem_base = xmlMemBlocks(); 26611 ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0); 26612 doc = gen_xmlDocPtr(n_doc, 1); 26613 elem = gen_xmlElementPtr(n_elem, 2); 26614 26615 ret_val = xmlValidateElementDecl(ctxt, doc, elem); 26616 desret_int(ret_val); 26617 call_tests++; 26618 des_xmlValidCtxtPtr(n_ctxt, ctxt, 0); 26619 des_xmlDocPtr(n_doc, doc, 1); 26620 des_xmlElementPtr(n_elem, elem, 2); 26621 xmlResetLastError(); 26622 if (mem_base != xmlMemBlocks()) { 26623 printf("Leak of %d blocks found in xmlValidateElementDecl", 26624 xmlMemBlocks() - mem_base); 26625 test_ret++; 26626 printf(" %d", n_ctxt); 26627 printf(" %d", n_doc); 26628 printf(" %d", n_elem); 26629 printf("\n"); 26630 } 26631 } 26632 } 26633 } 26634 function_tests++; 26635 #endif 26636 26637 return(test_ret); 26638 } 26639 26640 26641 static int 26642 test_xmlValidateNameValue(void) { 26643 int test_ret = 0; 26644 26645 #if defined(LIBXML_VALID_ENABLED) 26646 int mem_base; 26647 int ret_val; 26648 xmlChar * value; /* an Name value */ 26649 int n_value; 26650 26651 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 26652 mem_base = xmlMemBlocks(); 26653 value = gen_const_xmlChar_ptr(n_value, 0); 26654 26655 ret_val = xmlValidateNameValue((const xmlChar *)value); 26656 desret_int(ret_val); 26657 call_tests++; 26658 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0); 26659 xmlResetLastError(); 26660 if (mem_base != xmlMemBlocks()) { 26661 printf("Leak of %d blocks found in xmlValidateNameValue", 26662 xmlMemBlocks() - mem_base); 26663 test_ret++; 26664 printf(" %d", n_value); 26665 printf("\n"); 26666 } 26667 } 26668 function_tests++; 26669 #endif 26670 26671 return(test_ret); 26672 } 26673 26674 26675 static int 26676 test_xmlValidateNamesValue(void) { 26677 int test_ret = 0; 26678 26679 #if defined(LIBXML_VALID_ENABLED) 26680 int mem_base; 26681 int ret_val; 26682 xmlChar * value; /* an Names value */ 26683 int n_value; 26684 26685 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 26686 mem_base = xmlMemBlocks(); 26687 value = gen_const_xmlChar_ptr(n_value, 0); 26688 26689 ret_val = xmlValidateNamesValue((const xmlChar *)value); 26690 desret_int(ret_val); 26691 call_tests++; 26692 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0); 26693 xmlResetLastError(); 26694 if (mem_base != xmlMemBlocks()) { 26695 printf("Leak of %d blocks found in xmlValidateNamesValue", 26696 xmlMemBlocks() - mem_base); 26697 test_ret++; 26698 printf(" %d", n_value); 26699 printf("\n"); 26700 } 26701 } 26702 function_tests++; 26703 #endif 26704 26705 return(test_ret); 26706 } 26707 26708 26709 static int 26710 test_xmlValidateNmtokenValue(void) { 26711 int test_ret = 0; 26712 26713 #if defined(LIBXML_VALID_ENABLED) 26714 int mem_base; 26715 int ret_val; 26716 xmlChar * value; /* an Nmtoken value */ 26717 int n_value; 26718 26719 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 26720 mem_base = xmlMemBlocks(); 26721 value = gen_const_xmlChar_ptr(n_value, 0); 26722 26723 ret_val = xmlValidateNmtokenValue((const xmlChar *)value); 26724 desret_int(ret_val); 26725 call_tests++; 26726 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0); 26727 xmlResetLastError(); 26728 if (mem_base != xmlMemBlocks()) { 26729 printf("Leak of %d blocks found in xmlValidateNmtokenValue", 26730 xmlMemBlocks() - mem_base); 26731 test_ret++; 26732 printf(" %d", n_value); 26733 printf("\n"); 26734 } 26735 } 26736 function_tests++; 26737 #endif 26738 26739 return(test_ret); 26740 } 26741 26742 26743 static int 26744 test_xmlValidateNmtokensValue(void) { 26745 int test_ret = 0; 26746 26747 #if defined(LIBXML_VALID_ENABLED) 26748 int mem_base; 26749 int ret_val; 26750 xmlChar * value; /* an Nmtokens value */ 26751 int n_value; 26752 26753 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 26754 mem_base = xmlMemBlocks(); 26755 value = gen_const_xmlChar_ptr(n_value, 0); 26756 26757 ret_val = xmlValidateNmtokensValue((const xmlChar *)value); 26758 desret_int(ret_val); 26759 call_tests++; 26760 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0); 26761 xmlResetLastError(); 26762 if (mem_base != xmlMemBlocks()) { 26763 printf("Leak of %d blocks found in xmlValidateNmtokensValue", 26764 xmlMemBlocks() - mem_base); 26765 test_ret++; 26766 printf(" %d", n_value); 26767 printf("\n"); 26768 } 26769 } 26770 function_tests++; 26771 #endif 26772 26773 return(test_ret); 26774 } 26775 26776 26777 static int 26778 test_xmlValidateNotationDecl(void) { 26779 int test_ret = 0; 26780 26781 #if defined(LIBXML_VALID_ENABLED) 26782 int mem_base; 26783 int ret_val; 26784 xmlValidCtxtPtr ctxt; /* the validation context */ 26785 int n_ctxt; 26786 xmlDocPtr doc; /* a document instance */ 26787 int n_doc; 26788 xmlNotationPtr nota; /* a notation definition */ 26789 int n_nota; 26790 26791 for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { 26792 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 26793 for (n_nota = 0;n_nota < gen_nb_xmlNotationPtr;n_nota++) { 26794 mem_base = xmlMemBlocks(); 26795 ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0); 26796 doc = gen_xmlDocPtr(n_doc, 1); 26797 nota = gen_xmlNotationPtr(n_nota, 2); 26798 26799 ret_val = xmlValidateNotationDecl(ctxt, doc, nota); 26800 desret_int(ret_val); 26801 call_tests++; 26802 des_xmlValidCtxtPtr(n_ctxt, ctxt, 0); 26803 des_xmlDocPtr(n_doc, doc, 1); 26804 des_xmlNotationPtr(n_nota, nota, 2); 26805 xmlResetLastError(); 26806 if (mem_base != xmlMemBlocks()) { 26807 printf("Leak of %d blocks found in xmlValidateNotationDecl", 26808 xmlMemBlocks() - mem_base); 26809 test_ret++; 26810 printf(" %d", n_ctxt); 26811 printf(" %d", n_doc); 26812 printf(" %d", n_nota); 26813 printf("\n"); 26814 } 26815 } 26816 } 26817 } 26818 function_tests++; 26819 #endif 26820 26821 return(test_ret); 26822 } 26823 26824 26825 static int 26826 test_xmlValidateNotationUse(void) { 26827 int test_ret = 0; 26828 26829 #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 26830 int mem_base; 26831 int ret_val; 26832 xmlValidCtxtPtr ctxt; /* the validation context */ 26833 int n_ctxt; 26834 xmlDocPtr doc; /* the document */ 26835 int n_doc; 26836 xmlChar * notationName; /* the notation name to check */ 26837 int n_notationName; 26838 26839 for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { 26840 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 26841 for (n_notationName = 0;n_notationName < gen_nb_const_xmlChar_ptr;n_notationName++) { 26842 mem_base = xmlMemBlocks(); 26843 ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0); 26844 doc = gen_xmlDocPtr(n_doc, 1); 26845 notationName = gen_const_xmlChar_ptr(n_notationName, 2); 26846 26847 ret_val = xmlValidateNotationUse(ctxt, doc, (const xmlChar *)notationName); 26848 desret_int(ret_val); 26849 call_tests++; 26850 des_xmlValidCtxtPtr(n_ctxt, ctxt, 0); 26851 des_xmlDocPtr(n_doc, doc, 1); 26852 des_const_xmlChar_ptr(n_notationName, (const xmlChar *)notationName, 2); 26853 xmlResetLastError(); 26854 if (mem_base != xmlMemBlocks()) { 26855 printf("Leak of %d blocks found in xmlValidateNotationUse", 26856 xmlMemBlocks() - mem_base); 26857 test_ret++; 26858 printf(" %d", n_ctxt); 26859 printf(" %d", n_doc); 26860 printf(" %d", n_notationName); 26861 printf("\n"); 26862 } 26863 } 26864 } 26865 } 26866 function_tests++; 26867 #endif 26868 26869 return(test_ret); 26870 } 26871 26872 26873 static int 26874 test_xmlValidateOneAttribute(void) { 26875 int test_ret = 0; 26876 26877 #if defined(LIBXML_VALID_ENABLED) 26878 int mem_base; 26879 int ret_val; 26880 xmlValidCtxtPtr ctxt; /* the validation context */ 26881 int n_ctxt; 26882 xmlDocPtr doc; /* a document instance */ 26883 int n_doc; 26884 xmlNodePtr elem; /* an element instance */ 26885 int n_elem; 26886 xmlAttrPtr attr; /* an attribute instance */ 26887 int n_attr; 26888 xmlChar * value; /* the attribute value (without entities processing) */ 26889 int n_value; 26890 26891 for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { 26892 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 26893 for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) { 26894 for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) { 26895 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 26896 mem_base = xmlMemBlocks(); 26897 ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0); 26898 doc = gen_xmlDocPtr(n_doc, 1); 26899 elem = gen_xmlNodePtr(n_elem, 2); 26900 attr = gen_xmlAttrPtr(n_attr, 3); 26901 value = gen_const_xmlChar_ptr(n_value, 4); 26902 26903 ret_val = xmlValidateOneAttribute(ctxt, doc, elem, attr, (const xmlChar *)value); 26904 desret_int(ret_val); 26905 call_tests++; 26906 des_xmlValidCtxtPtr(n_ctxt, ctxt, 0); 26907 des_xmlDocPtr(n_doc, doc, 1); 26908 des_xmlNodePtr(n_elem, elem, 2); 26909 des_xmlAttrPtr(n_attr, attr, 3); 26910 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 4); 26911 xmlResetLastError(); 26912 if (mem_base != xmlMemBlocks()) { 26913 printf("Leak of %d blocks found in xmlValidateOneAttribute", 26914 xmlMemBlocks() - mem_base); 26915 test_ret++; 26916 printf(" %d", n_ctxt); 26917 printf(" %d", n_doc); 26918 printf(" %d", n_elem); 26919 printf(" %d", n_attr); 26920 printf(" %d", n_value); 26921 printf("\n"); 26922 } 26923 } 26924 } 26925 } 26926 } 26927 } 26928 function_tests++; 26929 #endif 26930 26931 return(test_ret); 26932 } 26933 26934 26935 static int 26936 test_xmlValidateOneElement(void) { 26937 int test_ret = 0; 26938 26939 #if defined(LIBXML_VALID_ENABLED) 26940 int mem_base; 26941 int ret_val; 26942 xmlValidCtxtPtr ctxt; /* the validation context */ 26943 int n_ctxt; 26944 xmlDocPtr doc; /* a document instance */ 26945 int n_doc; 26946 xmlNodePtr elem; /* an element instance */ 26947 int n_elem; 26948 26949 for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { 26950 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 26951 for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) { 26952 mem_base = xmlMemBlocks(); 26953 ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0); 26954 doc = gen_xmlDocPtr(n_doc, 1); 26955 elem = gen_xmlNodePtr(n_elem, 2); 26956 26957 ret_val = xmlValidateOneElement(ctxt, doc, elem); 26958 desret_int(ret_val); 26959 call_tests++; 26960 des_xmlValidCtxtPtr(n_ctxt, ctxt, 0); 26961 des_xmlDocPtr(n_doc, doc, 1); 26962 des_xmlNodePtr(n_elem, elem, 2); 26963 xmlResetLastError(); 26964 if (mem_base != xmlMemBlocks()) { 26965 printf("Leak of %d blocks found in xmlValidateOneElement", 26966 xmlMemBlocks() - mem_base); 26967 test_ret++; 26968 printf(" %d", n_ctxt); 26969 printf(" %d", n_doc); 26970 printf(" %d", n_elem); 26971 printf("\n"); 26972 } 26973 } 26974 } 26975 } 26976 function_tests++; 26977 #endif 26978 26979 return(test_ret); 26980 } 26981 26982 26983 static int 26984 test_xmlValidateOneNamespace(void) { 26985 int test_ret = 0; 26986 26987 #if defined(LIBXML_VALID_ENABLED) 26988 int mem_base; 26989 int ret_val; 26990 xmlValidCtxtPtr ctxt; /* the validation context */ 26991 int n_ctxt; 26992 xmlDocPtr doc; /* a document instance */ 26993 int n_doc; 26994 xmlNodePtr elem; /* an element instance */ 26995 int n_elem; 26996 xmlChar * prefix; /* the namespace prefix */ 26997 int n_prefix; 26998 xmlNsPtr ns; /* an namespace declaration instance */ 26999 int n_ns; 27000 xmlChar * value; /* the attribute value (without entities processing) */ 27001 int n_value; 27002 27003 for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { 27004 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 27005 for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) { 27006 for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) { 27007 for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) { 27008 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 27009 mem_base = xmlMemBlocks(); 27010 ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0); 27011 doc = gen_xmlDocPtr(n_doc, 1); 27012 elem = gen_xmlNodePtr(n_elem, 2); 27013 prefix = gen_const_xmlChar_ptr(n_prefix, 3); 27014 ns = gen_xmlNsPtr(n_ns, 4); 27015 value = gen_const_xmlChar_ptr(n_value, 5); 27016 27017 ret_val = xmlValidateOneNamespace(ctxt, doc, elem, (const xmlChar *)prefix, ns, (const xmlChar *)value); 27018 desret_int(ret_val); 27019 call_tests++; 27020 des_xmlValidCtxtPtr(n_ctxt, ctxt, 0); 27021 des_xmlDocPtr(n_doc, doc, 1); 27022 des_xmlNodePtr(n_elem, elem, 2); 27023 des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 3); 27024 des_xmlNsPtr(n_ns, ns, 4); 27025 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 5); 27026 xmlResetLastError(); 27027 if (mem_base != xmlMemBlocks()) { 27028 printf("Leak of %d blocks found in xmlValidateOneNamespace", 27029 xmlMemBlocks() - mem_base); 27030 test_ret++; 27031 printf(" %d", n_ctxt); 27032 printf(" %d", n_doc); 27033 printf(" %d", n_elem); 27034 printf(" %d", n_prefix); 27035 printf(" %d", n_ns); 27036 printf(" %d", n_value); 27037 printf("\n"); 27038 } 27039 } 27040 } 27041 } 27042 } 27043 } 27044 } 27045 function_tests++; 27046 #endif 27047 27048 return(test_ret); 27049 } 27050 27051 27052 static int 27053 test_xmlValidatePopElement(void) { 27054 int test_ret = 0; 27055 27056 #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED) 27057 int mem_base; 27058 int ret_val; 27059 xmlValidCtxtPtr ctxt; /* the validation context */ 27060 int n_ctxt; 27061 xmlDocPtr doc; /* a document instance */ 27062 int n_doc; 27063 xmlNodePtr elem; /* an element instance */ 27064 int n_elem; 27065 xmlChar * qname; /* the qualified name as appearing in the serialization */ 27066 int n_qname; 27067 27068 for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { 27069 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 27070 for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) { 27071 for (n_qname = 0;n_qname < gen_nb_const_xmlChar_ptr;n_qname++) { 27072 mem_base = xmlMemBlocks(); 27073 ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0); 27074 doc = gen_xmlDocPtr(n_doc, 1); 27075 elem = gen_xmlNodePtr(n_elem, 2); 27076 qname = gen_const_xmlChar_ptr(n_qname, 3); 27077 27078 ret_val = xmlValidatePopElement(ctxt, doc, elem, (const xmlChar *)qname); 27079 desret_int(ret_val); 27080 call_tests++; 27081 des_xmlValidCtxtPtr(n_ctxt, ctxt, 0); 27082 des_xmlDocPtr(n_doc, doc, 1); 27083 des_xmlNodePtr(n_elem, elem, 2); 27084 des_const_xmlChar_ptr(n_qname, (const xmlChar *)qname, 3); 27085 xmlResetLastError(); 27086 if (mem_base != xmlMemBlocks()) { 27087 printf("Leak of %d blocks found in xmlValidatePopElement", 27088 xmlMemBlocks() - mem_base); 27089 test_ret++; 27090 printf(" %d", n_ctxt); 27091 printf(" %d", n_doc); 27092 printf(" %d", n_elem); 27093 printf(" %d", n_qname); 27094 printf("\n"); 27095 } 27096 } 27097 } 27098 } 27099 } 27100 function_tests++; 27101 #endif 27102 27103 return(test_ret); 27104 } 27105 27106 27107 static int 27108 test_xmlValidatePushCData(void) { 27109 int test_ret = 0; 27110 27111 #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED) 27112 int mem_base; 27113 int ret_val; 27114 xmlValidCtxtPtr ctxt; /* the validation context */ 27115 int n_ctxt; 27116 xmlChar * data; /* some character data read */ 27117 int n_data; 27118 int len; /* the length of the data */ 27119 int n_len; 27120 27121 for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { 27122 for (n_data = 0;n_data < gen_nb_const_xmlChar_ptr;n_data++) { 27123 for (n_len = 0;n_len < gen_nb_int;n_len++) { 27124 mem_base = xmlMemBlocks(); 27125 ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0); 27126 data = gen_const_xmlChar_ptr(n_data, 1); 27127 len = gen_int(n_len, 2); 27128 27129 ret_val = xmlValidatePushCData(ctxt, (const xmlChar *)data, len); 27130 desret_int(ret_val); 27131 call_tests++; 27132 des_xmlValidCtxtPtr(n_ctxt, ctxt, 0); 27133 des_const_xmlChar_ptr(n_data, (const xmlChar *)data, 1); 27134 des_int(n_len, len, 2); 27135 xmlResetLastError(); 27136 if (mem_base != xmlMemBlocks()) { 27137 printf("Leak of %d blocks found in xmlValidatePushCData", 27138 xmlMemBlocks() - mem_base); 27139 test_ret++; 27140 printf(" %d", n_ctxt); 27141 printf(" %d", n_data); 27142 printf(" %d", n_len); 27143 printf("\n"); 27144 } 27145 } 27146 } 27147 } 27148 function_tests++; 27149 #endif 27150 27151 return(test_ret); 27152 } 27153 27154 27155 static int 27156 test_xmlValidatePushElement(void) { 27157 int test_ret = 0; 27158 27159 #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED) 27160 int mem_base; 27161 int ret_val; 27162 xmlValidCtxtPtr ctxt; /* the validation context */ 27163 int n_ctxt; 27164 xmlDocPtr doc; /* a document instance */ 27165 int n_doc; 27166 xmlNodePtr elem; /* an element instance */ 27167 int n_elem; 27168 xmlChar * qname; /* the qualified name as appearing in the serialization */ 27169 int n_qname; 27170 27171 for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { 27172 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 27173 for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) { 27174 for (n_qname = 0;n_qname < gen_nb_const_xmlChar_ptr;n_qname++) { 27175 mem_base = xmlMemBlocks(); 27176 ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0); 27177 doc = gen_xmlDocPtr(n_doc, 1); 27178 elem = gen_xmlNodePtr(n_elem, 2); 27179 qname = gen_const_xmlChar_ptr(n_qname, 3); 27180 27181 ret_val = xmlValidatePushElement(ctxt, doc, elem, (const xmlChar *)qname); 27182 desret_int(ret_val); 27183 call_tests++; 27184 des_xmlValidCtxtPtr(n_ctxt, ctxt, 0); 27185 des_xmlDocPtr(n_doc, doc, 1); 27186 des_xmlNodePtr(n_elem, elem, 2); 27187 des_const_xmlChar_ptr(n_qname, (const xmlChar *)qname, 3); 27188 xmlResetLastError(); 27189 if (mem_base != xmlMemBlocks()) { 27190 printf("Leak of %d blocks found in xmlValidatePushElement", 27191 xmlMemBlocks() - mem_base); 27192 test_ret++; 27193 printf(" %d", n_ctxt); 27194 printf(" %d", n_doc); 27195 printf(" %d", n_elem); 27196 printf(" %d", n_qname); 27197 printf("\n"); 27198 } 27199 } 27200 } 27201 } 27202 } 27203 function_tests++; 27204 #endif 27205 27206 return(test_ret); 27207 } 27208 27209 27210 static int 27211 test_xmlValidateRoot(void) { 27212 int test_ret = 0; 27213 27214 #if defined(LIBXML_VALID_ENABLED) 27215 int mem_base; 27216 int ret_val; 27217 xmlValidCtxtPtr ctxt; /* the validation context */ 27218 int n_ctxt; 27219 xmlDocPtr doc; /* a document instance */ 27220 int n_doc; 27221 27222 for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { 27223 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 27224 mem_base = xmlMemBlocks(); 27225 ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0); 27226 doc = gen_xmlDocPtr(n_doc, 1); 27227 27228 ret_val = xmlValidateRoot(ctxt, doc); 27229 desret_int(ret_val); 27230 call_tests++; 27231 des_xmlValidCtxtPtr(n_ctxt, ctxt, 0); 27232 des_xmlDocPtr(n_doc, doc, 1); 27233 xmlResetLastError(); 27234 if (mem_base != xmlMemBlocks()) { 27235 printf("Leak of %d blocks found in xmlValidateRoot", 27236 xmlMemBlocks() - mem_base); 27237 test_ret++; 27238 printf(" %d", n_ctxt); 27239 printf(" %d", n_doc); 27240 printf("\n"); 27241 } 27242 } 27243 } 27244 function_tests++; 27245 #endif 27246 27247 return(test_ret); 27248 } 27249 27250 static int 27251 test_valid(void) { 27252 int test_ret = 0; 27253 27254 if (quiet == 0) printf("Testing valid : 50 of 70 functions ...\n"); 27255 test_ret += test_xmlAddAttributeDecl(); 27256 test_ret += test_xmlAddElementDecl(); 27257 test_ret += test_xmlAddID(); 27258 test_ret += test_xmlAddNotationDecl(); 27259 test_ret += test_xmlAddRef(); 27260 test_ret += test_xmlCopyAttributeTable(); 27261 test_ret += test_xmlCopyDocElementContent(); 27262 test_ret += test_xmlCopyElementContent(); 27263 test_ret += test_xmlCopyElementTable(); 27264 test_ret += test_xmlCopyEnumeration(); 27265 test_ret += test_xmlCopyNotationTable(); 27266 test_ret += test_xmlCreateEnumeration(); 27267 test_ret += test_xmlDumpAttributeDecl(); 27268 test_ret += test_xmlDumpAttributeTable(); 27269 test_ret += test_xmlDumpElementDecl(); 27270 test_ret += test_xmlDumpElementTable(); 27271 test_ret += test_xmlDumpNotationDecl(); 27272 test_ret += test_xmlDumpNotationTable(); 27273 test_ret += test_xmlGetDtdAttrDesc(); 27274 test_ret += test_xmlGetDtdElementDesc(); 27275 test_ret += test_xmlGetDtdNotationDesc(); 27276 test_ret += test_xmlGetDtdQAttrDesc(); 27277 test_ret += test_xmlGetDtdQElementDesc(); 27278 test_ret += test_xmlGetID(); 27279 test_ret += test_xmlGetRefs(); 27280 test_ret += test_xmlIsID(); 27281 test_ret += test_xmlIsMixedElement(); 27282 test_ret += test_xmlIsRef(); 27283 test_ret += test_xmlNewDocElementContent(); 27284 test_ret += test_xmlNewElementContent(); 27285 test_ret += test_xmlNewValidCtxt(); 27286 test_ret += test_xmlRemoveID(); 27287 test_ret += test_xmlRemoveRef(); 27288 test_ret += test_xmlSnprintfElementContent(); 27289 test_ret += test_xmlSprintfElementContent(); 27290 test_ret += test_xmlValidBuildContentModel(); 27291 test_ret += test_xmlValidCtxtNormalizeAttributeValue(); 27292 test_ret += test_xmlValidGetPotentialChildren(); 27293 test_ret += test_xmlValidGetValidElements(); 27294 test_ret += test_xmlValidNormalizeAttributeValue(); 27295 test_ret += test_xmlValidateAttributeDecl(); 27296 test_ret += test_xmlValidateAttributeValue(); 27297 test_ret += test_xmlValidateDocument(); 27298 test_ret += test_xmlValidateDocumentFinal(); 27299 test_ret += test_xmlValidateDtd(); 27300 test_ret += test_xmlValidateDtdFinal(); 27301 test_ret += test_xmlValidateElement(); 27302 test_ret += test_xmlValidateElementDecl(); 27303 test_ret += test_xmlValidateNameValue(); 27304 test_ret += test_xmlValidateNamesValue(); 27305 test_ret += test_xmlValidateNmtokenValue(); 27306 test_ret += test_xmlValidateNmtokensValue(); 27307 test_ret += test_xmlValidateNotationDecl(); 27308 test_ret += test_xmlValidateNotationUse(); 27309 test_ret += test_xmlValidateOneAttribute(); 27310 test_ret += test_xmlValidateOneElement(); 27311 test_ret += test_xmlValidateOneNamespace(); 27312 test_ret += test_xmlValidatePopElement(); 27313 test_ret += test_xmlValidatePushCData(); 27314 test_ret += test_xmlValidatePushElement(); 27315 test_ret += test_xmlValidateRoot(); 27316 27317 if (test_ret != 0) 27318 printf("Module valid: %d errors\n", test_ret); 27319 return(test_ret); 27320 } 27321 27322 static int 27323 test_xmlXIncludeNewContext(void) { 27324 int test_ret = 0; 27325 27326 27327 /* missing type support */ 27328 return(test_ret); 27329 } 27330 27331 27332 static int 27333 test_xmlXIncludeProcess(void) { 27334 int test_ret = 0; 27335 27336 #if defined(LIBXML_XINCLUDE_ENABLED) 27337 int mem_base; 27338 int ret_val; 27339 xmlDocPtr doc; /* an XML document */ 27340 int n_doc; 27341 27342 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 27343 mem_base = xmlMemBlocks(); 27344 doc = gen_xmlDocPtr(n_doc, 0); 27345 27346 ret_val = xmlXIncludeProcess(doc); 27347 desret_int(ret_val); 27348 call_tests++; 27349 des_xmlDocPtr(n_doc, doc, 0); 27350 xmlResetLastError(); 27351 if (mem_base != xmlMemBlocks()) { 27352 printf("Leak of %d blocks found in xmlXIncludeProcess", 27353 xmlMemBlocks() - mem_base); 27354 test_ret++; 27355 printf(" %d", n_doc); 27356 printf("\n"); 27357 } 27358 } 27359 function_tests++; 27360 #endif 27361 27362 return(test_ret); 27363 } 27364 27365 27366 static int 27367 test_xmlXIncludeProcessFlags(void) { 27368 int test_ret = 0; 27369 27370 #if defined(LIBXML_XINCLUDE_ENABLED) 27371 int mem_base; 27372 int ret_val; 27373 xmlDocPtr doc; /* an XML document */ 27374 int n_doc; 27375 int flags; /* a set of xmlParserOption used for parsing XML includes */ 27376 int n_flags; 27377 27378 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 27379 for (n_flags = 0;n_flags < gen_nb_int;n_flags++) { 27380 mem_base = xmlMemBlocks(); 27381 doc = gen_xmlDocPtr(n_doc, 0); 27382 flags = gen_int(n_flags, 1); 27383 27384 ret_val = xmlXIncludeProcessFlags(doc, flags); 27385 desret_int(ret_val); 27386 call_tests++; 27387 des_xmlDocPtr(n_doc, doc, 0); 27388 des_int(n_flags, flags, 1); 27389 xmlResetLastError(); 27390 if (mem_base != xmlMemBlocks()) { 27391 printf("Leak of %d blocks found in xmlXIncludeProcessFlags", 27392 xmlMemBlocks() - mem_base); 27393 test_ret++; 27394 printf(" %d", n_doc); 27395 printf(" %d", n_flags); 27396 printf("\n"); 27397 } 27398 } 27399 } 27400 function_tests++; 27401 #endif 27402 27403 return(test_ret); 27404 } 27405 27406 27407 static int 27408 test_xmlXIncludeProcessFlagsData(void) { 27409 int test_ret = 0; 27410 27411 #if defined(LIBXML_XINCLUDE_ENABLED) 27412 int mem_base; 27413 int ret_val; 27414 xmlDocPtr doc; /* an XML document */ 27415 int n_doc; 27416 int flags; /* a set of xmlParserOption used for parsing XML includes */ 27417 int n_flags; 27418 void * data; /* application data that will be passed to the parser context in the _private field of the parser context(s) */ 27419 int n_data; 27420 27421 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 27422 for (n_flags = 0;n_flags < gen_nb_int;n_flags++) { 27423 for (n_data = 0;n_data < gen_nb_userdata;n_data++) { 27424 mem_base = xmlMemBlocks(); 27425 doc = gen_xmlDocPtr(n_doc, 0); 27426 flags = gen_int(n_flags, 1); 27427 data = gen_userdata(n_data, 2); 27428 27429 ret_val = xmlXIncludeProcessFlagsData(doc, flags, data); 27430 desret_int(ret_val); 27431 call_tests++; 27432 des_xmlDocPtr(n_doc, doc, 0); 27433 des_int(n_flags, flags, 1); 27434 des_userdata(n_data, data, 2); 27435 xmlResetLastError(); 27436 if (mem_base != xmlMemBlocks()) { 27437 printf("Leak of %d blocks found in xmlXIncludeProcessFlagsData", 27438 xmlMemBlocks() - mem_base); 27439 test_ret++; 27440 printf(" %d", n_doc); 27441 printf(" %d", n_flags); 27442 printf(" %d", n_data); 27443 printf("\n"); 27444 } 27445 } 27446 } 27447 } 27448 function_tests++; 27449 #endif 27450 27451 return(test_ret); 27452 } 27453 27454 #ifdef LIBXML_XINCLUDE_ENABLED 27455 27456 #define gen_nb_xmlXIncludeCtxtPtr 1 27457 static xmlXIncludeCtxtPtr gen_xmlXIncludeCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 27458 return(NULL); 27459 } 27460 static void des_xmlXIncludeCtxtPtr(int no ATTRIBUTE_UNUSED, xmlXIncludeCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 27461 } 27462 #endif 27463 27464 27465 static int 27466 test_xmlXIncludeProcessNode(void) { 27467 int test_ret = 0; 27468 27469 #if defined(LIBXML_XINCLUDE_ENABLED) 27470 int mem_base; 27471 int ret_val; 27472 xmlXIncludeCtxtPtr ctxt; /* an existing XInclude context */ 27473 int n_ctxt; 27474 xmlNodePtr node; /* a node in an XML document */ 27475 int n_node; 27476 27477 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXIncludeCtxtPtr;n_ctxt++) { 27478 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 27479 mem_base = xmlMemBlocks(); 27480 ctxt = gen_xmlXIncludeCtxtPtr(n_ctxt, 0); 27481 node = gen_xmlNodePtr(n_node, 1); 27482 27483 ret_val = xmlXIncludeProcessNode(ctxt, node); 27484 desret_int(ret_val); 27485 call_tests++; 27486 des_xmlXIncludeCtxtPtr(n_ctxt, ctxt, 0); 27487 des_xmlNodePtr(n_node, node, 1); 27488 xmlResetLastError(); 27489 if (mem_base != xmlMemBlocks()) { 27490 printf("Leak of %d blocks found in xmlXIncludeProcessNode", 27491 xmlMemBlocks() - mem_base); 27492 test_ret++; 27493 printf(" %d", n_ctxt); 27494 printf(" %d", n_node); 27495 printf("\n"); 27496 } 27497 } 27498 } 27499 function_tests++; 27500 #endif 27501 27502 return(test_ret); 27503 } 27504 27505 27506 static int 27507 test_xmlXIncludeProcessTree(void) { 27508 int test_ret = 0; 27509 27510 #if defined(LIBXML_XINCLUDE_ENABLED) 27511 int mem_base; 27512 int ret_val; 27513 xmlNodePtr tree; /* a node in an XML document */ 27514 int n_tree; 27515 27516 for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) { 27517 mem_base = xmlMemBlocks(); 27518 tree = gen_xmlNodePtr(n_tree, 0); 27519 27520 ret_val = xmlXIncludeProcessTree(tree); 27521 desret_int(ret_val); 27522 call_tests++; 27523 des_xmlNodePtr(n_tree, tree, 0); 27524 xmlResetLastError(); 27525 if (mem_base != xmlMemBlocks()) { 27526 printf("Leak of %d blocks found in xmlXIncludeProcessTree", 27527 xmlMemBlocks() - mem_base); 27528 test_ret++; 27529 printf(" %d", n_tree); 27530 printf("\n"); 27531 } 27532 } 27533 function_tests++; 27534 #endif 27535 27536 return(test_ret); 27537 } 27538 27539 27540 static int 27541 test_xmlXIncludeProcessTreeFlags(void) { 27542 int test_ret = 0; 27543 27544 #if defined(LIBXML_XINCLUDE_ENABLED) 27545 int mem_base; 27546 int ret_val; 27547 xmlNodePtr tree; /* a node in an XML document */ 27548 int n_tree; 27549 int flags; /* a set of xmlParserOption used for parsing XML includes */ 27550 int n_flags; 27551 27552 for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) { 27553 for (n_flags = 0;n_flags < gen_nb_int;n_flags++) { 27554 mem_base = xmlMemBlocks(); 27555 tree = gen_xmlNodePtr(n_tree, 0); 27556 flags = gen_int(n_flags, 1); 27557 27558 ret_val = xmlXIncludeProcessTreeFlags(tree, flags); 27559 desret_int(ret_val); 27560 call_tests++; 27561 des_xmlNodePtr(n_tree, tree, 0); 27562 des_int(n_flags, flags, 1); 27563 xmlResetLastError(); 27564 if (mem_base != xmlMemBlocks()) { 27565 printf("Leak of %d blocks found in xmlXIncludeProcessTreeFlags", 27566 xmlMemBlocks() - mem_base); 27567 test_ret++; 27568 printf(" %d", n_tree); 27569 printf(" %d", n_flags); 27570 printf("\n"); 27571 } 27572 } 27573 } 27574 function_tests++; 27575 #endif 27576 27577 return(test_ret); 27578 } 27579 27580 27581 static int 27582 test_xmlXIncludeProcessTreeFlagsData(void) { 27583 int test_ret = 0; 27584 27585 #if defined(LIBXML_XINCLUDE_ENABLED) 27586 int mem_base; 27587 int ret_val; 27588 xmlNodePtr tree; /* an XML node */ 27589 int n_tree; 27590 int flags; /* a set of xmlParserOption used for parsing XML includes */ 27591 int n_flags; 27592 void * data; /* application data that will be passed to the parser context in the _private field of the parser context(s) */ 27593 int n_data; 27594 27595 for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) { 27596 for (n_flags = 0;n_flags < gen_nb_int;n_flags++) { 27597 for (n_data = 0;n_data < gen_nb_userdata;n_data++) { 27598 mem_base = xmlMemBlocks(); 27599 tree = gen_xmlNodePtr(n_tree, 0); 27600 flags = gen_int(n_flags, 1); 27601 data = gen_userdata(n_data, 2); 27602 27603 ret_val = xmlXIncludeProcessTreeFlagsData(tree, flags, data); 27604 desret_int(ret_val); 27605 call_tests++; 27606 des_xmlNodePtr(n_tree, tree, 0); 27607 des_int(n_flags, flags, 1); 27608 des_userdata(n_data, data, 2); 27609 xmlResetLastError(); 27610 if (mem_base != xmlMemBlocks()) { 27611 printf("Leak of %d blocks found in xmlXIncludeProcessTreeFlagsData", 27612 xmlMemBlocks() - mem_base); 27613 test_ret++; 27614 printf(" %d", n_tree); 27615 printf(" %d", n_flags); 27616 printf(" %d", n_data); 27617 printf("\n"); 27618 } 27619 } 27620 } 27621 } 27622 function_tests++; 27623 #endif 27624 27625 return(test_ret); 27626 } 27627 27628 27629 static int 27630 test_xmlXIncludeSetFlags(void) { 27631 int test_ret = 0; 27632 27633 #if defined(LIBXML_XINCLUDE_ENABLED) 27634 int mem_base; 27635 int ret_val; 27636 xmlXIncludeCtxtPtr ctxt; /* an XInclude processing context */ 27637 int n_ctxt; 27638 int flags; /* a set of xmlParserOption used for parsing XML includes */ 27639 int n_flags; 27640 27641 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXIncludeCtxtPtr;n_ctxt++) { 27642 for (n_flags = 0;n_flags < gen_nb_int;n_flags++) { 27643 mem_base = xmlMemBlocks(); 27644 ctxt = gen_xmlXIncludeCtxtPtr(n_ctxt, 0); 27645 flags = gen_int(n_flags, 1); 27646 27647 ret_val = xmlXIncludeSetFlags(ctxt, flags); 27648 desret_int(ret_val); 27649 call_tests++; 27650 des_xmlXIncludeCtxtPtr(n_ctxt, ctxt, 0); 27651 des_int(n_flags, flags, 1); 27652 xmlResetLastError(); 27653 if (mem_base != xmlMemBlocks()) { 27654 printf("Leak of %d blocks found in xmlXIncludeSetFlags", 27655 xmlMemBlocks() - mem_base); 27656 test_ret++; 27657 printf(" %d", n_ctxt); 27658 printf(" %d", n_flags); 27659 printf("\n"); 27660 } 27661 } 27662 } 27663 function_tests++; 27664 #endif 27665 27666 return(test_ret); 27667 } 27668 27669 static int 27670 test_xinclude(void) { 27671 int test_ret = 0; 27672 27673 if (quiet == 0) printf("Testing xinclude : 8 of 10 functions ...\n"); 27674 test_ret += test_xmlXIncludeNewContext(); 27675 test_ret += test_xmlXIncludeProcess(); 27676 test_ret += test_xmlXIncludeProcessFlags(); 27677 test_ret += test_xmlXIncludeProcessFlagsData(); 27678 test_ret += test_xmlXIncludeProcessNode(); 27679 test_ret += test_xmlXIncludeProcessTree(); 27680 test_ret += test_xmlXIncludeProcessTreeFlags(); 27681 test_ret += test_xmlXIncludeProcessTreeFlagsData(); 27682 test_ret += test_xmlXIncludeSetFlags(); 27683 27684 if (test_ret != 0) 27685 printf("Module xinclude: %d errors\n", test_ret); 27686 return(test_ret); 27687 } 27688 27689 static int 27690 test_xmlAllocOutputBuffer(void) { 27691 int test_ret = 0; 27692 27693 #if defined(LIBXML_OUTPUT_ENABLED) 27694 int mem_base; 27695 xmlOutputBufferPtr ret_val; 27696 xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */ 27697 int n_encoder; 27698 27699 for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) { 27700 mem_base = xmlMemBlocks(); 27701 encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 0); 27702 27703 ret_val = xmlAllocOutputBuffer(encoder); 27704 desret_xmlOutputBufferPtr(ret_val); 27705 call_tests++; 27706 des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 0); 27707 xmlResetLastError(); 27708 if (mem_base != xmlMemBlocks()) { 27709 printf("Leak of %d blocks found in xmlAllocOutputBuffer", 27710 xmlMemBlocks() - mem_base); 27711 test_ret++; 27712 printf(" %d", n_encoder); 27713 printf("\n"); 27714 } 27715 } 27716 function_tests++; 27717 #endif 27718 27719 return(test_ret); 27720 } 27721 27722 27723 static int 27724 test_xmlAllocParserInputBuffer(void) { 27725 int test_ret = 0; 27726 27727 int mem_base; 27728 xmlParserInputBufferPtr ret_val; 27729 xmlCharEncoding enc; /* the charset encoding if known */ 27730 int n_enc; 27731 27732 for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) { 27733 mem_base = xmlMemBlocks(); 27734 enc = gen_xmlCharEncoding(n_enc, 0); 27735 27736 ret_val = xmlAllocParserInputBuffer(enc); 27737 desret_xmlParserInputBufferPtr(ret_val); 27738 call_tests++; 27739 des_xmlCharEncoding(n_enc, enc, 0); 27740 xmlResetLastError(); 27741 if (mem_base != xmlMemBlocks()) { 27742 printf("Leak of %d blocks found in xmlAllocParserInputBuffer", 27743 xmlMemBlocks() - mem_base); 27744 test_ret++; 27745 printf(" %d", n_enc); 27746 printf("\n"); 27747 } 27748 } 27749 function_tests++; 27750 27751 return(test_ret); 27752 } 27753 27754 27755 static int 27756 test_xmlCheckFilename(void) { 27757 int test_ret = 0; 27758 27759 int mem_base; 27760 int ret_val; 27761 char * path; /* the path to check */ 27762 int n_path; 27763 27764 for (n_path = 0;n_path < gen_nb_const_char_ptr;n_path++) { 27765 mem_base = xmlMemBlocks(); 27766 path = gen_const_char_ptr(n_path, 0); 27767 27768 ret_val = xmlCheckFilename((const char *)path); 27769 desret_int(ret_val); 27770 call_tests++; 27771 des_const_char_ptr(n_path, (const char *)path, 0); 27772 xmlResetLastError(); 27773 if (mem_base != xmlMemBlocks()) { 27774 printf("Leak of %d blocks found in xmlCheckFilename", 27775 xmlMemBlocks() - mem_base); 27776 test_ret++; 27777 printf(" %d", n_path); 27778 printf("\n"); 27779 } 27780 } 27781 function_tests++; 27782 27783 return(test_ret); 27784 } 27785 27786 27787 static int 27788 test_xmlCheckHTTPInput(void) { 27789 int test_ret = 0; 27790 27791 int mem_base; 27792 xmlParserInputPtr ret_val; 27793 xmlParserCtxtPtr ctxt; /* an XML parser context */ 27794 int n_ctxt; 27795 xmlParserInputPtr ret; /* an XML parser input */ 27796 int n_ret; 27797 27798 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 27799 for (n_ret = 0;n_ret < gen_nb_xmlParserInputPtr;n_ret++) { 27800 mem_base = xmlMemBlocks(); 27801 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 27802 ret = gen_xmlParserInputPtr(n_ret, 1); 27803 27804 ret_val = xmlCheckHTTPInput(ctxt, ret); 27805 desret_xmlParserInputPtr(ret_val); 27806 call_tests++; 27807 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 27808 des_xmlParserInputPtr(n_ret, ret, 1); 27809 xmlResetLastError(); 27810 if (mem_base != xmlMemBlocks()) { 27811 printf("Leak of %d blocks found in xmlCheckHTTPInput", 27812 xmlMemBlocks() - mem_base); 27813 test_ret++; 27814 printf(" %d", n_ctxt); 27815 printf(" %d", n_ret); 27816 printf("\n"); 27817 } 27818 } 27819 } 27820 function_tests++; 27821 27822 return(test_ret); 27823 } 27824 27825 27826 static int 27827 test_xmlCleanupInputCallbacks(void) { 27828 int test_ret = 0; 27829 27830 int mem_base; 27831 27832 mem_base = xmlMemBlocks(); 27833 27834 xmlCleanupInputCallbacks(); 27835 call_tests++; 27836 xmlResetLastError(); 27837 if (mem_base != xmlMemBlocks()) { 27838 printf("Leak of %d blocks found in xmlCleanupInputCallbacks", 27839 xmlMemBlocks() - mem_base); 27840 test_ret++; 27841 printf("\n"); 27842 } 27843 function_tests++; 27844 27845 return(test_ret); 27846 } 27847 27848 27849 static int 27850 test_xmlCleanupOutputCallbacks(void) { 27851 int test_ret = 0; 27852 27853 #if defined(LIBXML_OUTPUT_ENABLED) 27854 int mem_base; 27855 27856 mem_base = xmlMemBlocks(); 27857 27858 xmlCleanupOutputCallbacks(); 27859 call_tests++; 27860 xmlResetLastError(); 27861 if (mem_base != xmlMemBlocks()) { 27862 printf("Leak of %d blocks found in xmlCleanupOutputCallbacks", 27863 xmlMemBlocks() - mem_base); 27864 test_ret++; 27865 printf("\n"); 27866 } 27867 function_tests++; 27868 #endif 27869 27870 return(test_ret); 27871 } 27872 27873 27874 static int 27875 test_xmlFileClose(void) { 27876 int test_ret = 0; 27877 27878 int mem_base; 27879 int ret_val; 27880 void * context; /* the I/O context */ 27881 int n_context; 27882 27883 for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) { 27884 mem_base = xmlMemBlocks(); 27885 context = gen_void_ptr(n_context, 0); 27886 27887 ret_val = xmlFileClose(context); 27888 desret_int(ret_val); 27889 call_tests++; 27890 des_void_ptr(n_context, context, 0); 27891 xmlResetLastError(); 27892 if (mem_base != xmlMemBlocks()) { 27893 printf("Leak of %d blocks found in xmlFileClose", 27894 xmlMemBlocks() - mem_base); 27895 test_ret++; 27896 printf(" %d", n_context); 27897 printf("\n"); 27898 } 27899 } 27900 function_tests++; 27901 27902 return(test_ret); 27903 } 27904 27905 27906 static int 27907 test_xmlFileMatch(void) { 27908 int test_ret = 0; 27909 27910 int mem_base; 27911 int ret_val; 27912 const char * filename; /* the URI for matching */ 27913 int n_filename; 27914 27915 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 27916 mem_base = xmlMemBlocks(); 27917 filename = gen_filepath(n_filename, 0); 27918 27919 ret_val = xmlFileMatch(filename); 27920 desret_int(ret_val); 27921 call_tests++; 27922 des_filepath(n_filename, filename, 0); 27923 xmlResetLastError(); 27924 if (mem_base != xmlMemBlocks()) { 27925 printf("Leak of %d blocks found in xmlFileMatch", 27926 xmlMemBlocks() - mem_base); 27927 test_ret++; 27928 printf(" %d", n_filename); 27929 printf("\n"); 27930 } 27931 } 27932 function_tests++; 27933 27934 return(test_ret); 27935 } 27936 27937 27938 static int 27939 test_xmlFileOpen(void) { 27940 int test_ret = 0; 27941 27942 int mem_base; 27943 void * ret_val; 27944 const char * filename; /* the URI for matching */ 27945 int n_filename; 27946 27947 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 27948 mem_base = xmlMemBlocks(); 27949 filename = gen_filepath(n_filename, 0); 27950 27951 ret_val = xmlFileOpen(filename); 27952 desret_void_ptr(ret_val); 27953 call_tests++; 27954 des_filepath(n_filename, filename, 0); 27955 xmlResetLastError(); 27956 if (mem_base != xmlMemBlocks()) { 27957 printf("Leak of %d blocks found in xmlFileOpen", 27958 xmlMemBlocks() - mem_base); 27959 test_ret++; 27960 printf(" %d", n_filename); 27961 printf("\n"); 27962 } 27963 } 27964 function_tests++; 27965 27966 return(test_ret); 27967 } 27968 27969 27970 static int 27971 test_xmlFileRead(void) { 27972 int test_ret = 0; 27973 27974 int mem_base; 27975 int ret_val; 27976 void * context; /* the I/O context */ 27977 int n_context; 27978 char * buffer; /* where to drop data */ 27979 int n_buffer; 27980 int len; /* number of bytes to write */ 27981 int n_len; 27982 27983 for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) { 27984 for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) { 27985 for (n_len = 0;n_len < gen_nb_int;n_len++) { 27986 mem_base = xmlMemBlocks(); 27987 context = gen_void_ptr(n_context, 0); 27988 buffer = gen_char_ptr(n_buffer, 1); 27989 len = gen_int(n_len, 2); 27990 27991 ret_val = xmlFileRead(context, buffer, len); 27992 desret_int(ret_val); 27993 call_tests++; 27994 des_void_ptr(n_context, context, 0); 27995 des_char_ptr(n_buffer, buffer, 1); 27996 des_int(n_len, len, 2); 27997 xmlResetLastError(); 27998 if (mem_base != xmlMemBlocks()) { 27999 printf("Leak of %d blocks found in xmlFileRead", 28000 xmlMemBlocks() - mem_base); 28001 test_ret++; 28002 printf(" %d", n_context); 28003 printf(" %d", n_buffer); 28004 printf(" %d", n_len); 28005 printf("\n"); 28006 } 28007 } 28008 } 28009 } 28010 function_tests++; 28011 28012 return(test_ret); 28013 } 28014 28015 28016 static int 28017 test_xmlIOFTPClose(void) { 28018 int test_ret = 0; 28019 28020 #if defined(LIBXML_FTP_ENABLED) 28021 int mem_base; 28022 int ret_val; 28023 void * context; /* the I/O context */ 28024 int n_context; 28025 28026 for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) { 28027 mem_base = xmlMemBlocks(); 28028 context = gen_void_ptr(n_context, 0); 28029 28030 ret_val = xmlIOFTPClose(context); 28031 desret_int(ret_val); 28032 call_tests++; 28033 des_void_ptr(n_context, context, 0); 28034 xmlResetLastError(); 28035 if (mem_base != xmlMemBlocks()) { 28036 printf("Leak of %d blocks found in xmlIOFTPClose", 28037 xmlMemBlocks() - mem_base); 28038 test_ret++; 28039 printf(" %d", n_context); 28040 printf("\n"); 28041 } 28042 } 28043 function_tests++; 28044 #endif 28045 28046 return(test_ret); 28047 } 28048 28049 28050 static int 28051 test_xmlIOFTPMatch(void) { 28052 int test_ret = 0; 28053 28054 #if defined(LIBXML_FTP_ENABLED) 28055 int mem_base; 28056 int ret_val; 28057 const char * filename; /* the URI for matching */ 28058 int n_filename; 28059 28060 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 28061 mem_base = xmlMemBlocks(); 28062 filename = gen_filepath(n_filename, 0); 28063 28064 ret_val = xmlIOFTPMatch(filename); 28065 desret_int(ret_val); 28066 call_tests++; 28067 des_filepath(n_filename, filename, 0); 28068 xmlResetLastError(); 28069 if (mem_base != xmlMemBlocks()) { 28070 printf("Leak of %d blocks found in xmlIOFTPMatch", 28071 xmlMemBlocks() - mem_base); 28072 test_ret++; 28073 printf(" %d", n_filename); 28074 printf("\n"); 28075 } 28076 } 28077 function_tests++; 28078 #endif 28079 28080 return(test_ret); 28081 } 28082 28083 28084 static int 28085 test_xmlIOFTPOpen(void) { 28086 int test_ret = 0; 28087 28088 #if defined(LIBXML_FTP_ENABLED) 28089 int mem_base; 28090 void * ret_val; 28091 const char * filename; /* the URI for matching */ 28092 int n_filename; 28093 28094 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 28095 mem_base = xmlMemBlocks(); 28096 filename = gen_filepath(n_filename, 0); 28097 28098 ret_val = xmlIOFTPOpen(filename); 28099 desret_void_ptr(ret_val); 28100 call_tests++; 28101 des_filepath(n_filename, filename, 0); 28102 xmlResetLastError(); 28103 if (mem_base != xmlMemBlocks()) { 28104 printf("Leak of %d blocks found in xmlIOFTPOpen", 28105 xmlMemBlocks() - mem_base); 28106 test_ret++; 28107 printf(" %d", n_filename); 28108 printf("\n"); 28109 } 28110 } 28111 function_tests++; 28112 #endif 28113 28114 return(test_ret); 28115 } 28116 28117 28118 static int 28119 test_xmlIOFTPRead(void) { 28120 int test_ret = 0; 28121 28122 #if defined(LIBXML_FTP_ENABLED) 28123 int mem_base; 28124 int ret_val; 28125 void * context; /* the I/O context */ 28126 int n_context; 28127 char * buffer; /* where to drop data */ 28128 int n_buffer; 28129 int len; /* number of bytes to write */ 28130 int n_len; 28131 28132 for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) { 28133 for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) { 28134 for (n_len = 0;n_len < gen_nb_int;n_len++) { 28135 mem_base = xmlMemBlocks(); 28136 context = gen_void_ptr(n_context, 0); 28137 buffer = gen_char_ptr(n_buffer, 1); 28138 len = gen_int(n_len, 2); 28139 28140 ret_val = xmlIOFTPRead(context, buffer, len); 28141 desret_int(ret_val); 28142 call_tests++; 28143 des_void_ptr(n_context, context, 0); 28144 des_char_ptr(n_buffer, buffer, 1); 28145 des_int(n_len, len, 2); 28146 xmlResetLastError(); 28147 if (mem_base != xmlMemBlocks()) { 28148 printf("Leak of %d blocks found in xmlIOFTPRead", 28149 xmlMemBlocks() - mem_base); 28150 test_ret++; 28151 printf(" %d", n_context); 28152 printf(" %d", n_buffer); 28153 printf(" %d", n_len); 28154 printf("\n"); 28155 } 28156 } 28157 } 28158 } 28159 function_tests++; 28160 #endif 28161 28162 return(test_ret); 28163 } 28164 28165 28166 static int 28167 test_xmlIOHTTPClose(void) { 28168 int test_ret = 0; 28169 28170 #if defined(LIBXML_HTTP_ENABLED) 28171 int mem_base; 28172 int ret_val; 28173 void * context; /* the I/O context */ 28174 int n_context; 28175 28176 for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) { 28177 mem_base = xmlMemBlocks(); 28178 context = gen_void_ptr(n_context, 0); 28179 28180 ret_val = xmlIOHTTPClose(context); 28181 desret_int(ret_val); 28182 call_tests++; 28183 des_void_ptr(n_context, context, 0); 28184 xmlResetLastError(); 28185 if (mem_base != xmlMemBlocks()) { 28186 printf("Leak of %d blocks found in xmlIOHTTPClose", 28187 xmlMemBlocks() - mem_base); 28188 test_ret++; 28189 printf(" %d", n_context); 28190 printf("\n"); 28191 } 28192 } 28193 function_tests++; 28194 #endif 28195 28196 return(test_ret); 28197 } 28198 28199 28200 static int 28201 test_xmlIOHTTPMatch(void) { 28202 int test_ret = 0; 28203 28204 #if defined(LIBXML_HTTP_ENABLED) 28205 int mem_base; 28206 int ret_val; 28207 const char * filename; /* the URI for matching */ 28208 int n_filename; 28209 28210 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 28211 mem_base = xmlMemBlocks(); 28212 filename = gen_filepath(n_filename, 0); 28213 28214 ret_val = xmlIOHTTPMatch(filename); 28215 desret_int(ret_val); 28216 call_tests++; 28217 des_filepath(n_filename, filename, 0); 28218 xmlResetLastError(); 28219 if (mem_base != xmlMemBlocks()) { 28220 printf("Leak of %d blocks found in xmlIOHTTPMatch", 28221 xmlMemBlocks() - mem_base); 28222 test_ret++; 28223 printf(" %d", n_filename); 28224 printf("\n"); 28225 } 28226 } 28227 function_tests++; 28228 #endif 28229 28230 return(test_ret); 28231 } 28232 28233 28234 static int 28235 test_xmlIOHTTPOpen(void) { 28236 int test_ret = 0; 28237 28238 #if defined(LIBXML_HTTP_ENABLED) 28239 int mem_base; 28240 void * ret_val; 28241 const char * filename; /* the URI for matching */ 28242 int n_filename; 28243 28244 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 28245 mem_base = xmlMemBlocks(); 28246 filename = gen_filepath(n_filename, 0); 28247 28248 ret_val = xmlIOHTTPOpen(filename); 28249 desret_xmlNanoHTTPCtxtPtr(ret_val); 28250 call_tests++; 28251 des_filepath(n_filename, filename, 0); 28252 xmlResetLastError(); 28253 if (mem_base != xmlMemBlocks()) { 28254 printf("Leak of %d blocks found in xmlIOHTTPOpen", 28255 xmlMemBlocks() - mem_base); 28256 test_ret++; 28257 printf(" %d", n_filename); 28258 printf("\n"); 28259 } 28260 } 28261 function_tests++; 28262 #endif 28263 28264 return(test_ret); 28265 } 28266 28267 28268 static int 28269 test_xmlIOHTTPRead(void) { 28270 int test_ret = 0; 28271 28272 #if defined(LIBXML_HTTP_ENABLED) 28273 int mem_base; 28274 int ret_val; 28275 void * context; /* the I/O context */ 28276 int n_context; 28277 char * buffer; /* where to drop data */ 28278 int n_buffer; 28279 int len; /* number of bytes to write */ 28280 int n_len; 28281 28282 for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) { 28283 for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) { 28284 for (n_len = 0;n_len < gen_nb_int;n_len++) { 28285 mem_base = xmlMemBlocks(); 28286 context = gen_void_ptr(n_context, 0); 28287 buffer = gen_char_ptr(n_buffer, 1); 28288 len = gen_int(n_len, 2); 28289 28290 ret_val = xmlIOHTTPRead(context, buffer, len); 28291 desret_int(ret_val); 28292 call_tests++; 28293 des_void_ptr(n_context, context, 0); 28294 des_char_ptr(n_buffer, buffer, 1); 28295 des_int(n_len, len, 2); 28296 xmlResetLastError(); 28297 if (mem_base != xmlMemBlocks()) { 28298 printf("Leak of %d blocks found in xmlIOHTTPRead", 28299 xmlMemBlocks() - mem_base); 28300 test_ret++; 28301 printf(" %d", n_context); 28302 printf(" %d", n_buffer); 28303 printf(" %d", n_len); 28304 printf("\n"); 28305 } 28306 } 28307 } 28308 } 28309 function_tests++; 28310 #endif 28311 28312 return(test_ret); 28313 } 28314 28315 28316 static int 28317 test_xmlNoNetExternalEntityLoader(void) { 28318 int test_ret = 0; 28319 28320 int mem_base; 28321 xmlParserInputPtr ret_val; 28322 const char * URL; /* the URL for the entity to load */ 28323 int n_URL; 28324 char * ID; /* the System ID for the entity to load */ 28325 int n_ID; 28326 xmlParserCtxtPtr ctxt; /* the context in which the entity is called or NULL */ 28327 int n_ctxt; 28328 28329 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 28330 for (n_ID = 0;n_ID < gen_nb_const_char_ptr;n_ID++) { 28331 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 28332 mem_base = xmlMemBlocks(); 28333 URL = gen_filepath(n_URL, 0); 28334 ID = gen_const_char_ptr(n_ID, 1); 28335 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 2); 28336 28337 ret_val = xmlNoNetExternalEntityLoader(URL, (const char *)ID, ctxt); 28338 desret_xmlParserInputPtr(ret_val); 28339 call_tests++; 28340 des_filepath(n_URL, URL, 0); 28341 des_const_char_ptr(n_ID, (const char *)ID, 1); 28342 des_xmlParserCtxtPtr(n_ctxt, ctxt, 2); 28343 xmlResetLastError(); 28344 if (mem_base != xmlMemBlocks()) { 28345 printf("Leak of %d blocks found in xmlNoNetExternalEntityLoader", 28346 xmlMemBlocks() - mem_base); 28347 test_ret++; 28348 printf(" %d", n_URL); 28349 printf(" %d", n_ID); 28350 printf(" %d", n_ctxt); 28351 printf("\n"); 28352 } 28353 } 28354 } 28355 } 28356 function_tests++; 28357 28358 return(test_ret); 28359 } 28360 28361 28362 static int 28363 test_xmlNormalizeWindowsPath(void) { 28364 int test_ret = 0; 28365 28366 int mem_base; 28367 xmlChar * ret_val; 28368 xmlChar * path; /* the input file path */ 28369 int n_path; 28370 28371 for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) { 28372 mem_base = xmlMemBlocks(); 28373 path = gen_const_xmlChar_ptr(n_path, 0); 28374 28375 ret_val = xmlNormalizeWindowsPath((const xmlChar *)path); 28376 desret_xmlChar_ptr(ret_val); 28377 call_tests++; 28378 des_const_xmlChar_ptr(n_path, (const xmlChar *)path, 0); 28379 xmlResetLastError(); 28380 if (mem_base != xmlMemBlocks()) { 28381 printf("Leak of %d blocks found in xmlNormalizeWindowsPath", 28382 xmlMemBlocks() - mem_base); 28383 test_ret++; 28384 printf(" %d", n_path); 28385 printf("\n"); 28386 } 28387 } 28388 function_tests++; 28389 28390 return(test_ret); 28391 } 28392 28393 28394 static int 28395 test_xmlOutputBufferCreateBuffer(void) { 28396 int test_ret = 0; 28397 28398 #if defined(LIBXML_OUTPUT_ENABLED) 28399 int mem_base; 28400 xmlOutputBufferPtr ret_val; 28401 xmlBufferPtr buffer; /* a xmlBufferPtr */ 28402 int n_buffer; 28403 xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */ 28404 int n_encoder; 28405 28406 for (n_buffer = 0;n_buffer < gen_nb_xmlBufferPtr;n_buffer++) { 28407 for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) { 28408 mem_base = xmlMemBlocks(); 28409 buffer = gen_xmlBufferPtr(n_buffer, 0); 28410 encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1); 28411 28412 ret_val = xmlOutputBufferCreateBuffer(buffer, encoder); 28413 desret_xmlOutputBufferPtr(ret_val); 28414 call_tests++; 28415 des_xmlBufferPtr(n_buffer, buffer, 0); 28416 des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1); 28417 xmlResetLastError(); 28418 if (mem_base != xmlMemBlocks()) { 28419 printf("Leak of %d blocks found in xmlOutputBufferCreateBuffer", 28420 xmlMemBlocks() - mem_base); 28421 test_ret++; 28422 printf(" %d", n_buffer); 28423 printf(" %d", n_encoder); 28424 printf("\n"); 28425 } 28426 } 28427 } 28428 function_tests++; 28429 #endif 28430 28431 return(test_ret); 28432 } 28433 28434 28435 static int 28436 test_xmlOutputBufferCreateFd(void) { 28437 int test_ret = 0; 28438 28439 #if defined(LIBXML_OUTPUT_ENABLED) 28440 int mem_base; 28441 xmlOutputBufferPtr ret_val; 28442 int fd; /* a file descriptor number */ 28443 int n_fd; 28444 xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */ 28445 int n_encoder; 28446 28447 for (n_fd = 0;n_fd < gen_nb_int;n_fd++) { 28448 for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) { 28449 mem_base = xmlMemBlocks(); 28450 fd = gen_int(n_fd, 0); 28451 encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1); 28452 28453 ret_val = xmlOutputBufferCreateFd(fd, encoder); 28454 desret_xmlOutputBufferPtr(ret_val); 28455 call_tests++; 28456 des_int(n_fd, fd, 0); 28457 des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1); 28458 xmlResetLastError(); 28459 if (mem_base != xmlMemBlocks()) { 28460 printf("Leak of %d blocks found in xmlOutputBufferCreateFd", 28461 xmlMemBlocks() - mem_base); 28462 test_ret++; 28463 printf(" %d", n_fd); 28464 printf(" %d", n_encoder); 28465 printf("\n"); 28466 } 28467 } 28468 } 28469 function_tests++; 28470 #endif 28471 28472 return(test_ret); 28473 } 28474 28475 28476 static int 28477 test_xmlOutputBufferCreateFile(void) { 28478 int test_ret = 0; 28479 28480 #if defined(LIBXML_OUTPUT_ENABLED) 28481 int mem_base; 28482 xmlOutputBufferPtr ret_val; 28483 FILE * file; /* a FILE* */ 28484 int n_file; 28485 xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */ 28486 int n_encoder; 28487 28488 for (n_file = 0;n_file < gen_nb_FILE_ptr;n_file++) { 28489 for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) { 28490 mem_base = xmlMemBlocks(); 28491 file = gen_FILE_ptr(n_file, 0); 28492 encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1); 28493 28494 ret_val = xmlOutputBufferCreateFile(file, encoder); 28495 desret_xmlOutputBufferPtr(ret_val); 28496 call_tests++; 28497 des_FILE_ptr(n_file, file, 0); 28498 des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1); 28499 xmlResetLastError(); 28500 if (mem_base != xmlMemBlocks()) { 28501 printf("Leak of %d blocks found in xmlOutputBufferCreateFile", 28502 xmlMemBlocks() - mem_base); 28503 test_ret++; 28504 printf(" %d", n_file); 28505 printf(" %d", n_encoder); 28506 printf("\n"); 28507 } 28508 } 28509 } 28510 function_tests++; 28511 #endif 28512 28513 return(test_ret); 28514 } 28515 28516 28517 static int 28518 test_xmlOutputBufferCreateFilename(void) { 28519 int test_ret = 0; 28520 28521 #if defined(LIBXML_OUTPUT_ENABLED) 28522 int mem_base; 28523 xmlOutputBufferPtr ret_val; 28524 const char * URI; /* a C string containing the URI or filename */ 28525 int n_URI; 28526 xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */ 28527 int n_encoder; 28528 int compression; /* the compression ration (0 none, 9 max). */ 28529 int n_compression; 28530 28531 for (n_URI = 0;n_URI < gen_nb_fileoutput;n_URI++) { 28532 for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) { 28533 for (n_compression = 0;n_compression < gen_nb_int;n_compression++) { 28534 mem_base = xmlMemBlocks(); 28535 URI = gen_fileoutput(n_URI, 0); 28536 encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1); 28537 compression = gen_int(n_compression, 2); 28538 28539 ret_val = xmlOutputBufferCreateFilename(URI, encoder, compression); 28540 desret_xmlOutputBufferPtr(ret_val); 28541 call_tests++; 28542 des_fileoutput(n_URI, URI, 0); 28543 des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1); 28544 des_int(n_compression, compression, 2); 28545 xmlResetLastError(); 28546 if (mem_base != xmlMemBlocks()) { 28547 printf("Leak of %d blocks found in xmlOutputBufferCreateFilename", 28548 xmlMemBlocks() - mem_base); 28549 test_ret++; 28550 printf(" %d", n_URI); 28551 printf(" %d", n_encoder); 28552 printf(" %d", n_compression); 28553 printf("\n"); 28554 } 28555 } 28556 } 28557 } 28558 function_tests++; 28559 #endif 28560 28561 return(test_ret); 28562 } 28563 28564 28565 static int 28566 test_xmlOutputBufferFlush(void) { 28567 int test_ret = 0; 28568 28569 #if defined(LIBXML_OUTPUT_ENABLED) 28570 int mem_base; 28571 int ret_val; 28572 xmlOutputBufferPtr out; /* a buffered output */ 28573 int n_out; 28574 28575 for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) { 28576 mem_base = xmlMemBlocks(); 28577 out = gen_xmlOutputBufferPtr(n_out, 0); 28578 28579 ret_val = xmlOutputBufferFlush(out); 28580 desret_int(ret_val); 28581 call_tests++; 28582 des_xmlOutputBufferPtr(n_out, out, 0); 28583 xmlResetLastError(); 28584 if (mem_base != xmlMemBlocks()) { 28585 printf("Leak of %d blocks found in xmlOutputBufferFlush", 28586 xmlMemBlocks() - mem_base); 28587 test_ret++; 28588 printf(" %d", n_out); 28589 printf("\n"); 28590 } 28591 } 28592 function_tests++; 28593 #endif 28594 28595 return(test_ret); 28596 } 28597 28598 28599 static int 28600 test_xmlOutputBufferGetContent(void) { 28601 int test_ret = 0; 28602 28603 #if defined(LIBXML_OUTPUT_ENABLED) 28604 int mem_base; 28605 const xmlChar * ret_val; 28606 xmlOutputBufferPtr out; /* an xmlOutputBufferPtr */ 28607 int n_out; 28608 28609 for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) { 28610 mem_base = xmlMemBlocks(); 28611 out = gen_xmlOutputBufferPtr(n_out, 0); 28612 28613 ret_val = xmlOutputBufferGetContent(out); 28614 desret_const_xmlChar_ptr(ret_val); 28615 call_tests++; 28616 des_xmlOutputBufferPtr(n_out, out, 0); 28617 xmlResetLastError(); 28618 if (mem_base != xmlMemBlocks()) { 28619 printf("Leak of %d blocks found in xmlOutputBufferGetContent", 28620 xmlMemBlocks() - mem_base); 28621 test_ret++; 28622 printf(" %d", n_out); 28623 printf("\n"); 28624 } 28625 } 28626 function_tests++; 28627 #endif 28628 28629 return(test_ret); 28630 } 28631 28632 28633 static int 28634 test_xmlOutputBufferGetSize(void) { 28635 int test_ret = 0; 28636 28637 28638 /* missing type support */ 28639 return(test_ret); 28640 } 28641 28642 28643 static int 28644 test_xmlOutputBufferWrite(void) { 28645 int test_ret = 0; 28646 28647 #if defined(LIBXML_OUTPUT_ENABLED) 28648 int mem_base; 28649 int ret_val; 28650 xmlOutputBufferPtr out; /* a buffered parser output */ 28651 int n_out; 28652 int len; /* the size in bytes of the array. */ 28653 int n_len; 28654 char * buf; /* an char array */ 28655 int n_buf; 28656 28657 for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) { 28658 for (n_len = 0;n_len < gen_nb_int;n_len++) { 28659 for (n_buf = 0;n_buf < gen_nb_const_char_ptr;n_buf++) { 28660 mem_base = xmlMemBlocks(); 28661 out = gen_xmlOutputBufferPtr(n_out, 0); 28662 len = gen_int(n_len, 1); 28663 buf = gen_const_char_ptr(n_buf, 2); 28664 28665 ret_val = xmlOutputBufferWrite(out, len, (const char *)buf); 28666 desret_int(ret_val); 28667 call_tests++; 28668 des_xmlOutputBufferPtr(n_out, out, 0); 28669 des_int(n_len, len, 1); 28670 des_const_char_ptr(n_buf, (const char *)buf, 2); 28671 xmlResetLastError(); 28672 if (mem_base != xmlMemBlocks()) { 28673 printf("Leak of %d blocks found in xmlOutputBufferWrite", 28674 xmlMemBlocks() - mem_base); 28675 test_ret++; 28676 printf(" %d", n_out); 28677 printf(" %d", n_len); 28678 printf(" %d", n_buf); 28679 printf("\n"); 28680 } 28681 } 28682 } 28683 } 28684 function_tests++; 28685 #endif 28686 28687 return(test_ret); 28688 } 28689 28690 28691 static int 28692 test_xmlOutputBufferWriteEscape(void) { 28693 int test_ret = 0; 28694 28695 28696 /* missing type support */ 28697 return(test_ret); 28698 } 28699 28700 28701 static int 28702 test_xmlOutputBufferWriteString(void) { 28703 int test_ret = 0; 28704 28705 #if defined(LIBXML_OUTPUT_ENABLED) 28706 int mem_base; 28707 int ret_val; 28708 xmlOutputBufferPtr out; /* a buffered parser output */ 28709 int n_out; 28710 char * str; /* a zero terminated C string */ 28711 int n_str; 28712 28713 for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) { 28714 for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) { 28715 mem_base = xmlMemBlocks(); 28716 out = gen_xmlOutputBufferPtr(n_out, 0); 28717 str = gen_const_char_ptr(n_str, 1); 28718 28719 ret_val = xmlOutputBufferWriteString(out, (const char *)str); 28720 desret_int(ret_val); 28721 call_tests++; 28722 des_xmlOutputBufferPtr(n_out, out, 0); 28723 des_const_char_ptr(n_str, (const char *)str, 1); 28724 xmlResetLastError(); 28725 if (mem_base != xmlMemBlocks()) { 28726 printf("Leak of %d blocks found in xmlOutputBufferWriteString", 28727 xmlMemBlocks() - mem_base); 28728 test_ret++; 28729 printf(" %d", n_out); 28730 printf(" %d", n_str); 28731 printf("\n"); 28732 } 28733 } 28734 } 28735 function_tests++; 28736 #endif 28737 28738 return(test_ret); 28739 } 28740 28741 28742 static int 28743 test_xmlParserGetDirectory(void) { 28744 int test_ret = 0; 28745 28746 28747 /* missing type support */ 28748 return(test_ret); 28749 } 28750 28751 28752 static int 28753 test_xmlParserInputBufferCreateFd(void) { 28754 int test_ret = 0; 28755 28756 int mem_base; 28757 xmlParserInputBufferPtr ret_val; 28758 int fd; /* a file descriptor number */ 28759 int n_fd; 28760 xmlCharEncoding enc; /* the charset encoding if known */ 28761 int n_enc; 28762 28763 for (n_fd = 0;n_fd < gen_nb_int;n_fd++) { 28764 for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) { 28765 mem_base = xmlMemBlocks(); 28766 fd = gen_int(n_fd, 0); 28767 enc = gen_xmlCharEncoding(n_enc, 1); 28768 if (fd >= 0) fd = -1; 28769 28770 ret_val = xmlParserInputBufferCreateFd(fd, enc); 28771 desret_xmlParserInputBufferPtr(ret_val); 28772 call_tests++; 28773 des_int(n_fd, fd, 0); 28774 des_xmlCharEncoding(n_enc, enc, 1); 28775 xmlResetLastError(); 28776 if (mem_base != xmlMemBlocks()) { 28777 printf("Leak of %d blocks found in xmlParserInputBufferCreateFd", 28778 xmlMemBlocks() - mem_base); 28779 test_ret++; 28780 printf(" %d", n_fd); 28781 printf(" %d", n_enc); 28782 printf("\n"); 28783 } 28784 } 28785 } 28786 function_tests++; 28787 28788 return(test_ret); 28789 } 28790 28791 28792 static int 28793 test_xmlParserInputBufferCreateFile(void) { 28794 int test_ret = 0; 28795 28796 int mem_base; 28797 xmlParserInputBufferPtr ret_val; 28798 FILE * file; /* a FILE* */ 28799 int n_file; 28800 xmlCharEncoding enc; /* the charset encoding if known */ 28801 int n_enc; 28802 28803 for (n_file = 0;n_file < gen_nb_FILE_ptr;n_file++) { 28804 for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) { 28805 mem_base = xmlMemBlocks(); 28806 file = gen_FILE_ptr(n_file, 0); 28807 enc = gen_xmlCharEncoding(n_enc, 1); 28808 28809 ret_val = xmlParserInputBufferCreateFile(file, enc); 28810 desret_xmlParserInputBufferPtr(ret_val); 28811 call_tests++; 28812 des_FILE_ptr(n_file, file, 0); 28813 des_xmlCharEncoding(n_enc, enc, 1); 28814 xmlResetLastError(); 28815 if (mem_base != xmlMemBlocks()) { 28816 printf("Leak of %d blocks found in xmlParserInputBufferCreateFile", 28817 xmlMemBlocks() - mem_base); 28818 test_ret++; 28819 printf(" %d", n_file); 28820 printf(" %d", n_enc); 28821 printf("\n"); 28822 } 28823 } 28824 } 28825 function_tests++; 28826 28827 return(test_ret); 28828 } 28829 28830 28831 static int 28832 test_xmlParserInputBufferCreateFilename(void) { 28833 int test_ret = 0; 28834 28835 int mem_base; 28836 xmlParserInputBufferPtr ret_val; 28837 const char * URI; /* a C string containing the URI or filename */ 28838 int n_URI; 28839 xmlCharEncoding enc; /* the charset encoding if known */ 28840 int n_enc; 28841 28842 for (n_URI = 0;n_URI < gen_nb_fileoutput;n_URI++) { 28843 for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) { 28844 mem_base = xmlMemBlocks(); 28845 URI = gen_fileoutput(n_URI, 0); 28846 enc = gen_xmlCharEncoding(n_enc, 1); 28847 28848 ret_val = xmlParserInputBufferCreateFilename(URI, enc); 28849 desret_xmlParserInputBufferPtr(ret_val); 28850 call_tests++; 28851 des_fileoutput(n_URI, URI, 0); 28852 des_xmlCharEncoding(n_enc, enc, 1); 28853 xmlResetLastError(); 28854 if (mem_base != xmlMemBlocks()) { 28855 printf("Leak of %d blocks found in xmlParserInputBufferCreateFilename", 28856 xmlMemBlocks() - mem_base); 28857 test_ret++; 28858 printf(" %d", n_URI); 28859 printf(" %d", n_enc); 28860 printf("\n"); 28861 } 28862 } 28863 } 28864 function_tests++; 28865 28866 return(test_ret); 28867 } 28868 28869 28870 static int 28871 test_xmlParserInputBufferCreateMem(void) { 28872 int test_ret = 0; 28873 28874 int mem_base; 28875 xmlParserInputBufferPtr ret_val; 28876 char * mem; /* the memory input */ 28877 int n_mem; 28878 int size; /* the length of the memory block */ 28879 int n_size; 28880 xmlCharEncoding enc; /* the charset encoding if known */ 28881 int n_enc; 28882 28883 for (n_mem = 0;n_mem < gen_nb_const_char_ptr;n_mem++) { 28884 for (n_size = 0;n_size < gen_nb_int;n_size++) { 28885 for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) { 28886 mem_base = xmlMemBlocks(); 28887 mem = gen_const_char_ptr(n_mem, 0); 28888 size = gen_int(n_size, 1); 28889 enc = gen_xmlCharEncoding(n_enc, 2); 28890 28891 ret_val = xmlParserInputBufferCreateMem((const char *)mem, size, enc); 28892 desret_xmlParserInputBufferPtr(ret_val); 28893 call_tests++; 28894 des_const_char_ptr(n_mem, (const char *)mem, 0); 28895 des_int(n_size, size, 1); 28896 des_xmlCharEncoding(n_enc, enc, 2); 28897 xmlResetLastError(); 28898 if (mem_base != xmlMemBlocks()) { 28899 printf("Leak of %d blocks found in xmlParserInputBufferCreateMem", 28900 xmlMemBlocks() - mem_base); 28901 test_ret++; 28902 printf(" %d", n_mem); 28903 printf(" %d", n_size); 28904 printf(" %d", n_enc); 28905 printf("\n"); 28906 } 28907 } 28908 } 28909 } 28910 function_tests++; 28911 28912 return(test_ret); 28913 } 28914 28915 28916 static int 28917 test_xmlParserInputBufferCreateStatic(void) { 28918 int test_ret = 0; 28919 28920 int mem_base; 28921 xmlParserInputBufferPtr ret_val; 28922 char * mem; /* the memory input */ 28923 int n_mem; 28924 int size; /* the length of the memory block */ 28925 int n_size; 28926 xmlCharEncoding enc; /* the charset encoding if known */ 28927 int n_enc; 28928 28929 for (n_mem = 0;n_mem < gen_nb_const_char_ptr;n_mem++) { 28930 for (n_size = 0;n_size < gen_nb_int;n_size++) { 28931 for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) { 28932 mem_base = xmlMemBlocks(); 28933 mem = gen_const_char_ptr(n_mem, 0); 28934 size = gen_int(n_size, 1); 28935 enc = gen_xmlCharEncoding(n_enc, 2); 28936 28937 ret_val = xmlParserInputBufferCreateStatic((const char *)mem, size, enc); 28938 desret_xmlParserInputBufferPtr(ret_val); 28939 call_tests++; 28940 des_const_char_ptr(n_mem, (const char *)mem, 0); 28941 des_int(n_size, size, 1); 28942 des_xmlCharEncoding(n_enc, enc, 2); 28943 xmlResetLastError(); 28944 if (mem_base != xmlMemBlocks()) { 28945 printf("Leak of %d blocks found in xmlParserInputBufferCreateStatic", 28946 xmlMemBlocks() - mem_base); 28947 test_ret++; 28948 printf(" %d", n_mem); 28949 printf(" %d", n_size); 28950 printf(" %d", n_enc); 28951 printf("\n"); 28952 } 28953 } 28954 } 28955 } 28956 function_tests++; 28957 28958 return(test_ret); 28959 } 28960 28961 28962 static int 28963 test_xmlParserInputBufferGrow(void) { 28964 int test_ret = 0; 28965 28966 int mem_base; 28967 int ret_val; 28968 xmlParserInputBufferPtr in; /* a buffered parser input */ 28969 int n_in; 28970 int len; /* indicative value of the amount of chars to read */ 28971 int n_len; 28972 28973 for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) { 28974 for (n_len = 0;n_len < gen_nb_int;n_len++) { 28975 mem_base = xmlMemBlocks(); 28976 in = gen_xmlParserInputBufferPtr(n_in, 0); 28977 len = gen_int(n_len, 1); 28978 28979 ret_val = xmlParserInputBufferGrow(in, len); 28980 desret_int(ret_val); 28981 call_tests++; 28982 des_xmlParserInputBufferPtr(n_in, in, 0); 28983 des_int(n_len, len, 1); 28984 xmlResetLastError(); 28985 if (mem_base != xmlMemBlocks()) { 28986 printf("Leak of %d blocks found in xmlParserInputBufferGrow", 28987 xmlMemBlocks() - mem_base); 28988 test_ret++; 28989 printf(" %d", n_in); 28990 printf(" %d", n_len); 28991 printf("\n"); 28992 } 28993 } 28994 } 28995 function_tests++; 28996 28997 return(test_ret); 28998 } 28999 29000 29001 static int 29002 test_xmlParserInputBufferPush(void) { 29003 int test_ret = 0; 29004 29005 int mem_base; 29006 int ret_val; 29007 xmlParserInputBufferPtr in; /* a buffered parser input */ 29008 int n_in; 29009 int len; /* the size in bytes of the array. */ 29010 int n_len; 29011 char * buf; /* an char array */ 29012 int n_buf; 29013 29014 for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) { 29015 for (n_len = 0;n_len < gen_nb_int;n_len++) { 29016 for (n_buf = 0;n_buf < gen_nb_const_char_ptr;n_buf++) { 29017 mem_base = xmlMemBlocks(); 29018 in = gen_xmlParserInputBufferPtr(n_in, 0); 29019 len = gen_int(n_len, 1); 29020 buf = gen_const_char_ptr(n_buf, 2); 29021 29022 ret_val = xmlParserInputBufferPush(in, len, (const char *)buf); 29023 desret_int(ret_val); 29024 call_tests++; 29025 des_xmlParserInputBufferPtr(n_in, in, 0); 29026 des_int(n_len, len, 1); 29027 des_const_char_ptr(n_buf, (const char *)buf, 2); 29028 xmlResetLastError(); 29029 if (mem_base != xmlMemBlocks()) { 29030 printf("Leak of %d blocks found in xmlParserInputBufferPush", 29031 xmlMemBlocks() - mem_base); 29032 test_ret++; 29033 printf(" %d", n_in); 29034 printf(" %d", n_len); 29035 printf(" %d", n_buf); 29036 printf("\n"); 29037 } 29038 } 29039 } 29040 } 29041 function_tests++; 29042 29043 return(test_ret); 29044 } 29045 29046 29047 static int 29048 test_xmlParserInputBufferRead(void) { 29049 int test_ret = 0; 29050 29051 int mem_base; 29052 int ret_val; 29053 xmlParserInputBufferPtr in; /* a buffered parser input */ 29054 int n_in; 29055 int len; /* indicative value of the amount of chars to read */ 29056 int n_len; 29057 29058 for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) { 29059 for (n_len = 0;n_len < gen_nb_int;n_len++) { 29060 mem_base = xmlMemBlocks(); 29061 in = gen_xmlParserInputBufferPtr(n_in, 0); 29062 len = gen_int(n_len, 1); 29063 29064 ret_val = xmlParserInputBufferRead(in, len); 29065 desret_int(ret_val); 29066 call_tests++; 29067 des_xmlParserInputBufferPtr(n_in, in, 0); 29068 des_int(n_len, len, 1); 29069 xmlResetLastError(); 29070 if (mem_base != xmlMemBlocks()) { 29071 printf("Leak of %d blocks found in xmlParserInputBufferRead", 29072 xmlMemBlocks() - mem_base); 29073 test_ret++; 29074 printf(" %d", n_in); 29075 printf(" %d", n_len); 29076 printf("\n"); 29077 } 29078 } 29079 } 29080 function_tests++; 29081 29082 return(test_ret); 29083 } 29084 29085 29086 static int 29087 test_xmlPopInputCallbacks(void) { 29088 int test_ret = 0; 29089 29090 int mem_base; 29091 int ret_val; 29092 29093 mem_base = xmlMemBlocks(); 29094 29095 ret_val = xmlPopInputCallbacks(); 29096 desret_int(ret_val); 29097 call_tests++; 29098 xmlResetLastError(); 29099 if (mem_base != xmlMemBlocks()) { 29100 printf("Leak of %d blocks found in xmlPopInputCallbacks", 29101 xmlMemBlocks() - mem_base); 29102 test_ret++; 29103 printf("\n"); 29104 } 29105 function_tests++; 29106 29107 return(test_ret); 29108 } 29109 29110 29111 static int 29112 test_xmlRegisterDefaultInputCallbacks(void) { 29113 int test_ret = 0; 29114 29115 int mem_base; 29116 29117 mem_base = xmlMemBlocks(); 29118 29119 xmlRegisterDefaultInputCallbacks(); 29120 call_tests++; 29121 xmlResetLastError(); 29122 if (mem_base != xmlMemBlocks()) { 29123 printf("Leak of %d blocks found in xmlRegisterDefaultInputCallbacks", 29124 xmlMemBlocks() - mem_base); 29125 test_ret++; 29126 printf("\n"); 29127 } 29128 function_tests++; 29129 29130 return(test_ret); 29131 } 29132 29133 29134 static int 29135 test_xmlRegisterDefaultOutputCallbacks(void) { 29136 int test_ret = 0; 29137 29138 #if defined(LIBXML_OUTPUT_ENABLED) 29139 int mem_base; 29140 29141 mem_base = xmlMemBlocks(); 29142 29143 xmlRegisterDefaultOutputCallbacks(); 29144 call_tests++; 29145 xmlResetLastError(); 29146 if (mem_base != xmlMemBlocks()) { 29147 printf("Leak of %d blocks found in xmlRegisterDefaultOutputCallbacks", 29148 xmlMemBlocks() - mem_base); 29149 test_ret++; 29150 printf("\n"); 29151 } 29152 function_tests++; 29153 #endif 29154 29155 return(test_ret); 29156 } 29157 29158 29159 static int 29160 test_xmlRegisterHTTPPostCallbacks(void) { 29161 int test_ret = 0; 29162 29163 #if defined(LIBXML_OUTPUT_ENABLED) && defined(LIBXML_HTTP_ENABLED) 29164 int mem_base; 29165 29166 mem_base = xmlMemBlocks(); 29167 29168 xmlRegisterHTTPPostCallbacks(); 29169 call_tests++; 29170 xmlResetLastError(); 29171 if (mem_base != xmlMemBlocks()) { 29172 printf("Leak of %d blocks found in xmlRegisterHTTPPostCallbacks", 29173 xmlMemBlocks() - mem_base); 29174 test_ret++; 29175 printf("\n"); 29176 } 29177 function_tests++; 29178 #endif 29179 29180 return(test_ret); 29181 } 29182 29183 static int 29184 test_xmlIO(void) { 29185 int test_ret = 0; 29186 29187 if (quiet == 0) printf("Testing xmlIO : 40 of 50 functions ...\n"); 29188 test_ret += test_xmlAllocOutputBuffer(); 29189 test_ret += test_xmlAllocParserInputBuffer(); 29190 test_ret += test_xmlCheckFilename(); 29191 test_ret += test_xmlCheckHTTPInput(); 29192 test_ret += test_xmlCleanupInputCallbacks(); 29193 test_ret += test_xmlCleanupOutputCallbacks(); 29194 test_ret += test_xmlFileClose(); 29195 test_ret += test_xmlFileMatch(); 29196 test_ret += test_xmlFileOpen(); 29197 test_ret += test_xmlFileRead(); 29198 test_ret += test_xmlIOFTPClose(); 29199 test_ret += test_xmlIOFTPMatch(); 29200 test_ret += test_xmlIOFTPOpen(); 29201 test_ret += test_xmlIOFTPRead(); 29202 test_ret += test_xmlIOHTTPClose(); 29203 test_ret += test_xmlIOHTTPMatch(); 29204 test_ret += test_xmlIOHTTPOpen(); 29205 test_ret += test_xmlIOHTTPRead(); 29206 test_ret += test_xmlNoNetExternalEntityLoader(); 29207 test_ret += test_xmlNormalizeWindowsPath(); 29208 test_ret += test_xmlOutputBufferCreateBuffer(); 29209 test_ret += test_xmlOutputBufferCreateFd(); 29210 test_ret += test_xmlOutputBufferCreateFile(); 29211 test_ret += test_xmlOutputBufferCreateFilename(); 29212 test_ret += test_xmlOutputBufferFlush(); 29213 test_ret += test_xmlOutputBufferGetContent(); 29214 test_ret += test_xmlOutputBufferGetSize(); 29215 test_ret += test_xmlOutputBufferWrite(); 29216 test_ret += test_xmlOutputBufferWriteEscape(); 29217 test_ret += test_xmlOutputBufferWriteString(); 29218 test_ret += test_xmlParserGetDirectory(); 29219 test_ret += test_xmlParserInputBufferCreateFd(); 29220 test_ret += test_xmlParserInputBufferCreateFile(); 29221 test_ret += test_xmlParserInputBufferCreateFilename(); 29222 test_ret += test_xmlParserInputBufferCreateMem(); 29223 test_ret += test_xmlParserInputBufferCreateStatic(); 29224 test_ret += test_xmlParserInputBufferGrow(); 29225 test_ret += test_xmlParserInputBufferPush(); 29226 test_ret += test_xmlParserInputBufferRead(); 29227 test_ret += test_xmlPopInputCallbacks(); 29228 test_ret += test_xmlRegisterDefaultInputCallbacks(); 29229 test_ret += test_xmlRegisterDefaultOutputCallbacks(); 29230 test_ret += test_xmlRegisterHTTPPostCallbacks(); 29231 29232 if (test_ret != 0) 29233 printf("Module xmlIO: %d errors\n", test_ret); 29234 return(test_ret); 29235 } 29236 #ifdef LIBXML_AUTOMATA_ENABLED 29237 29238 #define gen_nb_xmlAutomataPtr 1 29239 static xmlAutomataPtr gen_xmlAutomataPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 29240 return(NULL); 29241 } 29242 static void des_xmlAutomataPtr(int no ATTRIBUTE_UNUSED, xmlAutomataPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 29243 } 29244 #endif 29245 29246 29247 static int 29248 test_xmlAutomataCompile(void) { 29249 int test_ret = 0; 29250 29251 29252 /* missing type support */ 29253 return(test_ret); 29254 } 29255 29256 29257 static int 29258 test_xmlAutomataGetInitState(void) { 29259 int test_ret = 0; 29260 29261 29262 /* missing type support */ 29263 return(test_ret); 29264 } 29265 29266 29267 static int 29268 test_xmlAutomataIsDeterminist(void) { 29269 int test_ret = 0; 29270 29271 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED) 29272 int mem_base; 29273 int ret_val; 29274 xmlAutomataPtr am; /* an automata */ 29275 int n_am; 29276 29277 for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) { 29278 mem_base = xmlMemBlocks(); 29279 am = gen_xmlAutomataPtr(n_am, 0); 29280 29281 ret_val = xmlAutomataIsDeterminist(am); 29282 desret_int(ret_val); 29283 call_tests++; 29284 des_xmlAutomataPtr(n_am, am, 0); 29285 xmlResetLastError(); 29286 if (mem_base != xmlMemBlocks()) { 29287 printf("Leak of %d blocks found in xmlAutomataIsDeterminist", 29288 xmlMemBlocks() - mem_base); 29289 test_ret++; 29290 printf(" %d", n_am); 29291 printf("\n"); 29292 } 29293 } 29294 function_tests++; 29295 #endif 29296 29297 return(test_ret); 29298 } 29299 29300 #ifdef LIBXML_AUTOMATA_ENABLED 29301 29302 #define gen_nb_xmlAutomataStatePtr 1 29303 static xmlAutomataStatePtr gen_xmlAutomataStatePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 29304 return(NULL); 29305 } 29306 static void des_xmlAutomataStatePtr(int no ATTRIBUTE_UNUSED, xmlAutomataStatePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 29307 } 29308 #endif 29309 29310 29311 static int 29312 test_xmlAutomataNewAllTrans(void) { 29313 int test_ret = 0; 29314 29315 29316 /* missing type support */ 29317 return(test_ret); 29318 } 29319 29320 29321 static int 29322 test_xmlAutomataNewCountTrans(void) { 29323 int test_ret = 0; 29324 29325 29326 /* missing type support */ 29327 return(test_ret); 29328 } 29329 29330 29331 static int 29332 test_xmlAutomataNewCountTrans2(void) { 29333 int test_ret = 0; 29334 29335 29336 /* missing type support */ 29337 return(test_ret); 29338 } 29339 29340 29341 static int 29342 test_xmlAutomataNewCountedTrans(void) { 29343 int test_ret = 0; 29344 29345 29346 /* missing type support */ 29347 return(test_ret); 29348 } 29349 29350 29351 static int 29352 test_xmlAutomataNewCounter(void) { 29353 int test_ret = 0; 29354 29355 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED) 29356 int mem_base; 29357 int ret_val; 29358 xmlAutomataPtr am; /* an automata */ 29359 int n_am; 29360 int min; /* the minimal value on the counter */ 29361 int n_min; 29362 int max; /* the maximal value on the counter */ 29363 int n_max; 29364 29365 for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) { 29366 for (n_min = 0;n_min < gen_nb_int;n_min++) { 29367 for (n_max = 0;n_max < gen_nb_int;n_max++) { 29368 mem_base = xmlMemBlocks(); 29369 am = gen_xmlAutomataPtr(n_am, 0); 29370 min = gen_int(n_min, 1); 29371 max = gen_int(n_max, 2); 29372 29373 ret_val = xmlAutomataNewCounter(am, min, max); 29374 desret_int(ret_val); 29375 call_tests++; 29376 des_xmlAutomataPtr(n_am, am, 0); 29377 des_int(n_min, min, 1); 29378 des_int(n_max, max, 2); 29379 xmlResetLastError(); 29380 if (mem_base != xmlMemBlocks()) { 29381 printf("Leak of %d blocks found in xmlAutomataNewCounter", 29382 xmlMemBlocks() - mem_base); 29383 test_ret++; 29384 printf(" %d", n_am); 29385 printf(" %d", n_min); 29386 printf(" %d", n_max); 29387 printf("\n"); 29388 } 29389 } 29390 } 29391 } 29392 function_tests++; 29393 #endif 29394 29395 return(test_ret); 29396 } 29397 29398 29399 static int 29400 test_xmlAutomataNewCounterTrans(void) { 29401 int test_ret = 0; 29402 29403 29404 /* missing type support */ 29405 return(test_ret); 29406 } 29407 29408 29409 static int 29410 test_xmlAutomataNewEpsilon(void) { 29411 int test_ret = 0; 29412 29413 29414 /* missing type support */ 29415 return(test_ret); 29416 } 29417 29418 29419 static int 29420 test_xmlAutomataNewNegTrans(void) { 29421 int test_ret = 0; 29422 29423 29424 /* missing type support */ 29425 return(test_ret); 29426 } 29427 29428 29429 static int 29430 test_xmlAutomataNewOnceTrans(void) { 29431 int test_ret = 0; 29432 29433 29434 /* missing type support */ 29435 return(test_ret); 29436 } 29437 29438 29439 static int 29440 test_xmlAutomataNewOnceTrans2(void) { 29441 int test_ret = 0; 29442 29443 29444 /* missing type support */ 29445 return(test_ret); 29446 } 29447 29448 29449 static int 29450 test_xmlAutomataNewState(void) { 29451 int test_ret = 0; 29452 29453 29454 /* missing type support */ 29455 return(test_ret); 29456 } 29457 29458 29459 static int 29460 test_xmlAutomataNewTransition(void) { 29461 int test_ret = 0; 29462 29463 29464 /* missing type support */ 29465 return(test_ret); 29466 } 29467 29468 29469 static int 29470 test_xmlAutomataNewTransition2(void) { 29471 int test_ret = 0; 29472 29473 29474 /* missing type support */ 29475 return(test_ret); 29476 } 29477 29478 29479 static int 29480 test_xmlAutomataSetFinalState(void) { 29481 int test_ret = 0; 29482 29483 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED) 29484 int mem_base; 29485 int ret_val; 29486 xmlAutomataPtr am; /* an automata */ 29487 int n_am; 29488 xmlAutomataStatePtr state; /* a state in this automata */ 29489 int n_state; 29490 29491 for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) { 29492 for (n_state = 0;n_state < gen_nb_xmlAutomataStatePtr;n_state++) { 29493 mem_base = xmlMemBlocks(); 29494 am = gen_xmlAutomataPtr(n_am, 0); 29495 state = gen_xmlAutomataStatePtr(n_state, 1); 29496 29497 ret_val = xmlAutomataSetFinalState(am, state); 29498 desret_int(ret_val); 29499 call_tests++; 29500 des_xmlAutomataPtr(n_am, am, 0); 29501 des_xmlAutomataStatePtr(n_state, state, 1); 29502 xmlResetLastError(); 29503 if (mem_base != xmlMemBlocks()) { 29504 printf("Leak of %d blocks found in xmlAutomataSetFinalState", 29505 xmlMemBlocks() - mem_base); 29506 test_ret++; 29507 printf(" %d", n_am); 29508 printf(" %d", n_state); 29509 printf("\n"); 29510 } 29511 } 29512 } 29513 function_tests++; 29514 #endif 29515 29516 return(test_ret); 29517 } 29518 29519 29520 static int 29521 test_xmlNewAutomata(void) { 29522 int test_ret = 0; 29523 29524 29525 /* missing type support */ 29526 return(test_ret); 29527 } 29528 29529 static int 29530 test_xmlautomata(void) { 29531 int test_ret = 0; 29532 29533 if (quiet == 0) printf("Testing xmlautomata : 3 of 19 functions ...\n"); 29534 test_ret += test_xmlAutomataCompile(); 29535 test_ret += test_xmlAutomataGetInitState(); 29536 test_ret += test_xmlAutomataIsDeterminist(); 29537 test_ret += test_xmlAutomataNewAllTrans(); 29538 test_ret += test_xmlAutomataNewCountTrans(); 29539 test_ret += test_xmlAutomataNewCountTrans2(); 29540 test_ret += test_xmlAutomataNewCountedTrans(); 29541 test_ret += test_xmlAutomataNewCounter(); 29542 test_ret += test_xmlAutomataNewCounterTrans(); 29543 test_ret += test_xmlAutomataNewEpsilon(); 29544 test_ret += test_xmlAutomataNewNegTrans(); 29545 test_ret += test_xmlAutomataNewOnceTrans(); 29546 test_ret += test_xmlAutomataNewOnceTrans2(); 29547 test_ret += test_xmlAutomataNewState(); 29548 test_ret += test_xmlAutomataNewTransition(); 29549 test_ret += test_xmlAutomataNewTransition2(); 29550 test_ret += test_xmlAutomataSetFinalState(); 29551 test_ret += test_xmlNewAutomata(); 29552 29553 if (test_ret != 0) 29554 printf("Module xmlautomata: %d errors\n", test_ret); 29555 return(test_ret); 29556 } 29557 29558 #define gen_nb_xmlGenericErrorFunc_ptr 1 29559 static xmlGenericErrorFunc * gen_xmlGenericErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 29560 return(NULL); 29561 } 29562 static void des_xmlGenericErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlGenericErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 29563 } 29564 29565 static int 29566 test_initGenericErrorDefaultFunc(void) { 29567 int test_ret = 0; 29568 29569 int mem_base; 29570 xmlGenericErrorFunc * handler; /* the handler */ 29571 int n_handler; 29572 29573 for (n_handler = 0;n_handler < gen_nb_xmlGenericErrorFunc_ptr;n_handler++) { 29574 mem_base = xmlMemBlocks(); 29575 handler = gen_xmlGenericErrorFunc_ptr(n_handler, 0); 29576 29577 initGenericErrorDefaultFunc(handler); 29578 call_tests++; 29579 des_xmlGenericErrorFunc_ptr(n_handler, handler, 0); 29580 xmlResetLastError(); 29581 if (mem_base != xmlMemBlocks()) { 29582 printf("Leak of %d blocks found in initGenericErrorDefaultFunc", 29583 xmlMemBlocks() - mem_base); 29584 test_ret++; 29585 printf(" %d", n_handler); 29586 printf("\n"); 29587 } 29588 } 29589 function_tests++; 29590 29591 return(test_ret); 29592 } 29593 29594 29595 #define gen_nb_xmlErrorPtr 1 29596 static xmlErrorPtr gen_xmlErrorPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 29597 return(NULL); 29598 } 29599 static void des_xmlErrorPtr(int no ATTRIBUTE_UNUSED, xmlErrorPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 29600 } 29601 29602 static int 29603 test_xmlCopyError(void) { 29604 int test_ret = 0; 29605 29606 int mem_base; 29607 int ret_val; 29608 xmlErrorPtr from; /* a source error */ 29609 int n_from; 29610 xmlErrorPtr to; /* a target error */ 29611 int n_to; 29612 29613 for (n_from = 0;n_from < gen_nb_xmlErrorPtr;n_from++) { 29614 for (n_to = 0;n_to < gen_nb_xmlErrorPtr;n_to++) { 29615 mem_base = xmlMemBlocks(); 29616 from = gen_xmlErrorPtr(n_from, 0); 29617 to = gen_xmlErrorPtr(n_to, 1); 29618 29619 ret_val = xmlCopyError(from, to); 29620 desret_int(ret_val); 29621 call_tests++; 29622 des_xmlErrorPtr(n_from, from, 0); 29623 des_xmlErrorPtr(n_to, to, 1); 29624 xmlResetLastError(); 29625 if (mem_base != xmlMemBlocks()) { 29626 printf("Leak of %d blocks found in xmlCopyError", 29627 xmlMemBlocks() - mem_base); 29628 test_ret++; 29629 printf(" %d", n_from); 29630 printf(" %d", n_to); 29631 printf("\n"); 29632 } 29633 } 29634 } 29635 function_tests++; 29636 29637 return(test_ret); 29638 } 29639 29640 29641 static int 29642 test_xmlCtxtGetLastError(void) { 29643 int test_ret = 0; 29644 29645 29646 /* missing type support */ 29647 return(test_ret); 29648 } 29649 29650 29651 static int 29652 test_xmlCtxtResetLastError(void) { 29653 int test_ret = 0; 29654 29655 int mem_base; 29656 void * ctx; /* an XML parser context */ 29657 int n_ctx; 29658 29659 for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) { 29660 mem_base = xmlMemBlocks(); 29661 ctx = gen_void_ptr(n_ctx, 0); 29662 29663 xmlCtxtResetLastError(ctx); 29664 call_tests++; 29665 des_void_ptr(n_ctx, ctx, 0); 29666 xmlResetLastError(); 29667 if (mem_base != xmlMemBlocks()) { 29668 printf("Leak of %d blocks found in xmlCtxtResetLastError", 29669 xmlMemBlocks() - mem_base); 29670 test_ret++; 29671 printf(" %d", n_ctx); 29672 printf("\n"); 29673 } 29674 } 29675 function_tests++; 29676 29677 return(test_ret); 29678 } 29679 29680 29681 static int 29682 test_xmlGetLastError(void) { 29683 int test_ret = 0; 29684 29685 29686 /* missing type support */ 29687 return(test_ret); 29688 } 29689 29690 29691 static int 29692 test_xmlParserError(void) { 29693 int test_ret = 0; 29694 29695 29696 /* missing type support */ 29697 return(test_ret); 29698 } 29699 29700 29701 static int 29702 test_xmlParserPrintFileContext(void) { 29703 int test_ret = 0; 29704 29705 int mem_base; 29706 xmlParserInputPtr input; /* an xmlParserInputPtr input */ 29707 int n_input; 29708 29709 for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) { 29710 mem_base = xmlMemBlocks(); 29711 input = gen_xmlParserInputPtr(n_input, 0); 29712 29713 xmlParserPrintFileContext(input); 29714 call_tests++; 29715 des_xmlParserInputPtr(n_input, input, 0); 29716 xmlResetLastError(); 29717 if (mem_base != xmlMemBlocks()) { 29718 printf("Leak of %d blocks found in xmlParserPrintFileContext", 29719 xmlMemBlocks() - mem_base); 29720 test_ret++; 29721 printf(" %d", n_input); 29722 printf("\n"); 29723 } 29724 } 29725 function_tests++; 29726 29727 return(test_ret); 29728 } 29729 29730 29731 static int 29732 test_xmlParserPrintFileInfo(void) { 29733 int test_ret = 0; 29734 29735 int mem_base; 29736 xmlParserInputPtr input; /* an xmlParserInputPtr input */ 29737 int n_input; 29738 29739 for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) { 29740 mem_base = xmlMemBlocks(); 29741 input = gen_xmlParserInputPtr(n_input, 0); 29742 29743 xmlParserPrintFileInfo(input); 29744 call_tests++; 29745 des_xmlParserInputPtr(n_input, input, 0); 29746 xmlResetLastError(); 29747 if (mem_base != xmlMemBlocks()) { 29748 printf("Leak of %d blocks found in xmlParserPrintFileInfo", 29749 xmlMemBlocks() - mem_base); 29750 test_ret++; 29751 printf(" %d", n_input); 29752 printf("\n"); 29753 } 29754 } 29755 function_tests++; 29756 29757 return(test_ret); 29758 } 29759 29760 29761 static int 29762 test_xmlParserValidityError(void) { 29763 int test_ret = 0; 29764 29765 29766 /* missing type support */ 29767 return(test_ret); 29768 } 29769 29770 29771 static int 29772 test_xmlParserValidityWarning(void) { 29773 int test_ret = 0; 29774 29775 29776 /* missing type support */ 29777 return(test_ret); 29778 } 29779 29780 29781 static int 29782 test_xmlParserWarning(void) { 29783 int test_ret = 0; 29784 29785 29786 /* missing type support */ 29787 return(test_ret); 29788 } 29789 29790 29791 static int 29792 test_xmlResetError(void) { 29793 int test_ret = 0; 29794 29795 int mem_base; 29796 xmlErrorPtr err; /* pointer to the error. */ 29797 int n_err; 29798 29799 for (n_err = 0;n_err < gen_nb_xmlErrorPtr;n_err++) { 29800 mem_base = xmlMemBlocks(); 29801 err = gen_xmlErrorPtr(n_err, 0); 29802 29803 xmlResetError(err); 29804 call_tests++; 29805 des_xmlErrorPtr(n_err, err, 0); 29806 xmlResetLastError(); 29807 if (mem_base != xmlMemBlocks()) { 29808 printf("Leak of %d blocks found in xmlResetError", 29809 xmlMemBlocks() - mem_base); 29810 test_ret++; 29811 printf(" %d", n_err); 29812 printf("\n"); 29813 } 29814 } 29815 function_tests++; 29816 29817 return(test_ret); 29818 } 29819 29820 29821 static int 29822 test_xmlResetLastError(void) { 29823 int test_ret = 0; 29824 29825 29826 29827 xmlResetLastError(); 29828 call_tests++; 29829 xmlResetLastError(); 29830 function_tests++; 29831 29832 return(test_ret); 29833 } 29834 29835 29836 static int 29837 test_xmlSetGenericErrorFunc(void) { 29838 int test_ret = 0; 29839 29840 29841 /* missing type support */ 29842 return(test_ret); 29843 } 29844 29845 29846 static int 29847 test_xmlSetStructuredErrorFunc(void) { 29848 int test_ret = 0; 29849 29850 29851 /* missing type support */ 29852 return(test_ret); 29853 } 29854 29855 static int 29856 test_xmlerror(void) { 29857 int test_ret = 0; 29858 29859 if (quiet == 0) printf("Testing xmlerror : 7 of 15 functions ...\n"); 29860 test_ret += test_initGenericErrorDefaultFunc(); 29861 test_ret += test_xmlCopyError(); 29862 test_ret += test_xmlCtxtGetLastError(); 29863 test_ret += test_xmlCtxtResetLastError(); 29864 test_ret += test_xmlGetLastError(); 29865 test_ret += test_xmlParserError(); 29866 test_ret += test_xmlParserPrintFileContext(); 29867 test_ret += test_xmlParserPrintFileInfo(); 29868 test_ret += test_xmlParserValidityError(); 29869 test_ret += test_xmlParserValidityWarning(); 29870 test_ret += test_xmlParserWarning(); 29871 test_ret += test_xmlResetError(); 29872 test_ret += test_xmlResetLastError(); 29873 test_ret += test_xmlSetGenericErrorFunc(); 29874 test_ret += test_xmlSetStructuredErrorFunc(); 29875 29876 if (test_ret != 0) 29877 printf("Module xmlerror: %d errors\n", test_ret); 29878 return(test_ret); 29879 } 29880 #ifdef LIBXML_MODULES_ENABLED 29881 29882 #define gen_nb_xmlModulePtr 1 29883 static xmlModulePtr gen_xmlModulePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 29884 return(NULL); 29885 } 29886 static void des_xmlModulePtr(int no ATTRIBUTE_UNUSED, xmlModulePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 29887 } 29888 #endif 29889 29890 29891 static int 29892 test_xmlModuleClose(void) { 29893 int test_ret = 0; 29894 29895 #if defined(LIBXML_MODULES_ENABLED) 29896 int mem_base; 29897 int ret_val; 29898 xmlModulePtr module; /* the module handle */ 29899 int n_module; 29900 29901 for (n_module = 0;n_module < gen_nb_xmlModulePtr;n_module++) { 29902 mem_base = xmlMemBlocks(); 29903 module = gen_xmlModulePtr(n_module, 0); 29904 29905 ret_val = xmlModuleClose(module); 29906 desret_int(ret_val); 29907 call_tests++; 29908 des_xmlModulePtr(n_module, module, 0); 29909 xmlResetLastError(); 29910 if (mem_base != xmlMemBlocks()) { 29911 printf("Leak of %d blocks found in xmlModuleClose", 29912 xmlMemBlocks() - mem_base); 29913 test_ret++; 29914 printf(" %d", n_module); 29915 printf("\n"); 29916 } 29917 } 29918 function_tests++; 29919 #endif 29920 29921 return(test_ret); 29922 } 29923 29924 29925 static int 29926 test_xmlModuleOpen(void) { 29927 int test_ret = 0; 29928 29929 29930 /* missing type support */ 29931 return(test_ret); 29932 } 29933 29934 29935 static int 29936 test_xmlModuleSymbol(void) { 29937 int test_ret = 0; 29938 29939 #if defined(LIBXML_MODULES_ENABLED) 29940 int mem_base; 29941 int ret_val; 29942 xmlModulePtr module; /* the module */ 29943 int n_module; 29944 char * name; /* the name of the symbol */ 29945 int n_name; 29946 void ** symbol; /* the resulting symbol address */ 29947 int n_symbol; 29948 29949 for (n_module = 0;n_module < gen_nb_xmlModulePtr;n_module++) { 29950 for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) { 29951 for (n_symbol = 0;n_symbol < gen_nb_void_ptr_ptr;n_symbol++) { 29952 mem_base = xmlMemBlocks(); 29953 module = gen_xmlModulePtr(n_module, 0); 29954 name = gen_const_char_ptr(n_name, 1); 29955 symbol = gen_void_ptr_ptr(n_symbol, 2); 29956 29957 ret_val = xmlModuleSymbol(module, (const char *)name, symbol); 29958 desret_int(ret_val); 29959 call_tests++; 29960 des_xmlModulePtr(n_module, module, 0); 29961 des_const_char_ptr(n_name, (const char *)name, 1); 29962 des_void_ptr_ptr(n_symbol, symbol, 2); 29963 xmlResetLastError(); 29964 if (mem_base != xmlMemBlocks()) { 29965 printf("Leak of %d blocks found in xmlModuleSymbol", 29966 xmlMemBlocks() - mem_base); 29967 test_ret++; 29968 printf(" %d", n_module); 29969 printf(" %d", n_name); 29970 printf(" %d", n_symbol); 29971 printf("\n"); 29972 } 29973 } 29974 } 29975 } 29976 function_tests++; 29977 #endif 29978 29979 return(test_ret); 29980 } 29981 29982 static int 29983 test_xmlmodule(void) { 29984 int test_ret = 0; 29985 29986 if (quiet == 0) printf("Testing xmlmodule : 2 of 4 functions ...\n"); 29987 test_ret += test_xmlModuleClose(); 29988 test_ret += test_xmlModuleOpen(); 29989 test_ret += test_xmlModuleSymbol(); 29990 29991 if (test_ret != 0) 29992 printf("Module xmlmodule: %d errors\n", test_ret); 29993 return(test_ret); 29994 } 29995 29996 static int 29997 test_xmlNewTextReader(void) { 29998 int test_ret = 0; 29999 30000 #if defined(LIBXML_READER_ENABLED) 30001 int mem_base; 30002 xmlTextReaderPtr ret_val; 30003 xmlParserInputBufferPtr input; /* the xmlParserInputBufferPtr used to read data */ 30004 int n_input; 30005 const char * URI; /* the URI information for the source if available */ 30006 int n_URI; 30007 30008 for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) { 30009 for (n_URI = 0;n_URI < gen_nb_filepath;n_URI++) { 30010 mem_base = xmlMemBlocks(); 30011 input = gen_xmlParserInputBufferPtr(n_input, 0); 30012 URI = gen_filepath(n_URI, 1); 30013 30014 ret_val = xmlNewTextReader(input, URI); 30015 desret_xmlTextReaderPtr(ret_val); 30016 call_tests++; 30017 des_xmlParserInputBufferPtr(n_input, input, 0); 30018 des_filepath(n_URI, URI, 1); 30019 xmlResetLastError(); 30020 if (mem_base != xmlMemBlocks()) { 30021 printf("Leak of %d blocks found in xmlNewTextReader", 30022 xmlMemBlocks() - mem_base); 30023 test_ret++; 30024 printf(" %d", n_input); 30025 printf(" %d", n_URI); 30026 printf("\n"); 30027 } 30028 } 30029 } 30030 function_tests++; 30031 #endif 30032 30033 return(test_ret); 30034 } 30035 30036 30037 static int 30038 test_xmlNewTextReaderFilename(void) { 30039 int test_ret = 0; 30040 30041 #if defined(LIBXML_READER_ENABLED) 30042 int mem_base; 30043 xmlTextReaderPtr ret_val; 30044 const char * URI; /* the URI of the resource to process */ 30045 int n_URI; 30046 30047 for (n_URI = 0;n_URI < gen_nb_filepath;n_URI++) { 30048 mem_base = xmlMemBlocks(); 30049 URI = gen_filepath(n_URI, 0); 30050 30051 ret_val = xmlNewTextReaderFilename(URI); 30052 desret_xmlTextReaderPtr(ret_val); 30053 call_tests++; 30054 des_filepath(n_URI, URI, 0); 30055 xmlResetLastError(); 30056 if (mem_base != xmlMemBlocks()) { 30057 printf("Leak of %d blocks found in xmlNewTextReaderFilename", 30058 xmlMemBlocks() - mem_base); 30059 test_ret++; 30060 printf(" %d", n_URI); 30061 printf("\n"); 30062 } 30063 } 30064 function_tests++; 30065 #endif 30066 30067 return(test_ret); 30068 } 30069 30070 30071 static int 30072 test_xmlReaderForDoc(void) { 30073 int test_ret = 0; 30074 30075 #if defined(LIBXML_READER_ENABLED) 30076 int mem_base; 30077 xmlTextReaderPtr ret_val; 30078 xmlChar * cur; /* a pointer to a zero terminated string */ 30079 int n_cur; 30080 const char * URL; /* the base URL to use for the document */ 30081 int n_URL; 30082 char * encoding; /* the document encoding, or NULL */ 30083 int n_encoding; 30084 int options; /* a combination of xmlParserOption */ 30085 int n_options; 30086 30087 for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) { 30088 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 30089 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 30090 for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) { 30091 mem_base = xmlMemBlocks(); 30092 cur = gen_const_xmlChar_ptr(n_cur, 0); 30093 URL = gen_filepath(n_URL, 1); 30094 encoding = gen_const_char_ptr(n_encoding, 2); 30095 options = gen_parseroptions(n_options, 3); 30096 30097 ret_val = xmlReaderForDoc((const xmlChar *)cur, URL, (const char *)encoding, options); 30098 desret_xmlTextReaderPtr(ret_val); 30099 call_tests++; 30100 des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0); 30101 des_filepath(n_URL, URL, 1); 30102 des_const_char_ptr(n_encoding, (const char *)encoding, 2); 30103 des_parseroptions(n_options, options, 3); 30104 xmlResetLastError(); 30105 if (mem_base != xmlMemBlocks()) { 30106 printf("Leak of %d blocks found in xmlReaderForDoc", 30107 xmlMemBlocks() - mem_base); 30108 test_ret++; 30109 printf(" %d", n_cur); 30110 printf(" %d", n_URL); 30111 printf(" %d", n_encoding); 30112 printf(" %d", n_options); 30113 printf("\n"); 30114 } 30115 } 30116 } 30117 } 30118 } 30119 function_tests++; 30120 #endif 30121 30122 return(test_ret); 30123 } 30124 30125 30126 static int 30127 test_xmlReaderForFile(void) { 30128 int test_ret = 0; 30129 30130 #if defined(LIBXML_READER_ENABLED) 30131 int mem_base; 30132 xmlTextReaderPtr ret_val; 30133 const char * filename; /* a file or URL */ 30134 int n_filename; 30135 char * encoding; /* the document encoding, or NULL */ 30136 int n_encoding; 30137 int options; /* a combination of xmlParserOption */ 30138 int n_options; 30139 30140 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 30141 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 30142 for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) { 30143 mem_base = xmlMemBlocks(); 30144 filename = gen_filepath(n_filename, 0); 30145 encoding = gen_const_char_ptr(n_encoding, 1); 30146 options = gen_parseroptions(n_options, 2); 30147 30148 ret_val = xmlReaderForFile(filename, (const char *)encoding, options); 30149 desret_xmlTextReaderPtr(ret_val); 30150 call_tests++; 30151 des_filepath(n_filename, filename, 0); 30152 des_const_char_ptr(n_encoding, (const char *)encoding, 1); 30153 des_parseroptions(n_options, options, 2); 30154 xmlResetLastError(); 30155 if (mem_base != xmlMemBlocks()) { 30156 printf("Leak of %d blocks found in xmlReaderForFile", 30157 xmlMemBlocks() - mem_base); 30158 test_ret++; 30159 printf(" %d", n_filename); 30160 printf(" %d", n_encoding); 30161 printf(" %d", n_options); 30162 printf("\n"); 30163 } 30164 } 30165 } 30166 } 30167 function_tests++; 30168 #endif 30169 30170 return(test_ret); 30171 } 30172 30173 30174 static int 30175 test_xmlReaderForMemory(void) { 30176 int test_ret = 0; 30177 30178 #if defined(LIBXML_READER_ENABLED) 30179 int mem_base; 30180 xmlTextReaderPtr ret_val; 30181 char * buffer; /* a pointer to a char array */ 30182 int n_buffer; 30183 int size; /* the size of the array */ 30184 int n_size; 30185 const char * URL; /* the base URL to use for the document */ 30186 int n_URL; 30187 char * encoding; /* the document encoding, or NULL */ 30188 int n_encoding; 30189 int options; /* a combination of xmlParserOption */ 30190 int n_options; 30191 30192 for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) { 30193 for (n_size = 0;n_size < gen_nb_int;n_size++) { 30194 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 30195 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 30196 for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) { 30197 mem_base = xmlMemBlocks(); 30198 buffer = gen_const_char_ptr(n_buffer, 0); 30199 size = gen_int(n_size, 1); 30200 URL = gen_filepath(n_URL, 2); 30201 encoding = gen_const_char_ptr(n_encoding, 3); 30202 options = gen_parseroptions(n_options, 4); 30203 30204 ret_val = xmlReaderForMemory((const char *)buffer, size, URL, (const char *)encoding, options); 30205 desret_xmlTextReaderPtr(ret_val); 30206 call_tests++; 30207 des_const_char_ptr(n_buffer, (const char *)buffer, 0); 30208 des_int(n_size, size, 1); 30209 des_filepath(n_URL, URL, 2); 30210 des_const_char_ptr(n_encoding, (const char *)encoding, 3); 30211 des_parseroptions(n_options, options, 4); 30212 xmlResetLastError(); 30213 if (mem_base != xmlMemBlocks()) { 30214 printf("Leak of %d blocks found in xmlReaderForMemory", 30215 xmlMemBlocks() - mem_base); 30216 test_ret++; 30217 printf(" %d", n_buffer); 30218 printf(" %d", n_size); 30219 printf(" %d", n_URL); 30220 printf(" %d", n_encoding); 30221 printf(" %d", n_options); 30222 printf("\n"); 30223 } 30224 } 30225 } 30226 } 30227 } 30228 } 30229 function_tests++; 30230 #endif 30231 30232 return(test_ret); 30233 } 30234 30235 30236 static int 30237 test_xmlReaderNewDoc(void) { 30238 int test_ret = 0; 30239 30240 #if defined(LIBXML_READER_ENABLED) 30241 int mem_base; 30242 int ret_val; 30243 xmlTextReaderPtr reader; /* an XML reader */ 30244 int n_reader; 30245 xmlChar * cur; /* a pointer to a zero terminated string */ 30246 int n_cur; 30247 const char * URL; /* the base URL to use for the document */ 30248 int n_URL; 30249 char * encoding; /* the document encoding, or NULL */ 30250 int n_encoding; 30251 int options; /* a combination of xmlParserOption */ 30252 int n_options; 30253 30254 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 30255 for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) { 30256 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 30257 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 30258 for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) { 30259 mem_base = xmlMemBlocks(); 30260 reader = gen_xmlTextReaderPtr(n_reader, 0); 30261 cur = gen_const_xmlChar_ptr(n_cur, 1); 30262 URL = gen_filepath(n_URL, 2); 30263 encoding = gen_const_char_ptr(n_encoding, 3); 30264 options = gen_parseroptions(n_options, 4); 30265 30266 ret_val = xmlReaderNewDoc(reader, (const xmlChar *)cur, URL, (const char *)encoding, options); 30267 desret_int(ret_val); 30268 call_tests++; 30269 des_xmlTextReaderPtr(n_reader, reader, 0); 30270 des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1); 30271 des_filepath(n_URL, URL, 2); 30272 des_const_char_ptr(n_encoding, (const char *)encoding, 3); 30273 des_parseroptions(n_options, options, 4); 30274 xmlResetLastError(); 30275 if (mem_base != xmlMemBlocks()) { 30276 printf("Leak of %d blocks found in xmlReaderNewDoc", 30277 xmlMemBlocks() - mem_base); 30278 test_ret++; 30279 printf(" %d", n_reader); 30280 printf(" %d", n_cur); 30281 printf(" %d", n_URL); 30282 printf(" %d", n_encoding); 30283 printf(" %d", n_options); 30284 printf("\n"); 30285 } 30286 } 30287 } 30288 } 30289 } 30290 } 30291 function_tests++; 30292 #endif 30293 30294 return(test_ret); 30295 } 30296 30297 30298 static int 30299 test_xmlReaderNewFile(void) { 30300 int test_ret = 0; 30301 30302 #if defined(LIBXML_READER_ENABLED) 30303 int mem_base; 30304 int ret_val; 30305 xmlTextReaderPtr reader; /* an XML reader */ 30306 int n_reader; 30307 const char * filename; /* a file or URL */ 30308 int n_filename; 30309 char * encoding; /* the document encoding, or NULL */ 30310 int n_encoding; 30311 int options; /* a combination of xmlParserOption */ 30312 int n_options; 30313 30314 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 30315 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 30316 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 30317 for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) { 30318 mem_base = xmlMemBlocks(); 30319 reader = gen_xmlTextReaderPtr(n_reader, 0); 30320 filename = gen_filepath(n_filename, 1); 30321 encoding = gen_const_char_ptr(n_encoding, 2); 30322 options = gen_parseroptions(n_options, 3); 30323 30324 ret_val = xmlReaderNewFile(reader, filename, (const char *)encoding, options); 30325 desret_int(ret_val); 30326 call_tests++; 30327 des_xmlTextReaderPtr(n_reader, reader, 0); 30328 des_filepath(n_filename, filename, 1); 30329 des_const_char_ptr(n_encoding, (const char *)encoding, 2); 30330 des_parseroptions(n_options, options, 3); 30331 xmlResetLastError(); 30332 if (mem_base != xmlMemBlocks()) { 30333 printf("Leak of %d blocks found in xmlReaderNewFile", 30334 xmlMemBlocks() - mem_base); 30335 test_ret++; 30336 printf(" %d", n_reader); 30337 printf(" %d", n_filename); 30338 printf(" %d", n_encoding); 30339 printf(" %d", n_options); 30340 printf("\n"); 30341 } 30342 } 30343 } 30344 } 30345 } 30346 function_tests++; 30347 #endif 30348 30349 return(test_ret); 30350 } 30351 30352 30353 static int 30354 test_xmlReaderNewMemory(void) { 30355 int test_ret = 0; 30356 30357 #if defined(LIBXML_READER_ENABLED) 30358 int mem_base; 30359 int ret_val; 30360 xmlTextReaderPtr reader; /* an XML reader */ 30361 int n_reader; 30362 char * buffer; /* a pointer to a char array */ 30363 int n_buffer; 30364 int size; /* the size of the array */ 30365 int n_size; 30366 const char * URL; /* the base URL to use for the document */ 30367 int n_URL; 30368 char * encoding; /* the document encoding, or NULL */ 30369 int n_encoding; 30370 int options; /* a combination of xmlParserOption */ 30371 int n_options; 30372 30373 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 30374 for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) { 30375 for (n_size = 0;n_size < gen_nb_int;n_size++) { 30376 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 30377 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 30378 for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) { 30379 mem_base = xmlMemBlocks(); 30380 reader = gen_xmlTextReaderPtr(n_reader, 0); 30381 buffer = gen_const_char_ptr(n_buffer, 1); 30382 size = gen_int(n_size, 2); 30383 URL = gen_filepath(n_URL, 3); 30384 encoding = gen_const_char_ptr(n_encoding, 4); 30385 options = gen_parseroptions(n_options, 5); 30386 30387 ret_val = xmlReaderNewMemory(reader, (const char *)buffer, size, URL, (const char *)encoding, options); 30388 desret_int(ret_val); 30389 call_tests++; 30390 des_xmlTextReaderPtr(n_reader, reader, 0); 30391 des_const_char_ptr(n_buffer, (const char *)buffer, 1); 30392 des_int(n_size, size, 2); 30393 des_filepath(n_URL, URL, 3); 30394 des_const_char_ptr(n_encoding, (const char *)encoding, 4); 30395 des_parseroptions(n_options, options, 5); 30396 xmlResetLastError(); 30397 if (mem_base != xmlMemBlocks()) { 30398 printf("Leak of %d blocks found in xmlReaderNewMemory", 30399 xmlMemBlocks() - mem_base); 30400 test_ret++; 30401 printf(" %d", n_reader); 30402 printf(" %d", n_buffer); 30403 printf(" %d", n_size); 30404 printf(" %d", n_URL); 30405 printf(" %d", n_encoding); 30406 printf(" %d", n_options); 30407 printf("\n"); 30408 } 30409 } 30410 } 30411 } 30412 } 30413 } 30414 } 30415 function_tests++; 30416 #endif 30417 30418 return(test_ret); 30419 } 30420 30421 30422 static int 30423 test_xmlReaderNewWalker(void) { 30424 int test_ret = 0; 30425 30426 #if defined(LIBXML_READER_ENABLED) 30427 int mem_base; 30428 int ret_val; 30429 xmlTextReaderPtr reader; /* an XML reader */ 30430 int n_reader; 30431 xmlDocPtr doc; /* a preparsed document */ 30432 int n_doc; 30433 30434 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 30435 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 30436 mem_base = xmlMemBlocks(); 30437 reader = gen_xmlTextReaderPtr(n_reader, 0); 30438 doc = gen_xmlDocPtr(n_doc, 1); 30439 30440 ret_val = xmlReaderNewWalker(reader, doc); 30441 desret_int(ret_val); 30442 call_tests++; 30443 des_xmlTextReaderPtr(n_reader, reader, 0); 30444 des_xmlDocPtr(n_doc, doc, 1); 30445 xmlResetLastError(); 30446 if (mem_base != xmlMemBlocks()) { 30447 printf("Leak of %d blocks found in xmlReaderNewWalker", 30448 xmlMemBlocks() - mem_base); 30449 test_ret++; 30450 printf(" %d", n_reader); 30451 printf(" %d", n_doc); 30452 printf("\n"); 30453 } 30454 } 30455 } 30456 function_tests++; 30457 #endif 30458 30459 return(test_ret); 30460 } 30461 30462 30463 static int 30464 test_xmlReaderWalker(void) { 30465 int test_ret = 0; 30466 30467 #if defined(LIBXML_READER_ENABLED) 30468 int mem_base; 30469 xmlTextReaderPtr ret_val; 30470 xmlDocPtr doc; /* a preparsed document */ 30471 int n_doc; 30472 30473 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 30474 mem_base = xmlMemBlocks(); 30475 doc = gen_xmlDocPtr(n_doc, 0); 30476 30477 ret_val = xmlReaderWalker(doc); 30478 desret_xmlTextReaderPtr(ret_val); 30479 call_tests++; 30480 des_xmlDocPtr(n_doc, doc, 0); 30481 xmlResetLastError(); 30482 if (mem_base != xmlMemBlocks()) { 30483 printf("Leak of %d blocks found in xmlReaderWalker", 30484 xmlMemBlocks() - mem_base); 30485 test_ret++; 30486 printf(" %d", n_doc); 30487 printf("\n"); 30488 } 30489 } 30490 function_tests++; 30491 #endif 30492 30493 return(test_ret); 30494 } 30495 30496 30497 static int 30498 test_xmlTextReaderAttributeCount(void) { 30499 int test_ret = 0; 30500 30501 #if defined(LIBXML_READER_ENABLED) 30502 int mem_base; 30503 int ret_val; 30504 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 30505 int n_reader; 30506 30507 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 30508 mem_base = xmlMemBlocks(); 30509 reader = gen_xmlTextReaderPtr(n_reader, 0); 30510 30511 ret_val = xmlTextReaderAttributeCount(reader); 30512 desret_int(ret_val); 30513 call_tests++; 30514 des_xmlTextReaderPtr(n_reader, reader, 0); 30515 xmlResetLastError(); 30516 if (mem_base != xmlMemBlocks()) { 30517 printf("Leak of %d blocks found in xmlTextReaderAttributeCount", 30518 xmlMemBlocks() - mem_base); 30519 test_ret++; 30520 printf(" %d", n_reader); 30521 printf("\n"); 30522 } 30523 } 30524 function_tests++; 30525 #endif 30526 30527 return(test_ret); 30528 } 30529 30530 30531 static int 30532 test_xmlTextReaderBaseUri(void) { 30533 int test_ret = 0; 30534 30535 #if defined(LIBXML_READER_ENABLED) 30536 int mem_base; 30537 xmlChar * ret_val; 30538 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 30539 int n_reader; 30540 30541 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 30542 mem_base = xmlMemBlocks(); 30543 reader = gen_xmlTextReaderPtr(n_reader, 0); 30544 30545 ret_val = xmlTextReaderBaseUri(reader); 30546 desret_xmlChar_ptr(ret_val); 30547 call_tests++; 30548 des_xmlTextReaderPtr(n_reader, reader, 0); 30549 xmlResetLastError(); 30550 if (mem_base != xmlMemBlocks()) { 30551 printf("Leak of %d blocks found in xmlTextReaderBaseUri", 30552 xmlMemBlocks() - mem_base); 30553 test_ret++; 30554 printf(" %d", n_reader); 30555 printf("\n"); 30556 } 30557 } 30558 function_tests++; 30559 #endif 30560 30561 return(test_ret); 30562 } 30563 30564 30565 static int 30566 test_xmlTextReaderByteConsumed(void) { 30567 int test_ret = 0; 30568 30569 #if defined(LIBXML_READER_ENABLED) 30570 int mem_base; 30571 long ret_val; 30572 xmlTextReaderPtr reader; /* an XML reader */ 30573 int n_reader; 30574 30575 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 30576 mem_base = xmlMemBlocks(); 30577 reader = gen_xmlTextReaderPtr(n_reader, 0); 30578 30579 ret_val = xmlTextReaderByteConsumed(reader); 30580 desret_long(ret_val); 30581 call_tests++; 30582 des_xmlTextReaderPtr(n_reader, reader, 0); 30583 xmlResetLastError(); 30584 if (mem_base != xmlMemBlocks()) { 30585 printf("Leak of %d blocks found in xmlTextReaderByteConsumed", 30586 xmlMemBlocks() - mem_base); 30587 test_ret++; 30588 printf(" %d", n_reader); 30589 printf("\n"); 30590 } 30591 } 30592 function_tests++; 30593 #endif 30594 30595 return(test_ret); 30596 } 30597 30598 30599 static int 30600 test_xmlTextReaderClose(void) { 30601 int test_ret = 0; 30602 30603 #if defined(LIBXML_READER_ENABLED) 30604 int mem_base; 30605 int ret_val; 30606 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 30607 int n_reader; 30608 30609 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 30610 mem_base = xmlMemBlocks(); 30611 reader = gen_xmlTextReaderPtr(n_reader, 0); 30612 30613 ret_val = xmlTextReaderClose(reader); 30614 desret_int(ret_val); 30615 call_tests++; 30616 des_xmlTextReaderPtr(n_reader, reader, 0); 30617 xmlResetLastError(); 30618 if (mem_base != xmlMemBlocks()) { 30619 printf("Leak of %d blocks found in xmlTextReaderClose", 30620 xmlMemBlocks() - mem_base); 30621 test_ret++; 30622 printf(" %d", n_reader); 30623 printf("\n"); 30624 } 30625 } 30626 function_tests++; 30627 #endif 30628 30629 return(test_ret); 30630 } 30631 30632 30633 static int 30634 test_xmlTextReaderConstBaseUri(void) { 30635 int test_ret = 0; 30636 30637 #if defined(LIBXML_READER_ENABLED) 30638 int mem_base; 30639 const xmlChar * ret_val; 30640 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 30641 int n_reader; 30642 30643 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 30644 mem_base = xmlMemBlocks(); 30645 reader = gen_xmlTextReaderPtr(n_reader, 0); 30646 30647 ret_val = xmlTextReaderConstBaseUri(reader); 30648 desret_const_xmlChar_ptr(ret_val); 30649 call_tests++; 30650 des_xmlTextReaderPtr(n_reader, reader, 0); 30651 xmlResetLastError(); 30652 if (mem_base != xmlMemBlocks()) { 30653 printf("Leak of %d blocks found in xmlTextReaderConstBaseUri", 30654 xmlMemBlocks() - mem_base); 30655 test_ret++; 30656 printf(" %d", n_reader); 30657 printf("\n"); 30658 } 30659 } 30660 function_tests++; 30661 #endif 30662 30663 return(test_ret); 30664 } 30665 30666 30667 static int 30668 test_xmlTextReaderConstEncoding(void) { 30669 int test_ret = 0; 30670 30671 #if defined(LIBXML_READER_ENABLED) 30672 int mem_base; 30673 const xmlChar * ret_val; 30674 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 30675 int n_reader; 30676 30677 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 30678 mem_base = xmlMemBlocks(); 30679 reader = gen_xmlTextReaderPtr(n_reader, 0); 30680 30681 ret_val = xmlTextReaderConstEncoding(reader); 30682 desret_const_xmlChar_ptr(ret_val); 30683 call_tests++; 30684 des_xmlTextReaderPtr(n_reader, reader, 0); 30685 xmlResetLastError(); 30686 if (mem_base != xmlMemBlocks()) { 30687 printf("Leak of %d blocks found in xmlTextReaderConstEncoding", 30688 xmlMemBlocks() - mem_base); 30689 test_ret++; 30690 printf(" %d", n_reader); 30691 printf("\n"); 30692 } 30693 } 30694 function_tests++; 30695 #endif 30696 30697 return(test_ret); 30698 } 30699 30700 30701 static int 30702 test_xmlTextReaderConstLocalName(void) { 30703 int test_ret = 0; 30704 30705 #if defined(LIBXML_READER_ENABLED) 30706 int mem_base; 30707 const xmlChar * ret_val; 30708 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 30709 int n_reader; 30710 30711 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 30712 mem_base = xmlMemBlocks(); 30713 reader = gen_xmlTextReaderPtr(n_reader, 0); 30714 30715 ret_val = xmlTextReaderConstLocalName(reader); 30716 desret_const_xmlChar_ptr(ret_val); 30717 call_tests++; 30718 des_xmlTextReaderPtr(n_reader, reader, 0); 30719 xmlResetLastError(); 30720 if (mem_base != xmlMemBlocks()) { 30721 printf("Leak of %d blocks found in xmlTextReaderConstLocalName", 30722 xmlMemBlocks() - mem_base); 30723 test_ret++; 30724 printf(" %d", n_reader); 30725 printf("\n"); 30726 } 30727 } 30728 function_tests++; 30729 #endif 30730 30731 return(test_ret); 30732 } 30733 30734 30735 static int 30736 test_xmlTextReaderConstName(void) { 30737 int test_ret = 0; 30738 30739 #if defined(LIBXML_READER_ENABLED) 30740 int mem_base; 30741 const xmlChar * ret_val; 30742 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 30743 int n_reader; 30744 30745 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 30746 mem_base = xmlMemBlocks(); 30747 reader = gen_xmlTextReaderPtr(n_reader, 0); 30748 30749 ret_val = xmlTextReaderConstName(reader); 30750 desret_const_xmlChar_ptr(ret_val); 30751 call_tests++; 30752 des_xmlTextReaderPtr(n_reader, reader, 0); 30753 xmlResetLastError(); 30754 if (mem_base != xmlMemBlocks()) { 30755 printf("Leak of %d blocks found in xmlTextReaderConstName", 30756 xmlMemBlocks() - mem_base); 30757 test_ret++; 30758 printf(" %d", n_reader); 30759 printf("\n"); 30760 } 30761 } 30762 function_tests++; 30763 #endif 30764 30765 return(test_ret); 30766 } 30767 30768 30769 static int 30770 test_xmlTextReaderConstNamespaceUri(void) { 30771 int test_ret = 0; 30772 30773 #if defined(LIBXML_READER_ENABLED) 30774 int mem_base; 30775 const xmlChar * ret_val; 30776 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 30777 int n_reader; 30778 30779 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 30780 mem_base = xmlMemBlocks(); 30781 reader = gen_xmlTextReaderPtr(n_reader, 0); 30782 30783 ret_val = xmlTextReaderConstNamespaceUri(reader); 30784 desret_const_xmlChar_ptr(ret_val); 30785 call_tests++; 30786 des_xmlTextReaderPtr(n_reader, reader, 0); 30787 xmlResetLastError(); 30788 if (mem_base != xmlMemBlocks()) { 30789 printf("Leak of %d blocks found in xmlTextReaderConstNamespaceUri", 30790 xmlMemBlocks() - mem_base); 30791 test_ret++; 30792 printf(" %d", n_reader); 30793 printf("\n"); 30794 } 30795 } 30796 function_tests++; 30797 #endif 30798 30799 return(test_ret); 30800 } 30801 30802 30803 static int 30804 test_xmlTextReaderConstPrefix(void) { 30805 int test_ret = 0; 30806 30807 #if defined(LIBXML_READER_ENABLED) 30808 int mem_base; 30809 const xmlChar * ret_val; 30810 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 30811 int n_reader; 30812 30813 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 30814 mem_base = xmlMemBlocks(); 30815 reader = gen_xmlTextReaderPtr(n_reader, 0); 30816 30817 ret_val = xmlTextReaderConstPrefix(reader); 30818 desret_const_xmlChar_ptr(ret_val); 30819 call_tests++; 30820 des_xmlTextReaderPtr(n_reader, reader, 0); 30821 xmlResetLastError(); 30822 if (mem_base != xmlMemBlocks()) { 30823 printf("Leak of %d blocks found in xmlTextReaderConstPrefix", 30824 xmlMemBlocks() - mem_base); 30825 test_ret++; 30826 printf(" %d", n_reader); 30827 printf("\n"); 30828 } 30829 } 30830 function_tests++; 30831 #endif 30832 30833 return(test_ret); 30834 } 30835 30836 30837 static int 30838 test_xmlTextReaderConstString(void) { 30839 int test_ret = 0; 30840 30841 #if defined(LIBXML_READER_ENABLED) 30842 int mem_base; 30843 const xmlChar * ret_val; 30844 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 30845 int n_reader; 30846 xmlChar * str; /* the string to intern. */ 30847 int n_str; 30848 30849 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 30850 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 30851 mem_base = xmlMemBlocks(); 30852 reader = gen_xmlTextReaderPtr(n_reader, 0); 30853 str = gen_const_xmlChar_ptr(n_str, 1); 30854 30855 ret_val = xmlTextReaderConstString(reader, (const xmlChar *)str); 30856 desret_const_xmlChar_ptr(ret_val); 30857 call_tests++; 30858 des_xmlTextReaderPtr(n_reader, reader, 0); 30859 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1); 30860 xmlResetLastError(); 30861 if (mem_base != xmlMemBlocks()) { 30862 printf("Leak of %d blocks found in xmlTextReaderConstString", 30863 xmlMemBlocks() - mem_base); 30864 test_ret++; 30865 printf(" %d", n_reader); 30866 printf(" %d", n_str); 30867 printf("\n"); 30868 } 30869 } 30870 } 30871 function_tests++; 30872 #endif 30873 30874 return(test_ret); 30875 } 30876 30877 30878 static int 30879 test_xmlTextReaderConstValue(void) { 30880 int test_ret = 0; 30881 30882 #if defined(LIBXML_READER_ENABLED) 30883 int mem_base; 30884 const xmlChar * ret_val; 30885 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 30886 int n_reader; 30887 30888 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 30889 mem_base = xmlMemBlocks(); 30890 reader = gen_xmlTextReaderPtr(n_reader, 0); 30891 30892 ret_val = xmlTextReaderConstValue(reader); 30893 desret_const_xmlChar_ptr(ret_val); 30894 call_tests++; 30895 des_xmlTextReaderPtr(n_reader, reader, 0); 30896 xmlResetLastError(); 30897 if (mem_base != xmlMemBlocks()) { 30898 printf("Leak of %d blocks found in xmlTextReaderConstValue", 30899 xmlMemBlocks() - mem_base); 30900 test_ret++; 30901 printf(" %d", n_reader); 30902 printf("\n"); 30903 } 30904 } 30905 function_tests++; 30906 #endif 30907 30908 return(test_ret); 30909 } 30910 30911 30912 static int 30913 test_xmlTextReaderConstXmlLang(void) { 30914 int test_ret = 0; 30915 30916 #if defined(LIBXML_READER_ENABLED) 30917 int mem_base; 30918 const xmlChar * ret_val; 30919 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 30920 int n_reader; 30921 30922 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 30923 mem_base = xmlMemBlocks(); 30924 reader = gen_xmlTextReaderPtr(n_reader, 0); 30925 30926 ret_val = xmlTextReaderConstXmlLang(reader); 30927 desret_const_xmlChar_ptr(ret_val); 30928 call_tests++; 30929 des_xmlTextReaderPtr(n_reader, reader, 0); 30930 xmlResetLastError(); 30931 if (mem_base != xmlMemBlocks()) { 30932 printf("Leak of %d blocks found in xmlTextReaderConstXmlLang", 30933 xmlMemBlocks() - mem_base); 30934 test_ret++; 30935 printf(" %d", n_reader); 30936 printf("\n"); 30937 } 30938 } 30939 function_tests++; 30940 #endif 30941 30942 return(test_ret); 30943 } 30944 30945 30946 static int 30947 test_xmlTextReaderConstXmlVersion(void) { 30948 int test_ret = 0; 30949 30950 #if defined(LIBXML_READER_ENABLED) 30951 int mem_base; 30952 const xmlChar * ret_val; 30953 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 30954 int n_reader; 30955 30956 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 30957 mem_base = xmlMemBlocks(); 30958 reader = gen_xmlTextReaderPtr(n_reader, 0); 30959 30960 ret_val = xmlTextReaderConstXmlVersion(reader); 30961 desret_const_xmlChar_ptr(ret_val); 30962 call_tests++; 30963 des_xmlTextReaderPtr(n_reader, reader, 0); 30964 xmlResetLastError(); 30965 if (mem_base != xmlMemBlocks()) { 30966 printf("Leak of %d blocks found in xmlTextReaderConstXmlVersion", 30967 xmlMemBlocks() - mem_base); 30968 test_ret++; 30969 printf(" %d", n_reader); 30970 printf("\n"); 30971 } 30972 } 30973 function_tests++; 30974 #endif 30975 30976 return(test_ret); 30977 } 30978 30979 30980 static int 30981 test_xmlTextReaderCurrentDoc(void) { 30982 int test_ret = 0; 30983 30984 #if defined(LIBXML_READER_ENABLED) 30985 int mem_base; 30986 xmlDocPtr ret_val; 30987 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 30988 int n_reader; 30989 30990 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 30991 mem_base = xmlMemBlocks(); 30992 reader = gen_xmlTextReaderPtr(n_reader, 0); 30993 30994 ret_val = xmlTextReaderCurrentDoc(reader); 30995 desret_xmlDocPtr(ret_val); 30996 call_tests++; 30997 des_xmlTextReaderPtr(n_reader, reader, 0); 30998 xmlResetLastError(); 30999 if (mem_base != xmlMemBlocks()) { 31000 printf("Leak of %d blocks found in xmlTextReaderCurrentDoc", 31001 xmlMemBlocks() - mem_base); 31002 test_ret++; 31003 printf(" %d", n_reader); 31004 printf("\n"); 31005 } 31006 } 31007 function_tests++; 31008 #endif 31009 31010 return(test_ret); 31011 } 31012 31013 31014 static int 31015 test_xmlTextReaderCurrentNode(void) { 31016 int test_ret = 0; 31017 31018 #if defined(LIBXML_READER_ENABLED) 31019 int mem_base; 31020 xmlNodePtr ret_val; 31021 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31022 int n_reader; 31023 31024 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31025 mem_base = xmlMemBlocks(); 31026 reader = gen_xmlTextReaderPtr(n_reader, 0); 31027 31028 ret_val = xmlTextReaderCurrentNode(reader); 31029 desret_xmlNodePtr(ret_val); 31030 call_tests++; 31031 des_xmlTextReaderPtr(n_reader, reader, 0); 31032 xmlResetLastError(); 31033 if (mem_base != xmlMemBlocks()) { 31034 printf("Leak of %d blocks found in xmlTextReaderCurrentNode", 31035 xmlMemBlocks() - mem_base); 31036 test_ret++; 31037 printf(" %d", n_reader); 31038 printf("\n"); 31039 } 31040 } 31041 function_tests++; 31042 #endif 31043 31044 return(test_ret); 31045 } 31046 31047 31048 static int 31049 test_xmlTextReaderDepth(void) { 31050 int test_ret = 0; 31051 31052 #if defined(LIBXML_READER_ENABLED) 31053 int mem_base; 31054 int ret_val; 31055 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31056 int n_reader; 31057 31058 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31059 mem_base = xmlMemBlocks(); 31060 reader = gen_xmlTextReaderPtr(n_reader, 0); 31061 31062 ret_val = xmlTextReaderDepth(reader); 31063 desret_int(ret_val); 31064 call_tests++; 31065 des_xmlTextReaderPtr(n_reader, reader, 0); 31066 xmlResetLastError(); 31067 if (mem_base != xmlMemBlocks()) { 31068 printf("Leak of %d blocks found in xmlTextReaderDepth", 31069 xmlMemBlocks() - mem_base); 31070 test_ret++; 31071 printf(" %d", n_reader); 31072 printf("\n"); 31073 } 31074 } 31075 function_tests++; 31076 #endif 31077 31078 return(test_ret); 31079 } 31080 31081 31082 static int 31083 test_xmlTextReaderExpand(void) { 31084 int test_ret = 0; 31085 31086 #if defined(LIBXML_READER_ENABLED) 31087 int mem_base; 31088 xmlNodePtr ret_val; 31089 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31090 int n_reader; 31091 31092 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31093 mem_base = xmlMemBlocks(); 31094 reader = gen_xmlTextReaderPtr(n_reader, 0); 31095 31096 ret_val = xmlTextReaderExpand(reader); 31097 desret_xmlNodePtr(ret_val); 31098 call_tests++; 31099 des_xmlTextReaderPtr(n_reader, reader, 0); 31100 xmlResetLastError(); 31101 if (mem_base != xmlMemBlocks()) { 31102 printf("Leak of %d blocks found in xmlTextReaderExpand", 31103 xmlMemBlocks() - mem_base); 31104 test_ret++; 31105 printf(" %d", n_reader); 31106 printf("\n"); 31107 } 31108 } 31109 function_tests++; 31110 #endif 31111 31112 return(test_ret); 31113 } 31114 31115 31116 static int 31117 test_xmlTextReaderGetAttribute(void) { 31118 int test_ret = 0; 31119 31120 #if defined(LIBXML_READER_ENABLED) 31121 int mem_base; 31122 xmlChar * ret_val; 31123 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31124 int n_reader; 31125 xmlChar * name; /* the qualified name of the attribute. */ 31126 int n_name; 31127 31128 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31129 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 31130 mem_base = xmlMemBlocks(); 31131 reader = gen_xmlTextReaderPtr(n_reader, 0); 31132 name = gen_const_xmlChar_ptr(n_name, 1); 31133 31134 ret_val = xmlTextReaderGetAttribute(reader, (const xmlChar *)name); 31135 desret_xmlChar_ptr(ret_val); 31136 call_tests++; 31137 des_xmlTextReaderPtr(n_reader, reader, 0); 31138 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 31139 xmlResetLastError(); 31140 if (mem_base != xmlMemBlocks()) { 31141 printf("Leak of %d blocks found in xmlTextReaderGetAttribute", 31142 xmlMemBlocks() - mem_base); 31143 test_ret++; 31144 printf(" %d", n_reader); 31145 printf(" %d", n_name); 31146 printf("\n"); 31147 } 31148 } 31149 } 31150 function_tests++; 31151 #endif 31152 31153 return(test_ret); 31154 } 31155 31156 31157 static int 31158 test_xmlTextReaderGetAttributeNo(void) { 31159 int test_ret = 0; 31160 31161 #if defined(LIBXML_READER_ENABLED) 31162 int mem_base; 31163 xmlChar * ret_val; 31164 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31165 int n_reader; 31166 int no; /* the zero-based index of the attribute relative to the containing element */ 31167 int n_no; 31168 31169 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31170 for (n_no = 0;n_no < gen_nb_int;n_no++) { 31171 mem_base = xmlMemBlocks(); 31172 reader = gen_xmlTextReaderPtr(n_reader, 0); 31173 no = gen_int(n_no, 1); 31174 31175 ret_val = xmlTextReaderGetAttributeNo(reader, no); 31176 desret_xmlChar_ptr(ret_val); 31177 call_tests++; 31178 des_xmlTextReaderPtr(n_reader, reader, 0); 31179 des_int(n_no, no, 1); 31180 xmlResetLastError(); 31181 if (mem_base != xmlMemBlocks()) { 31182 printf("Leak of %d blocks found in xmlTextReaderGetAttributeNo", 31183 xmlMemBlocks() - mem_base); 31184 test_ret++; 31185 printf(" %d", n_reader); 31186 printf(" %d", n_no); 31187 printf("\n"); 31188 } 31189 } 31190 } 31191 function_tests++; 31192 #endif 31193 31194 return(test_ret); 31195 } 31196 31197 31198 static int 31199 test_xmlTextReaderGetAttributeNs(void) { 31200 int test_ret = 0; 31201 31202 #if defined(LIBXML_READER_ENABLED) 31203 int mem_base; 31204 xmlChar * ret_val; 31205 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31206 int n_reader; 31207 xmlChar * localName; /* the local name of the attribute. */ 31208 int n_localName; 31209 xmlChar * namespaceURI; /* the namespace URI of the attribute. */ 31210 int n_namespaceURI; 31211 31212 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31213 for (n_localName = 0;n_localName < gen_nb_const_xmlChar_ptr;n_localName++) { 31214 for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) { 31215 mem_base = xmlMemBlocks(); 31216 reader = gen_xmlTextReaderPtr(n_reader, 0); 31217 localName = gen_const_xmlChar_ptr(n_localName, 1); 31218 namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 2); 31219 31220 ret_val = xmlTextReaderGetAttributeNs(reader, (const xmlChar *)localName, (const xmlChar *)namespaceURI); 31221 desret_xmlChar_ptr(ret_val); 31222 call_tests++; 31223 des_xmlTextReaderPtr(n_reader, reader, 0); 31224 des_const_xmlChar_ptr(n_localName, (const xmlChar *)localName, 1); 31225 des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 2); 31226 xmlResetLastError(); 31227 if (mem_base != xmlMemBlocks()) { 31228 printf("Leak of %d blocks found in xmlTextReaderGetAttributeNs", 31229 xmlMemBlocks() - mem_base); 31230 test_ret++; 31231 printf(" %d", n_reader); 31232 printf(" %d", n_localName); 31233 printf(" %d", n_namespaceURI); 31234 printf("\n"); 31235 } 31236 } 31237 } 31238 } 31239 function_tests++; 31240 #endif 31241 31242 return(test_ret); 31243 } 31244 31245 #ifdef LIBXML_READER_ENABLED 31246 31247 #define gen_nb_xmlTextReaderErrorFunc_ptr 1 31248 static xmlTextReaderErrorFunc * gen_xmlTextReaderErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 31249 return(NULL); 31250 } 31251 static void des_xmlTextReaderErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlTextReaderErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 31252 } 31253 #endif 31254 31255 31256 static int 31257 test_xmlTextReaderGetErrorHandler(void) { 31258 int test_ret = 0; 31259 31260 #if defined(LIBXML_READER_ENABLED) 31261 int mem_base; 31262 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31263 int n_reader; 31264 xmlTextReaderErrorFunc * f; /* the callback function or NULL is no callback has been registered */ 31265 int n_f; 31266 void ** arg; /* a user argument */ 31267 int n_arg; 31268 31269 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31270 for (n_f = 0;n_f < gen_nb_xmlTextReaderErrorFunc_ptr;n_f++) { 31271 for (n_arg = 0;n_arg < gen_nb_void_ptr_ptr;n_arg++) { 31272 mem_base = xmlMemBlocks(); 31273 reader = gen_xmlTextReaderPtr(n_reader, 0); 31274 f = gen_xmlTextReaderErrorFunc_ptr(n_f, 1); 31275 arg = gen_void_ptr_ptr(n_arg, 2); 31276 31277 xmlTextReaderGetErrorHandler(reader, f, arg); 31278 call_tests++; 31279 des_xmlTextReaderPtr(n_reader, reader, 0); 31280 des_xmlTextReaderErrorFunc_ptr(n_f, f, 1); 31281 des_void_ptr_ptr(n_arg, arg, 2); 31282 xmlResetLastError(); 31283 if (mem_base != xmlMemBlocks()) { 31284 printf("Leak of %d blocks found in xmlTextReaderGetErrorHandler", 31285 xmlMemBlocks() - mem_base); 31286 test_ret++; 31287 printf(" %d", n_reader); 31288 printf(" %d", n_f); 31289 printf(" %d", n_arg); 31290 printf("\n"); 31291 } 31292 } 31293 } 31294 } 31295 function_tests++; 31296 #endif 31297 31298 return(test_ret); 31299 } 31300 31301 31302 static int 31303 test_xmlTextReaderGetParserColumnNumber(void) { 31304 int test_ret = 0; 31305 31306 #if defined(LIBXML_READER_ENABLED) 31307 int mem_base; 31308 int ret_val; 31309 xmlTextReaderPtr reader; /* the user data (XML reader context) */ 31310 int n_reader; 31311 31312 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31313 mem_base = xmlMemBlocks(); 31314 reader = gen_xmlTextReaderPtr(n_reader, 0); 31315 31316 ret_val = xmlTextReaderGetParserColumnNumber(reader); 31317 desret_int(ret_val); 31318 call_tests++; 31319 des_xmlTextReaderPtr(n_reader, reader, 0); 31320 xmlResetLastError(); 31321 if (mem_base != xmlMemBlocks()) { 31322 printf("Leak of %d blocks found in xmlTextReaderGetParserColumnNumber", 31323 xmlMemBlocks() - mem_base); 31324 test_ret++; 31325 printf(" %d", n_reader); 31326 printf("\n"); 31327 } 31328 } 31329 function_tests++; 31330 #endif 31331 31332 return(test_ret); 31333 } 31334 31335 31336 static int 31337 test_xmlTextReaderGetParserLineNumber(void) { 31338 int test_ret = 0; 31339 31340 #if defined(LIBXML_READER_ENABLED) 31341 int mem_base; 31342 int ret_val; 31343 xmlTextReaderPtr reader; /* the user data (XML reader context) */ 31344 int n_reader; 31345 31346 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31347 mem_base = xmlMemBlocks(); 31348 reader = gen_xmlTextReaderPtr(n_reader, 0); 31349 31350 ret_val = xmlTextReaderGetParserLineNumber(reader); 31351 desret_int(ret_val); 31352 call_tests++; 31353 des_xmlTextReaderPtr(n_reader, reader, 0); 31354 xmlResetLastError(); 31355 if (mem_base != xmlMemBlocks()) { 31356 printf("Leak of %d blocks found in xmlTextReaderGetParserLineNumber", 31357 xmlMemBlocks() - mem_base); 31358 test_ret++; 31359 printf(" %d", n_reader); 31360 printf("\n"); 31361 } 31362 } 31363 function_tests++; 31364 #endif 31365 31366 return(test_ret); 31367 } 31368 31369 31370 static int 31371 test_xmlTextReaderGetParserProp(void) { 31372 int test_ret = 0; 31373 31374 #if defined(LIBXML_READER_ENABLED) 31375 int mem_base; 31376 int ret_val; 31377 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31378 int n_reader; 31379 int prop; /* the xmlParserProperties to get */ 31380 int n_prop; 31381 31382 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31383 for (n_prop = 0;n_prop < gen_nb_int;n_prop++) { 31384 mem_base = xmlMemBlocks(); 31385 reader = gen_xmlTextReaderPtr(n_reader, 0); 31386 prop = gen_int(n_prop, 1); 31387 31388 ret_val = xmlTextReaderGetParserProp(reader, prop); 31389 desret_int(ret_val); 31390 call_tests++; 31391 des_xmlTextReaderPtr(n_reader, reader, 0); 31392 des_int(n_prop, prop, 1); 31393 xmlResetLastError(); 31394 if (mem_base != xmlMemBlocks()) { 31395 printf("Leak of %d blocks found in xmlTextReaderGetParserProp", 31396 xmlMemBlocks() - mem_base); 31397 test_ret++; 31398 printf(" %d", n_reader); 31399 printf(" %d", n_prop); 31400 printf("\n"); 31401 } 31402 } 31403 } 31404 function_tests++; 31405 #endif 31406 31407 return(test_ret); 31408 } 31409 31410 31411 static int 31412 test_xmlTextReaderGetRemainder(void) { 31413 int test_ret = 0; 31414 31415 #if defined(LIBXML_READER_ENABLED) 31416 int mem_base; 31417 xmlParserInputBufferPtr ret_val; 31418 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31419 int n_reader; 31420 31421 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31422 mem_base = xmlMemBlocks(); 31423 reader = gen_xmlTextReaderPtr(n_reader, 0); 31424 31425 ret_val = xmlTextReaderGetRemainder(reader); 31426 desret_xmlParserInputBufferPtr(ret_val); 31427 call_tests++; 31428 des_xmlTextReaderPtr(n_reader, reader, 0); 31429 xmlResetLastError(); 31430 if (mem_base != xmlMemBlocks()) { 31431 printf("Leak of %d blocks found in xmlTextReaderGetRemainder", 31432 xmlMemBlocks() - mem_base); 31433 test_ret++; 31434 printf(" %d", n_reader); 31435 printf("\n"); 31436 } 31437 } 31438 function_tests++; 31439 #endif 31440 31441 return(test_ret); 31442 } 31443 31444 31445 static int 31446 test_xmlTextReaderHasAttributes(void) { 31447 int test_ret = 0; 31448 31449 #if defined(LIBXML_READER_ENABLED) 31450 int mem_base; 31451 int ret_val; 31452 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31453 int n_reader; 31454 31455 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31456 mem_base = xmlMemBlocks(); 31457 reader = gen_xmlTextReaderPtr(n_reader, 0); 31458 31459 ret_val = xmlTextReaderHasAttributes(reader); 31460 desret_int(ret_val); 31461 call_tests++; 31462 des_xmlTextReaderPtr(n_reader, reader, 0); 31463 xmlResetLastError(); 31464 if (mem_base != xmlMemBlocks()) { 31465 printf("Leak of %d blocks found in xmlTextReaderHasAttributes", 31466 xmlMemBlocks() - mem_base); 31467 test_ret++; 31468 printf(" %d", n_reader); 31469 printf("\n"); 31470 } 31471 } 31472 function_tests++; 31473 #endif 31474 31475 return(test_ret); 31476 } 31477 31478 31479 static int 31480 test_xmlTextReaderHasValue(void) { 31481 int test_ret = 0; 31482 31483 #if defined(LIBXML_READER_ENABLED) 31484 int mem_base; 31485 int ret_val; 31486 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31487 int n_reader; 31488 31489 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31490 mem_base = xmlMemBlocks(); 31491 reader = gen_xmlTextReaderPtr(n_reader, 0); 31492 31493 ret_val = xmlTextReaderHasValue(reader); 31494 desret_int(ret_val); 31495 call_tests++; 31496 des_xmlTextReaderPtr(n_reader, reader, 0); 31497 xmlResetLastError(); 31498 if (mem_base != xmlMemBlocks()) { 31499 printf("Leak of %d blocks found in xmlTextReaderHasValue", 31500 xmlMemBlocks() - mem_base); 31501 test_ret++; 31502 printf(" %d", n_reader); 31503 printf("\n"); 31504 } 31505 } 31506 function_tests++; 31507 #endif 31508 31509 return(test_ret); 31510 } 31511 31512 31513 static int 31514 test_xmlTextReaderIsDefault(void) { 31515 int test_ret = 0; 31516 31517 #if defined(LIBXML_READER_ENABLED) 31518 int mem_base; 31519 int ret_val; 31520 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31521 int n_reader; 31522 31523 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31524 mem_base = xmlMemBlocks(); 31525 reader = gen_xmlTextReaderPtr(n_reader, 0); 31526 31527 ret_val = xmlTextReaderIsDefault(reader); 31528 desret_int(ret_val); 31529 call_tests++; 31530 des_xmlTextReaderPtr(n_reader, reader, 0); 31531 xmlResetLastError(); 31532 if (mem_base != xmlMemBlocks()) { 31533 printf("Leak of %d blocks found in xmlTextReaderIsDefault", 31534 xmlMemBlocks() - mem_base); 31535 test_ret++; 31536 printf(" %d", n_reader); 31537 printf("\n"); 31538 } 31539 } 31540 function_tests++; 31541 #endif 31542 31543 return(test_ret); 31544 } 31545 31546 31547 static int 31548 test_xmlTextReaderIsEmptyElement(void) { 31549 int test_ret = 0; 31550 31551 #if defined(LIBXML_READER_ENABLED) 31552 int mem_base; 31553 int ret_val; 31554 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31555 int n_reader; 31556 31557 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31558 mem_base = xmlMemBlocks(); 31559 reader = gen_xmlTextReaderPtr(n_reader, 0); 31560 31561 ret_val = xmlTextReaderIsEmptyElement(reader); 31562 desret_int(ret_val); 31563 call_tests++; 31564 des_xmlTextReaderPtr(n_reader, reader, 0); 31565 xmlResetLastError(); 31566 if (mem_base != xmlMemBlocks()) { 31567 printf("Leak of %d blocks found in xmlTextReaderIsEmptyElement", 31568 xmlMemBlocks() - mem_base); 31569 test_ret++; 31570 printf(" %d", n_reader); 31571 printf("\n"); 31572 } 31573 } 31574 function_tests++; 31575 #endif 31576 31577 return(test_ret); 31578 } 31579 31580 31581 static int 31582 test_xmlTextReaderIsNamespaceDecl(void) { 31583 int test_ret = 0; 31584 31585 #if defined(LIBXML_READER_ENABLED) 31586 int mem_base; 31587 int ret_val; 31588 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31589 int n_reader; 31590 31591 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31592 mem_base = xmlMemBlocks(); 31593 reader = gen_xmlTextReaderPtr(n_reader, 0); 31594 31595 ret_val = xmlTextReaderIsNamespaceDecl(reader); 31596 desret_int(ret_val); 31597 call_tests++; 31598 des_xmlTextReaderPtr(n_reader, reader, 0); 31599 xmlResetLastError(); 31600 if (mem_base != xmlMemBlocks()) { 31601 printf("Leak of %d blocks found in xmlTextReaderIsNamespaceDecl", 31602 xmlMemBlocks() - mem_base); 31603 test_ret++; 31604 printf(" %d", n_reader); 31605 printf("\n"); 31606 } 31607 } 31608 function_tests++; 31609 #endif 31610 31611 return(test_ret); 31612 } 31613 31614 31615 static int 31616 test_xmlTextReaderIsValid(void) { 31617 int test_ret = 0; 31618 31619 #if defined(LIBXML_READER_ENABLED) 31620 int mem_base; 31621 int ret_val; 31622 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31623 int n_reader; 31624 31625 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31626 mem_base = xmlMemBlocks(); 31627 reader = gen_xmlTextReaderPtr(n_reader, 0); 31628 31629 ret_val = xmlTextReaderIsValid(reader); 31630 desret_int(ret_val); 31631 call_tests++; 31632 des_xmlTextReaderPtr(n_reader, reader, 0); 31633 xmlResetLastError(); 31634 if (mem_base != xmlMemBlocks()) { 31635 printf("Leak of %d blocks found in xmlTextReaderIsValid", 31636 xmlMemBlocks() - mem_base); 31637 test_ret++; 31638 printf(" %d", n_reader); 31639 printf("\n"); 31640 } 31641 } 31642 function_tests++; 31643 #endif 31644 31645 return(test_ret); 31646 } 31647 31648 31649 static int 31650 test_xmlTextReaderLocalName(void) { 31651 int test_ret = 0; 31652 31653 #if defined(LIBXML_READER_ENABLED) 31654 int mem_base; 31655 xmlChar * ret_val; 31656 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31657 int n_reader; 31658 31659 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31660 mem_base = xmlMemBlocks(); 31661 reader = gen_xmlTextReaderPtr(n_reader, 0); 31662 31663 ret_val = xmlTextReaderLocalName(reader); 31664 desret_xmlChar_ptr(ret_val); 31665 call_tests++; 31666 des_xmlTextReaderPtr(n_reader, reader, 0); 31667 xmlResetLastError(); 31668 if (mem_base != xmlMemBlocks()) { 31669 printf("Leak of %d blocks found in xmlTextReaderLocalName", 31670 xmlMemBlocks() - mem_base); 31671 test_ret++; 31672 printf(" %d", n_reader); 31673 printf("\n"); 31674 } 31675 } 31676 function_tests++; 31677 #endif 31678 31679 return(test_ret); 31680 } 31681 31682 #ifdef LIBXML_READER_ENABLED 31683 31684 #define gen_nb_xmlTextReaderLocatorPtr 1 31685 static xmlTextReaderLocatorPtr gen_xmlTextReaderLocatorPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 31686 return(NULL); 31687 } 31688 static void des_xmlTextReaderLocatorPtr(int no ATTRIBUTE_UNUSED, xmlTextReaderLocatorPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 31689 } 31690 #endif 31691 31692 31693 static int 31694 test_xmlTextReaderLocatorBaseURI(void) { 31695 int test_ret = 0; 31696 31697 #if defined(LIBXML_READER_ENABLED) 31698 int mem_base; 31699 xmlChar * ret_val; 31700 xmlTextReaderLocatorPtr locator; /* the xmlTextReaderLocatorPtr used */ 31701 int n_locator; 31702 31703 for (n_locator = 0;n_locator < gen_nb_xmlTextReaderLocatorPtr;n_locator++) { 31704 mem_base = xmlMemBlocks(); 31705 locator = gen_xmlTextReaderLocatorPtr(n_locator, 0); 31706 31707 ret_val = xmlTextReaderLocatorBaseURI(locator); 31708 desret_xmlChar_ptr(ret_val); 31709 call_tests++; 31710 des_xmlTextReaderLocatorPtr(n_locator, locator, 0); 31711 xmlResetLastError(); 31712 if (mem_base != xmlMemBlocks()) { 31713 printf("Leak of %d blocks found in xmlTextReaderLocatorBaseURI", 31714 xmlMemBlocks() - mem_base); 31715 test_ret++; 31716 printf(" %d", n_locator); 31717 printf("\n"); 31718 } 31719 } 31720 function_tests++; 31721 #endif 31722 31723 return(test_ret); 31724 } 31725 31726 31727 static int 31728 test_xmlTextReaderLocatorLineNumber(void) { 31729 int test_ret = 0; 31730 31731 #if defined(LIBXML_READER_ENABLED) 31732 int mem_base; 31733 int ret_val; 31734 xmlTextReaderLocatorPtr locator; /* the xmlTextReaderLocatorPtr used */ 31735 int n_locator; 31736 31737 for (n_locator = 0;n_locator < gen_nb_xmlTextReaderLocatorPtr;n_locator++) { 31738 mem_base = xmlMemBlocks(); 31739 locator = gen_xmlTextReaderLocatorPtr(n_locator, 0); 31740 31741 ret_val = xmlTextReaderLocatorLineNumber(locator); 31742 desret_int(ret_val); 31743 call_tests++; 31744 des_xmlTextReaderLocatorPtr(n_locator, locator, 0); 31745 xmlResetLastError(); 31746 if (mem_base != xmlMemBlocks()) { 31747 printf("Leak of %d blocks found in xmlTextReaderLocatorLineNumber", 31748 xmlMemBlocks() - mem_base); 31749 test_ret++; 31750 printf(" %d", n_locator); 31751 printf("\n"); 31752 } 31753 } 31754 function_tests++; 31755 #endif 31756 31757 return(test_ret); 31758 } 31759 31760 31761 static int 31762 test_xmlTextReaderLookupNamespace(void) { 31763 int test_ret = 0; 31764 31765 #if defined(LIBXML_READER_ENABLED) 31766 int mem_base; 31767 xmlChar * ret_val; 31768 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31769 int n_reader; 31770 xmlChar * prefix; /* the prefix whose namespace URI is to be resolved. To return the default namespace, specify NULL */ 31771 int n_prefix; 31772 31773 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31774 for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) { 31775 mem_base = xmlMemBlocks(); 31776 reader = gen_xmlTextReaderPtr(n_reader, 0); 31777 prefix = gen_const_xmlChar_ptr(n_prefix, 1); 31778 31779 ret_val = xmlTextReaderLookupNamespace(reader, (const xmlChar *)prefix); 31780 desret_xmlChar_ptr(ret_val); 31781 call_tests++; 31782 des_xmlTextReaderPtr(n_reader, reader, 0); 31783 des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1); 31784 xmlResetLastError(); 31785 if (mem_base != xmlMemBlocks()) { 31786 printf("Leak of %d blocks found in xmlTextReaderLookupNamespace", 31787 xmlMemBlocks() - mem_base); 31788 test_ret++; 31789 printf(" %d", n_reader); 31790 printf(" %d", n_prefix); 31791 printf("\n"); 31792 } 31793 } 31794 } 31795 function_tests++; 31796 #endif 31797 31798 return(test_ret); 31799 } 31800 31801 31802 static int 31803 test_xmlTextReaderMoveToAttribute(void) { 31804 int test_ret = 0; 31805 31806 #if defined(LIBXML_READER_ENABLED) 31807 int mem_base; 31808 int ret_val; 31809 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31810 int n_reader; 31811 xmlChar * name; /* the qualified name of the attribute. */ 31812 int n_name; 31813 31814 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31815 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 31816 mem_base = xmlMemBlocks(); 31817 reader = gen_xmlTextReaderPtr(n_reader, 0); 31818 name = gen_const_xmlChar_ptr(n_name, 1); 31819 31820 ret_val = xmlTextReaderMoveToAttribute(reader, (const xmlChar *)name); 31821 desret_int(ret_val); 31822 call_tests++; 31823 des_xmlTextReaderPtr(n_reader, reader, 0); 31824 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 31825 xmlResetLastError(); 31826 if (mem_base != xmlMemBlocks()) { 31827 printf("Leak of %d blocks found in xmlTextReaderMoveToAttribute", 31828 xmlMemBlocks() - mem_base); 31829 test_ret++; 31830 printf(" %d", n_reader); 31831 printf(" %d", n_name); 31832 printf("\n"); 31833 } 31834 } 31835 } 31836 function_tests++; 31837 #endif 31838 31839 return(test_ret); 31840 } 31841 31842 31843 static int 31844 test_xmlTextReaderMoveToAttributeNo(void) { 31845 int test_ret = 0; 31846 31847 #if defined(LIBXML_READER_ENABLED) 31848 int mem_base; 31849 int ret_val; 31850 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31851 int n_reader; 31852 int no; /* the zero-based index of the attribute relative to the containing element. */ 31853 int n_no; 31854 31855 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31856 for (n_no = 0;n_no < gen_nb_int;n_no++) { 31857 mem_base = xmlMemBlocks(); 31858 reader = gen_xmlTextReaderPtr(n_reader, 0); 31859 no = gen_int(n_no, 1); 31860 31861 ret_val = xmlTextReaderMoveToAttributeNo(reader, no); 31862 desret_int(ret_val); 31863 call_tests++; 31864 des_xmlTextReaderPtr(n_reader, reader, 0); 31865 des_int(n_no, no, 1); 31866 xmlResetLastError(); 31867 if (mem_base != xmlMemBlocks()) { 31868 printf("Leak of %d blocks found in xmlTextReaderMoveToAttributeNo", 31869 xmlMemBlocks() - mem_base); 31870 test_ret++; 31871 printf(" %d", n_reader); 31872 printf(" %d", n_no); 31873 printf("\n"); 31874 } 31875 } 31876 } 31877 function_tests++; 31878 #endif 31879 31880 return(test_ret); 31881 } 31882 31883 31884 static int 31885 test_xmlTextReaderMoveToAttributeNs(void) { 31886 int test_ret = 0; 31887 31888 #if defined(LIBXML_READER_ENABLED) 31889 int mem_base; 31890 int ret_val; 31891 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31892 int n_reader; 31893 xmlChar * localName; /* the local name of the attribute. */ 31894 int n_localName; 31895 xmlChar * namespaceURI; /* the namespace URI of the attribute. */ 31896 int n_namespaceURI; 31897 31898 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31899 for (n_localName = 0;n_localName < gen_nb_const_xmlChar_ptr;n_localName++) { 31900 for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) { 31901 mem_base = xmlMemBlocks(); 31902 reader = gen_xmlTextReaderPtr(n_reader, 0); 31903 localName = gen_const_xmlChar_ptr(n_localName, 1); 31904 namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 2); 31905 31906 ret_val = xmlTextReaderMoveToAttributeNs(reader, (const xmlChar *)localName, (const xmlChar *)namespaceURI); 31907 desret_int(ret_val); 31908 call_tests++; 31909 des_xmlTextReaderPtr(n_reader, reader, 0); 31910 des_const_xmlChar_ptr(n_localName, (const xmlChar *)localName, 1); 31911 des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 2); 31912 xmlResetLastError(); 31913 if (mem_base != xmlMemBlocks()) { 31914 printf("Leak of %d blocks found in xmlTextReaderMoveToAttributeNs", 31915 xmlMemBlocks() - mem_base); 31916 test_ret++; 31917 printf(" %d", n_reader); 31918 printf(" %d", n_localName); 31919 printf(" %d", n_namespaceURI); 31920 printf("\n"); 31921 } 31922 } 31923 } 31924 } 31925 function_tests++; 31926 #endif 31927 31928 return(test_ret); 31929 } 31930 31931 31932 static int 31933 test_xmlTextReaderMoveToElement(void) { 31934 int test_ret = 0; 31935 31936 #if defined(LIBXML_READER_ENABLED) 31937 int mem_base; 31938 int ret_val; 31939 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31940 int n_reader; 31941 31942 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31943 mem_base = xmlMemBlocks(); 31944 reader = gen_xmlTextReaderPtr(n_reader, 0); 31945 31946 ret_val = xmlTextReaderMoveToElement(reader); 31947 desret_int(ret_val); 31948 call_tests++; 31949 des_xmlTextReaderPtr(n_reader, reader, 0); 31950 xmlResetLastError(); 31951 if (mem_base != xmlMemBlocks()) { 31952 printf("Leak of %d blocks found in xmlTextReaderMoveToElement", 31953 xmlMemBlocks() - mem_base); 31954 test_ret++; 31955 printf(" %d", n_reader); 31956 printf("\n"); 31957 } 31958 } 31959 function_tests++; 31960 #endif 31961 31962 return(test_ret); 31963 } 31964 31965 31966 static int 31967 test_xmlTextReaderMoveToFirstAttribute(void) { 31968 int test_ret = 0; 31969 31970 #if defined(LIBXML_READER_ENABLED) 31971 int mem_base; 31972 int ret_val; 31973 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 31974 int n_reader; 31975 31976 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 31977 mem_base = xmlMemBlocks(); 31978 reader = gen_xmlTextReaderPtr(n_reader, 0); 31979 31980 ret_val = xmlTextReaderMoveToFirstAttribute(reader); 31981 desret_int(ret_val); 31982 call_tests++; 31983 des_xmlTextReaderPtr(n_reader, reader, 0); 31984 xmlResetLastError(); 31985 if (mem_base != xmlMemBlocks()) { 31986 printf("Leak of %d blocks found in xmlTextReaderMoveToFirstAttribute", 31987 xmlMemBlocks() - mem_base); 31988 test_ret++; 31989 printf(" %d", n_reader); 31990 printf("\n"); 31991 } 31992 } 31993 function_tests++; 31994 #endif 31995 31996 return(test_ret); 31997 } 31998 31999 32000 static int 32001 test_xmlTextReaderMoveToNextAttribute(void) { 32002 int test_ret = 0; 32003 32004 #if defined(LIBXML_READER_ENABLED) 32005 int mem_base; 32006 int ret_val; 32007 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32008 int n_reader; 32009 32010 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32011 mem_base = xmlMemBlocks(); 32012 reader = gen_xmlTextReaderPtr(n_reader, 0); 32013 32014 ret_val = xmlTextReaderMoveToNextAttribute(reader); 32015 desret_int(ret_val); 32016 call_tests++; 32017 des_xmlTextReaderPtr(n_reader, reader, 0); 32018 xmlResetLastError(); 32019 if (mem_base != xmlMemBlocks()) { 32020 printf("Leak of %d blocks found in xmlTextReaderMoveToNextAttribute", 32021 xmlMemBlocks() - mem_base); 32022 test_ret++; 32023 printf(" %d", n_reader); 32024 printf("\n"); 32025 } 32026 } 32027 function_tests++; 32028 #endif 32029 32030 return(test_ret); 32031 } 32032 32033 32034 static int 32035 test_xmlTextReaderName(void) { 32036 int test_ret = 0; 32037 32038 #if defined(LIBXML_READER_ENABLED) 32039 int mem_base; 32040 xmlChar * ret_val; 32041 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32042 int n_reader; 32043 32044 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32045 mem_base = xmlMemBlocks(); 32046 reader = gen_xmlTextReaderPtr(n_reader, 0); 32047 32048 ret_val = xmlTextReaderName(reader); 32049 desret_xmlChar_ptr(ret_val); 32050 call_tests++; 32051 des_xmlTextReaderPtr(n_reader, reader, 0); 32052 xmlResetLastError(); 32053 if (mem_base != xmlMemBlocks()) { 32054 printf("Leak of %d blocks found in xmlTextReaderName", 32055 xmlMemBlocks() - mem_base); 32056 test_ret++; 32057 printf(" %d", n_reader); 32058 printf("\n"); 32059 } 32060 } 32061 function_tests++; 32062 #endif 32063 32064 return(test_ret); 32065 } 32066 32067 32068 static int 32069 test_xmlTextReaderNamespaceUri(void) { 32070 int test_ret = 0; 32071 32072 #if defined(LIBXML_READER_ENABLED) 32073 int mem_base; 32074 xmlChar * ret_val; 32075 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32076 int n_reader; 32077 32078 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32079 mem_base = xmlMemBlocks(); 32080 reader = gen_xmlTextReaderPtr(n_reader, 0); 32081 32082 ret_val = xmlTextReaderNamespaceUri(reader); 32083 desret_xmlChar_ptr(ret_val); 32084 call_tests++; 32085 des_xmlTextReaderPtr(n_reader, reader, 0); 32086 xmlResetLastError(); 32087 if (mem_base != xmlMemBlocks()) { 32088 printf("Leak of %d blocks found in xmlTextReaderNamespaceUri", 32089 xmlMemBlocks() - mem_base); 32090 test_ret++; 32091 printf(" %d", n_reader); 32092 printf("\n"); 32093 } 32094 } 32095 function_tests++; 32096 #endif 32097 32098 return(test_ret); 32099 } 32100 32101 32102 static int 32103 test_xmlTextReaderNext(void) { 32104 int test_ret = 0; 32105 32106 #if defined(LIBXML_READER_ENABLED) 32107 int mem_base; 32108 int ret_val; 32109 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32110 int n_reader; 32111 32112 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32113 mem_base = xmlMemBlocks(); 32114 reader = gen_xmlTextReaderPtr(n_reader, 0); 32115 32116 ret_val = xmlTextReaderNext(reader); 32117 desret_int(ret_val); 32118 call_tests++; 32119 des_xmlTextReaderPtr(n_reader, reader, 0); 32120 xmlResetLastError(); 32121 if (mem_base != xmlMemBlocks()) { 32122 printf("Leak of %d blocks found in xmlTextReaderNext", 32123 xmlMemBlocks() - mem_base); 32124 test_ret++; 32125 printf(" %d", n_reader); 32126 printf("\n"); 32127 } 32128 } 32129 function_tests++; 32130 #endif 32131 32132 return(test_ret); 32133 } 32134 32135 32136 static int 32137 test_xmlTextReaderNextSibling(void) { 32138 int test_ret = 0; 32139 32140 #if defined(LIBXML_READER_ENABLED) 32141 int mem_base; 32142 int ret_val; 32143 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32144 int n_reader; 32145 32146 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32147 mem_base = xmlMemBlocks(); 32148 reader = gen_xmlTextReaderPtr(n_reader, 0); 32149 32150 ret_val = xmlTextReaderNextSibling(reader); 32151 desret_int(ret_val); 32152 call_tests++; 32153 des_xmlTextReaderPtr(n_reader, reader, 0); 32154 xmlResetLastError(); 32155 if (mem_base != xmlMemBlocks()) { 32156 printf("Leak of %d blocks found in xmlTextReaderNextSibling", 32157 xmlMemBlocks() - mem_base); 32158 test_ret++; 32159 printf(" %d", n_reader); 32160 printf("\n"); 32161 } 32162 } 32163 function_tests++; 32164 #endif 32165 32166 return(test_ret); 32167 } 32168 32169 32170 static int 32171 test_xmlTextReaderNodeType(void) { 32172 int test_ret = 0; 32173 32174 #if defined(LIBXML_READER_ENABLED) 32175 int mem_base; 32176 int ret_val; 32177 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32178 int n_reader; 32179 32180 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32181 mem_base = xmlMemBlocks(); 32182 reader = gen_xmlTextReaderPtr(n_reader, 0); 32183 32184 ret_val = xmlTextReaderNodeType(reader); 32185 desret_int(ret_val); 32186 call_tests++; 32187 des_xmlTextReaderPtr(n_reader, reader, 0); 32188 xmlResetLastError(); 32189 if (mem_base != xmlMemBlocks()) { 32190 printf("Leak of %d blocks found in xmlTextReaderNodeType", 32191 xmlMemBlocks() - mem_base); 32192 test_ret++; 32193 printf(" %d", n_reader); 32194 printf("\n"); 32195 } 32196 } 32197 function_tests++; 32198 #endif 32199 32200 return(test_ret); 32201 } 32202 32203 32204 static int 32205 test_xmlTextReaderNormalization(void) { 32206 int test_ret = 0; 32207 32208 #if defined(LIBXML_READER_ENABLED) 32209 int mem_base; 32210 int ret_val; 32211 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32212 int n_reader; 32213 32214 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32215 mem_base = xmlMemBlocks(); 32216 reader = gen_xmlTextReaderPtr(n_reader, 0); 32217 32218 ret_val = xmlTextReaderNormalization(reader); 32219 desret_int(ret_val); 32220 call_tests++; 32221 des_xmlTextReaderPtr(n_reader, reader, 0); 32222 xmlResetLastError(); 32223 if (mem_base != xmlMemBlocks()) { 32224 printf("Leak of %d blocks found in xmlTextReaderNormalization", 32225 xmlMemBlocks() - mem_base); 32226 test_ret++; 32227 printf(" %d", n_reader); 32228 printf("\n"); 32229 } 32230 } 32231 function_tests++; 32232 #endif 32233 32234 return(test_ret); 32235 } 32236 32237 32238 static int 32239 test_xmlTextReaderPrefix(void) { 32240 int test_ret = 0; 32241 32242 #if defined(LIBXML_READER_ENABLED) 32243 int mem_base; 32244 xmlChar * ret_val; 32245 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32246 int n_reader; 32247 32248 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32249 mem_base = xmlMemBlocks(); 32250 reader = gen_xmlTextReaderPtr(n_reader, 0); 32251 32252 ret_val = xmlTextReaderPrefix(reader); 32253 desret_xmlChar_ptr(ret_val); 32254 call_tests++; 32255 des_xmlTextReaderPtr(n_reader, reader, 0); 32256 xmlResetLastError(); 32257 if (mem_base != xmlMemBlocks()) { 32258 printf("Leak of %d blocks found in xmlTextReaderPrefix", 32259 xmlMemBlocks() - mem_base); 32260 test_ret++; 32261 printf(" %d", n_reader); 32262 printf("\n"); 32263 } 32264 } 32265 function_tests++; 32266 #endif 32267 32268 return(test_ret); 32269 } 32270 32271 32272 static int 32273 test_xmlTextReaderPreserve(void) { 32274 int test_ret = 0; 32275 32276 #if defined(LIBXML_READER_ENABLED) 32277 int mem_base; 32278 xmlNodePtr ret_val; 32279 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32280 int n_reader; 32281 32282 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32283 mem_base = xmlMemBlocks(); 32284 reader = gen_xmlTextReaderPtr(n_reader, 0); 32285 32286 ret_val = xmlTextReaderPreserve(reader); 32287 desret_xmlNodePtr(ret_val); 32288 call_tests++; 32289 des_xmlTextReaderPtr(n_reader, reader, 0); 32290 xmlResetLastError(); 32291 if (mem_base != xmlMemBlocks()) { 32292 printf("Leak of %d blocks found in xmlTextReaderPreserve", 32293 xmlMemBlocks() - mem_base); 32294 test_ret++; 32295 printf(" %d", n_reader); 32296 printf("\n"); 32297 } 32298 } 32299 function_tests++; 32300 #endif 32301 32302 return(test_ret); 32303 } 32304 32305 32306 static int 32307 test_xmlTextReaderPreservePattern(void) { 32308 int test_ret = 0; 32309 32310 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_PATTERN_ENABLED) 32311 #ifdef LIBXML_PATTERN_ENABLED 32312 int mem_base; 32313 int ret_val; 32314 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32315 int n_reader; 32316 xmlChar * pattern; /* an XPath subset pattern */ 32317 int n_pattern; 32318 xmlChar ** namespaces; /* the prefix definitions, array of [URI, prefix] or NULL */ 32319 int n_namespaces; 32320 32321 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32322 for (n_pattern = 0;n_pattern < gen_nb_const_xmlChar_ptr;n_pattern++) { 32323 for (n_namespaces = 0;n_namespaces < gen_nb_const_xmlChar_ptr_ptr;n_namespaces++) { 32324 mem_base = xmlMemBlocks(); 32325 reader = gen_xmlTextReaderPtr(n_reader, 0); 32326 pattern = gen_const_xmlChar_ptr(n_pattern, 1); 32327 namespaces = gen_const_xmlChar_ptr_ptr(n_namespaces, 2); 32328 32329 ret_val = xmlTextReaderPreservePattern(reader, (const xmlChar *)pattern, (const xmlChar **)namespaces); 32330 desret_int(ret_val); 32331 call_tests++; 32332 des_xmlTextReaderPtr(n_reader, reader, 0); 32333 des_const_xmlChar_ptr(n_pattern, (const xmlChar *)pattern, 1); 32334 des_const_xmlChar_ptr_ptr(n_namespaces, (const xmlChar **)namespaces, 2); 32335 xmlResetLastError(); 32336 if (mem_base != xmlMemBlocks()) { 32337 printf("Leak of %d blocks found in xmlTextReaderPreservePattern", 32338 xmlMemBlocks() - mem_base); 32339 test_ret++; 32340 printf(" %d", n_reader); 32341 printf(" %d", n_pattern); 32342 printf(" %d", n_namespaces); 32343 printf("\n"); 32344 } 32345 } 32346 } 32347 } 32348 function_tests++; 32349 #endif 32350 #endif 32351 32352 return(test_ret); 32353 } 32354 32355 32356 static int 32357 test_xmlTextReaderQuoteChar(void) { 32358 int test_ret = 0; 32359 32360 #if defined(LIBXML_READER_ENABLED) 32361 int mem_base; 32362 int ret_val; 32363 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32364 int n_reader; 32365 32366 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32367 mem_base = xmlMemBlocks(); 32368 reader = gen_xmlTextReaderPtr(n_reader, 0); 32369 32370 ret_val = xmlTextReaderQuoteChar(reader); 32371 desret_int(ret_val); 32372 call_tests++; 32373 des_xmlTextReaderPtr(n_reader, reader, 0); 32374 xmlResetLastError(); 32375 if (mem_base != xmlMemBlocks()) { 32376 printf("Leak of %d blocks found in xmlTextReaderQuoteChar", 32377 xmlMemBlocks() - mem_base); 32378 test_ret++; 32379 printf(" %d", n_reader); 32380 printf("\n"); 32381 } 32382 } 32383 function_tests++; 32384 #endif 32385 32386 return(test_ret); 32387 } 32388 32389 32390 static int 32391 test_xmlTextReaderRead(void) { 32392 int test_ret = 0; 32393 32394 #if defined(LIBXML_READER_ENABLED) 32395 int mem_base; 32396 int ret_val; 32397 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32398 int n_reader; 32399 32400 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32401 mem_base = xmlMemBlocks(); 32402 reader = gen_xmlTextReaderPtr(n_reader, 0); 32403 32404 ret_val = xmlTextReaderRead(reader); 32405 desret_int(ret_val); 32406 call_tests++; 32407 des_xmlTextReaderPtr(n_reader, reader, 0); 32408 xmlResetLastError(); 32409 if (mem_base != xmlMemBlocks()) { 32410 printf("Leak of %d blocks found in xmlTextReaderRead", 32411 xmlMemBlocks() - mem_base); 32412 test_ret++; 32413 printf(" %d", n_reader); 32414 printf("\n"); 32415 } 32416 } 32417 function_tests++; 32418 #endif 32419 32420 return(test_ret); 32421 } 32422 32423 32424 static int 32425 test_xmlTextReaderReadAttributeValue(void) { 32426 int test_ret = 0; 32427 32428 #if defined(LIBXML_READER_ENABLED) 32429 int mem_base; 32430 int ret_val; 32431 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32432 int n_reader; 32433 32434 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32435 mem_base = xmlMemBlocks(); 32436 reader = gen_xmlTextReaderPtr(n_reader, 0); 32437 32438 ret_val = xmlTextReaderReadAttributeValue(reader); 32439 desret_int(ret_val); 32440 call_tests++; 32441 des_xmlTextReaderPtr(n_reader, reader, 0); 32442 xmlResetLastError(); 32443 if (mem_base != xmlMemBlocks()) { 32444 printf("Leak of %d blocks found in xmlTextReaderReadAttributeValue", 32445 xmlMemBlocks() - mem_base); 32446 test_ret++; 32447 printf(" %d", n_reader); 32448 printf("\n"); 32449 } 32450 } 32451 function_tests++; 32452 #endif 32453 32454 return(test_ret); 32455 } 32456 32457 32458 static int 32459 test_xmlTextReaderReadState(void) { 32460 int test_ret = 0; 32461 32462 #if defined(LIBXML_READER_ENABLED) 32463 int mem_base; 32464 int ret_val; 32465 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32466 int n_reader; 32467 32468 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32469 mem_base = xmlMemBlocks(); 32470 reader = gen_xmlTextReaderPtr(n_reader, 0); 32471 32472 ret_val = xmlTextReaderReadState(reader); 32473 desret_int(ret_val); 32474 call_tests++; 32475 des_xmlTextReaderPtr(n_reader, reader, 0); 32476 xmlResetLastError(); 32477 if (mem_base != xmlMemBlocks()) { 32478 printf("Leak of %d blocks found in xmlTextReaderReadState", 32479 xmlMemBlocks() - mem_base); 32480 test_ret++; 32481 printf(" %d", n_reader); 32482 printf("\n"); 32483 } 32484 } 32485 function_tests++; 32486 #endif 32487 32488 return(test_ret); 32489 } 32490 32491 32492 static int 32493 test_xmlTextReaderRelaxNGSetSchema(void) { 32494 int test_ret = 0; 32495 32496 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED) 32497 int mem_base; 32498 int ret_val; 32499 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32500 int n_reader; 32501 xmlRelaxNGPtr schema; /* a precompiled RelaxNG schema */ 32502 int n_schema; 32503 32504 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32505 for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) { 32506 mem_base = xmlMemBlocks(); 32507 reader = gen_xmlTextReaderPtr(n_reader, 0); 32508 schema = gen_xmlRelaxNGPtr(n_schema, 1); 32509 32510 ret_val = xmlTextReaderRelaxNGSetSchema(reader, schema); 32511 desret_int(ret_val); 32512 call_tests++; 32513 des_xmlTextReaderPtr(n_reader, reader, 0); 32514 des_xmlRelaxNGPtr(n_schema, schema, 1); 32515 xmlResetLastError(); 32516 if (mem_base != xmlMemBlocks()) { 32517 printf("Leak of %d blocks found in xmlTextReaderRelaxNGSetSchema", 32518 xmlMemBlocks() - mem_base); 32519 test_ret++; 32520 printf(" %d", n_reader); 32521 printf(" %d", n_schema); 32522 printf("\n"); 32523 } 32524 } 32525 } 32526 function_tests++; 32527 #endif 32528 32529 return(test_ret); 32530 } 32531 32532 32533 static int 32534 test_xmlTextReaderRelaxNGValidate(void) { 32535 int test_ret = 0; 32536 32537 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED) 32538 int mem_base; 32539 int ret_val; 32540 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32541 int n_reader; 32542 char * rng; /* the path to a RelaxNG schema or NULL */ 32543 int n_rng; 32544 32545 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32546 for (n_rng = 0;n_rng < gen_nb_const_char_ptr;n_rng++) { 32547 mem_base = xmlMemBlocks(); 32548 reader = gen_xmlTextReaderPtr(n_reader, 0); 32549 rng = gen_const_char_ptr(n_rng, 1); 32550 32551 ret_val = xmlTextReaderRelaxNGValidate(reader, (const char *)rng); 32552 desret_int(ret_val); 32553 call_tests++; 32554 des_xmlTextReaderPtr(n_reader, reader, 0); 32555 des_const_char_ptr(n_rng, (const char *)rng, 1); 32556 xmlResetLastError(); 32557 if (mem_base != xmlMemBlocks()) { 32558 printf("Leak of %d blocks found in xmlTextReaderRelaxNGValidate", 32559 xmlMemBlocks() - mem_base); 32560 test_ret++; 32561 printf(" %d", n_reader); 32562 printf(" %d", n_rng); 32563 printf("\n"); 32564 } 32565 } 32566 } 32567 function_tests++; 32568 #endif 32569 32570 return(test_ret); 32571 } 32572 32573 32574 static int 32575 test_xmlTextReaderRelaxNGValidateCtxt(void) { 32576 int test_ret = 0; 32577 32578 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED) 32579 int mem_base; 32580 int ret_val; 32581 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32582 int n_reader; 32583 xmlRelaxNGValidCtxtPtr ctxt; /* the RelaxNG schema validation context or NULL */ 32584 int n_ctxt; 32585 int options; /* options (not used yet) */ 32586 int n_options; 32587 32588 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32589 for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) { 32590 for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) { 32591 mem_base = xmlMemBlocks(); 32592 reader = gen_xmlTextReaderPtr(n_reader, 0); 32593 ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 1); 32594 options = gen_parseroptions(n_options, 2); 32595 32596 ret_val = xmlTextReaderRelaxNGValidateCtxt(reader, ctxt, options); 32597 desret_int(ret_val); 32598 call_tests++; 32599 des_xmlTextReaderPtr(n_reader, reader, 0); 32600 des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 1); 32601 des_parseroptions(n_options, options, 2); 32602 xmlResetLastError(); 32603 if (mem_base != xmlMemBlocks()) { 32604 printf("Leak of %d blocks found in xmlTextReaderRelaxNGValidateCtxt", 32605 xmlMemBlocks() - mem_base); 32606 test_ret++; 32607 printf(" %d", n_reader); 32608 printf(" %d", n_ctxt); 32609 printf(" %d", n_options); 32610 printf("\n"); 32611 } 32612 } 32613 } 32614 } 32615 function_tests++; 32616 #endif 32617 32618 return(test_ret); 32619 } 32620 32621 32622 static int 32623 test_xmlTextReaderSchemaValidate(void) { 32624 int test_ret = 0; 32625 32626 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED) 32627 int ret_val; 32628 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32629 int n_reader; 32630 char * xsd; /* the path to a W3C XSD schema or NULL */ 32631 int n_xsd; 32632 32633 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32634 for (n_xsd = 0;n_xsd < gen_nb_const_char_ptr;n_xsd++) { 32635 reader = gen_xmlTextReaderPtr(n_reader, 0); 32636 xsd = gen_const_char_ptr(n_xsd, 1); 32637 32638 ret_val = xmlTextReaderSchemaValidate(reader, (const char *)xsd); 32639 desret_int(ret_val); 32640 call_tests++; 32641 des_xmlTextReaderPtr(n_reader, reader, 0); 32642 des_const_char_ptr(n_xsd, (const char *)xsd, 1); 32643 xmlResetLastError(); 32644 } 32645 } 32646 function_tests++; 32647 #endif 32648 32649 return(test_ret); 32650 } 32651 32652 32653 static int 32654 test_xmlTextReaderSchemaValidateCtxt(void) { 32655 int test_ret = 0; 32656 32657 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED) 32658 int mem_base; 32659 int ret_val; 32660 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32661 int n_reader; 32662 xmlSchemaValidCtxtPtr ctxt; /* the XML Schema validation context or NULL */ 32663 int n_ctxt; 32664 int options; /* options (not used yet) */ 32665 int n_options; 32666 32667 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32668 for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) { 32669 for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) { 32670 mem_base = xmlMemBlocks(); 32671 reader = gen_xmlTextReaderPtr(n_reader, 0); 32672 ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 1); 32673 options = gen_parseroptions(n_options, 2); 32674 32675 ret_val = xmlTextReaderSchemaValidateCtxt(reader, ctxt, options); 32676 desret_int(ret_val); 32677 call_tests++; 32678 des_xmlTextReaderPtr(n_reader, reader, 0); 32679 des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 1); 32680 des_parseroptions(n_options, options, 2); 32681 xmlResetLastError(); 32682 if (mem_base != xmlMemBlocks()) { 32683 printf("Leak of %d blocks found in xmlTextReaderSchemaValidateCtxt", 32684 xmlMemBlocks() - mem_base); 32685 test_ret++; 32686 printf(" %d", n_reader); 32687 printf(" %d", n_ctxt); 32688 printf(" %d", n_options); 32689 printf("\n"); 32690 } 32691 } 32692 } 32693 } 32694 function_tests++; 32695 #endif 32696 32697 return(test_ret); 32698 } 32699 32700 32701 static int 32702 test_xmlTextReaderSetErrorHandler(void) { 32703 int test_ret = 0; 32704 32705 32706 /* missing type support */ 32707 return(test_ret); 32708 } 32709 32710 32711 static int 32712 test_xmlTextReaderSetParserProp(void) { 32713 int test_ret = 0; 32714 32715 #if defined(LIBXML_READER_ENABLED) 32716 int mem_base; 32717 int ret_val; 32718 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32719 int n_reader; 32720 int prop; /* the xmlParserProperties to set */ 32721 int n_prop; 32722 int value; /* usually 0 or 1 to (de)activate it */ 32723 int n_value; 32724 32725 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32726 for (n_prop = 0;n_prop < gen_nb_int;n_prop++) { 32727 for (n_value = 0;n_value < gen_nb_int;n_value++) { 32728 mem_base = xmlMemBlocks(); 32729 reader = gen_xmlTextReaderPtr(n_reader, 0); 32730 prop = gen_int(n_prop, 1); 32731 value = gen_int(n_value, 2); 32732 32733 ret_val = xmlTextReaderSetParserProp(reader, prop, value); 32734 desret_int(ret_val); 32735 call_tests++; 32736 des_xmlTextReaderPtr(n_reader, reader, 0); 32737 des_int(n_prop, prop, 1); 32738 des_int(n_value, value, 2); 32739 xmlResetLastError(); 32740 if (mem_base != xmlMemBlocks()) { 32741 printf("Leak of %d blocks found in xmlTextReaderSetParserProp", 32742 xmlMemBlocks() - mem_base); 32743 test_ret++; 32744 printf(" %d", n_reader); 32745 printf(" %d", n_prop); 32746 printf(" %d", n_value); 32747 printf("\n"); 32748 } 32749 } 32750 } 32751 } 32752 function_tests++; 32753 #endif 32754 32755 return(test_ret); 32756 } 32757 32758 32759 static int 32760 test_xmlTextReaderSetSchema(void) { 32761 int test_ret = 0; 32762 32763 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED) 32764 int mem_base; 32765 int ret_val; 32766 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32767 int n_reader; 32768 xmlSchemaPtr schema; /* a precompiled Schema schema */ 32769 int n_schema; 32770 32771 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32772 for (n_schema = 0;n_schema < gen_nb_xmlSchemaPtr;n_schema++) { 32773 mem_base = xmlMemBlocks(); 32774 reader = gen_xmlTextReaderPtr(n_reader, 0); 32775 schema = gen_xmlSchemaPtr(n_schema, 1); 32776 32777 ret_val = xmlTextReaderSetSchema(reader, schema); 32778 desret_int(ret_val); 32779 call_tests++; 32780 des_xmlTextReaderPtr(n_reader, reader, 0); 32781 des_xmlSchemaPtr(n_schema, schema, 1); 32782 xmlResetLastError(); 32783 if (mem_base != xmlMemBlocks()) { 32784 printf("Leak of %d blocks found in xmlTextReaderSetSchema", 32785 xmlMemBlocks() - mem_base); 32786 test_ret++; 32787 printf(" %d", n_reader); 32788 printf(" %d", n_schema); 32789 printf("\n"); 32790 } 32791 } 32792 } 32793 function_tests++; 32794 #endif 32795 32796 return(test_ret); 32797 } 32798 32799 32800 static int 32801 test_xmlTextReaderSetStructuredErrorHandler(void) { 32802 int test_ret = 0; 32803 32804 32805 /* missing type support */ 32806 return(test_ret); 32807 } 32808 32809 32810 static int 32811 test_xmlTextReaderSetup(void) { 32812 int test_ret = 0; 32813 32814 #if defined(LIBXML_READER_ENABLED) 32815 int mem_base; 32816 int ret_val; 32817 xmlTextReaderPtr reader; /* an XML reader */ 32818 int n_reader; 32819 xmlParserInputBufferPtr input; /* xmlParserInputBufferPtr used to feed the reader, will be destroyed with it. */ 32820 int n_input; 32821 const char * URL; /* the base URL to use for the document */ 32822 int n_URL; 32823 char * encoding; /* the document encoding, or NULL */ 32824 int n_encoding; 32825 int options; /* a combination of xmlParserOption */ 32826 int n_options; 32827 32828 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32829 for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) { 32830 for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) { 32831 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 32832 for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) { 32833 mem_base = xmlMemBlocks(); 32834 reader = gen_xmlTextReaderPtr(n_reader, 0); 32835 input = gen_xmlParserInputBufferPtr(n_input, 1); 32836 URL = gen_filepath(n_URL, 2); 32837 encoding = gen_const_char_ptr(n_encoding, 3); 32838 options = gen_parseroptions(n_options, 4); 32839 32840 ret_val = xmlTextReaderSetup(reader, input, URL, (const char *)encoding, options); 32841 desret_int(ret_val); 32842 call_tests++; 32843 des_xmlTextReaderPtr(n_reader, reader, 0); 32844 des_filepath(n_URL, URL, 2); 32845 des_const_char_ptr(n_encoding, (const char *)encoding, 3); 32846 des_parseroptions(n_options, options, 4); 32847 xmlResetLastError(); 32848 if (mem_base != xmlMemBlocks()) { 32849 printf("Leak of %d blocks found in xmlTextReaderSetup", 32850 xmlMemBlocks() - mem_base); 32851 test_ret++; 32852 printf(" %d", n_reader); 32853 printf(" %d", n_input); 32854 printf(" %d", n_URL); 32855 printf(" %d", n_encoding); 32856 printf(" %d", n_options); 32857 printf("\n"); 32858 } 32859 } 32860 } 32861 } 32862 } 32863 } 32864 function_tests++; 32865 #endif 32866 32867 return(test_ret); 32868 } 32869 32870 32871 static int 32872 test_xmlTextReaderStandalone(void) { 32873 int test_ret = 0; 32874 32875 #if defined(LIBXML_READER_ENABLED) 32876 int mem_base; 32877 int ret_val; 32878 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32879 int n_reader; 32880 32881 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32882 mem_base = xmlMemBlocks(); 32883 reader = gen_xmlTextReaderPtr(n_reader, 0); 32884 32885 ret_val = xmlTextReaderStandalone(reader); 32886 desret_int(ret_val); 32887 call_tests++; 32888 des_xmlTextReaderPtr(n_reader, reader, 0); 32889 xmlResetLastError(); 32890 if (mem_base != xmlMemBlocks()) { 32891 printf("Leak of %d blocks found in xmlTextReaderStandalone", 32892 xmlMemBlocks() - mem_base); 32893 test_ret++; 32894 printf(" %d", n_reader); 32895 printf("\n"); 32896 } 32897 } 32898 function_tests++; 32899 #endif 32900 32901 return(test_ret); 32902 } 32903 32904 32905 static int 32906 test_xmlTextReaderValue(void) { 32907 int test_ret = 0; 32908 32909 #if defined(LIBXML_READER_ENABLED) 32910 int mem_base; 32911 xmlChar * ret_val; 32912 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32913 int n_reader; 32914 32915 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32916 mem_base = xmlMemBlocks(); 32917 reader = gen_xmlTextReaderPtr(n_reader, 0); 32918 32919 ret_val = xmlTextReaderValue(reader); 32920 desret_xmlChar_ptr(ret_val); 32921 call_tests++; 32922 des_xmlTextReaderPtr(n_reader, reader, 0); 32923 xmlResetLastError(); 32924 if (mem_base != xmlMemBlocks()) { 32925 printf("Leak of %d blocks found in xmlTextReaderValue", 32926 xmlMemBlocks() - mem_base); 32927 test_ret++; 32928 printf(" %d", n_reader); 32929 printf("\n"); 32930 } 32931 } 32932 function_tests++; 32933 #endif 32934 32935 return(test_ret); 32936 } 32937 32938 32939 static int 32940 test_xmlTextReaderXmlLang(void) { 32941 int test_ret = 0; 32942 32943 #if defined(LIBXML_READER_ENABLED) 32944 int mem_base; 32945 xmlChar * ret_val; 32946 xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */ 32947 int n_reader; 32948 32949 for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) { 32950 mem_base = xmlMemBlocks(); 32951 reader = gen_xmlTextReaderPtr(n_reader, 0); 32952 32953 ret_val = xmlTextReaderXmlLang(reader); 32954 desret_xmlChar_ptr(ret_val); 32955 call_tests++; 32956 des_xmlTextReaderPtr(n_reader, reader, 0); 32957 xmlResetLastError(); 32958 if (mem_base != xmlMemBlocks()) { 32959 printf("Leak of %d blocks found in xmlTextReaderXmlLang", 32960 xmlMemBlocks() - mem_base); 32961 test_ret++; 32962 printf(" %d", n_reader); 32963 printf("\n"); 32964 } 32965 } 32966 function_tests++; 32967 #endif 32968 32969 return(test_ret); 32970 } 32971 32972 static int 32973 test_xmlreader(void) { 32974 int test_ret = 0; 32975 32976 if (quiet == 0) printf("Testing xmlreader : 76 of 86 functions ...\n"); 32977 test_ret += test_xmlNewTextReader(); 32978 test_ret += test_xmlNewTextReaderFilename(); 32979 test_ret += test_xmlReaderForDoc(); 32980 test_ret += test_xmlReaderForFile(); 32981 test_ret += test_xmlReaderForMemory(); 32982 test_ret += test_xmlReaderNewDoc(); 32983 test_ret += test_xmlReaderNewFile(); 32984 test_ret += test_xmlReaderNewMemory(); 32985 test_ret += test_xmlReaderNewWalker(); 32986 test_ret += test_xmlReaderWalker(); 32987 test_ret += test_xmlTextReaderAttributeCount(); 32988 test_ret += test_xmlTextReaderBaseUri(); 32989 test_ret += test_xmlTextReaderByteConsumed(); 32990 test_ret += test_xmlTextReaderClose(); 32991 test_ret += test_xmlTextReaderConstBaseUri(); 32992 test_ret += test_xmlTextReaderConstEncoding(); 32993 test_ret += test_xmlTextReaderConstLocalName(); 32994 test_ret += test_xmlTextReaderConstName(); 32995 test_ret += test_xmlTextReaderConstNamespaceUri(); 32996 test_ret += test_xmlTextReaderConstPrefix(); 32997 test_ret += test_xmlTextReaderConstString(); 32998 test_ret += test_xmlTextReaderConstValue(); 32999 test_ret += test_xmlTextReaderConstXmlLang(); 33000 test_ret += test_xmlTextReaderConstXmlVersion(); 33001 test_ret += test_xmlTextReaderCurrentDoc(); 33002 test_ret += test_xmlTextReaderCurrentNode(); 33003 test_ret += test_xmlTextReaderDepth(); 33004 test_ret += test_xmlTextReaderExpand(); 33005 test_ret += test_xmlTextReaderGetAttribute(); 33006 test_ret += test_xmlTextReaderGetAttributeNo(); 33007 test_ret += test_xmlTextReaderGetAttributeNs(); 33008 test_ret += test_xmlTextReaderGetErrorHandler(); 33009 test_ret += test_xmlTextReaderGetParserColumnNumber(); 33010 test_ret += test_xmlTextReaderGetParserLineNumber(); 33011 test_ret += test_xmlTextReaderGetParserProp(); 33012 test_ret += test_xmlTextReaderGetRemainder(); 33013 test_ret += test_xmlTextReaderHasAttributes(); 33014 test_ret += test_xmlTextReaderHasValue(); 33015 test_ret += test_xmlTextReaderIsDefault(); 33016 test_ret += test_xmlTextReaderIsEmptyElement(); 33017 test_ret += test_xmlTextReaderIsNamespaceDecl(); 33018 test_ret += test_xmlTextReaderIsValid(); 33019 test_ret += test_xmlTextReaderLocalName(); 33020 test_ret += test_xmlTextReaderLocatorBaseURI(); 33021 test_ret += test_xmlTextReaderLocatorLineNumber(); 33022 test_ret += test_xmlTextReaderLookupNamespace(); 33023 test_ret += test_xmlTextReaderMoveToAttribute(); 33024 test_ret += test_xmlTextReaderMoveToAttributeNo(); 33025 test_ret += test_xmlTextReaderMoveToAttributeNs(); 33026 test_ret += test_xmlTextReaderMoveToElement(); 33027 test_ret += test_xmlTextReaderMoveToFirstAttribute(); 33028 test_ret += test_xmlTextReaderMoveToNextAttribute(); 33029 test_ret += test_xmlTextReaderName(); 33030 test_ret += test_xmlTextReaderNamespaceUri(); 33031 test_ret += test_xmlTextReaderNext(); 33032 test_ret += test_xmlTextReaderNextSibling(); 33033 test_ret += test_xmlTextReaderNodeType(); 33034 test_ret += test_xmlTextReaderNormalization(); 33035 test_ret += test_xmlTextReaderPrefix(); 33036 test_ret += test_xmlTextReaderPreserve(); 33037 test_ret += test_xmlTextReaderPreservePattern(); 33038 test_ret += test_xmlTextReaderQuoteChar(); 33039 test_ret += test_xmlTextReaderRead(); 33040 test_ret += test_xmlTextReaderReadAttributeValue(); 33041 test_ret += test_xmlTextReaderReadState(); 33042 test_ret += test_xmlTextReaderRelaxNGSetSchema(); 33043 test_ret += test_xmlTextReaderRelaxNGValidate(); 33044 test_ret += test_xmlTextReaderRelaxNGValidateCtxt(); 33045 test_ret += test_xmlTextReaderSchemaValidate(); 33046 test_ret += test_xmlTextReaderSchemaValidateCtxt(); 33047 test_ret += test_xmlTextReaderSetErrorHandler(); 33048 test_ret += test_xmlTextReaderSetParserProp(); 33049 test_ret += test_xmlTextReaderSetSchema(); 33050 test_ret += test_xmlTextReaderSetStructuredErrorHandler(); 33051 test_ret += test_xmlTextReaderSetup(); 33052 test_ret += test_xmlTextReaderStandalone(); 33053 test_ret += test_xmlTextReaderValue(); 33054 test_ret += test_xmlTextReaderXmlLang(); 33055 33056 if (test_ret != 0) 33057 printf("Module xmlreader: %d errors\n", test_ret); 33058 return(test_ret); 33059 } 33060 33061 static int 33062 test_xmlExpCtxtNbCons(void) { 33063 int test_ret = 0; 33064 33065 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED) 33066 int mem_base; 33067 int ret_val; 33068 xmlExpCtxtPtr ctxt; /* an expression context */ 33069 int n_ctxt; 33070 33071 for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) { 33072 mem_base = xmlMemBlocks(); 33073 ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0); 33074 33075 ret_val = xmlExpCtxtNbCons(ctxt); 33076 desret_int(ret_val); 33077 call_tests++; 33078 des_xmlExpCtxtPtr(n_ctxt, ctxt, 0); 33079 xmlResetLastError(); 33080 if (mem_base != xmlMemBlocks()) { 33081 printf("Leak of %d blocks found in xmlExpCtxtNbCons", 33082 xmlMemBlocks() - mem_base); 33083 test_ret++; 33084 printf(" %d", n_ctxt); 33085 printf("\n"); 33086 } 33087 } 33088 function_tests++; 33089 #endif 33090 33091 return(test_ret); 33092 } 33093 33094 33095 static int 33096 test_xmlExpCtxtNbNodes(void) { 33097 int test_ret = 0; 33098 33099 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED) 33100 int mem_base; 33101 int ret_val; 33102 xmlExpCtxtPtr ctxt; /* an expression context */ 33103 int n_ctxt; 33104 33105 for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) { 33106 mem_base = xmlMemBlocks(); 33107 ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0); 33108 33109 ret_val = xmlExpCtxtNbNodes(ctxt); 33110 desret_int(ret_val); 33111 call_tests++; 33112 des_xmlExpCtxtPtr(n_ctxt, ctxt, 0); 33113 xmlResetLastError(); 33114 if (mem_base != xmlMemBlocks()) { 33115 printf("Leak of %d blocks found in xmlExpCtxtNbNodes", 33116 xmlMemBlocks() - mem_base); 33117 test_ret++; 33118 printf(" %d", n_ctxt); 33119 printf("\n"); 33120 } 33121 } 33122 function_tests++; 33123 #endif 33124 33125 return(test_ret); 33126 } 33127 33128 33129 static int 33130 test_xmlExpDump(void) { 33131 int test_ret = 0; 33132 33133 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED) 33134 int mem_base; 33135 xmlBufferPtr buf; /* a buffer to receive the output */ 33136 int n_buf; 33137 xmlExpNodePtr expr; /* the compiled expression */ 33138 int n_expr; 33139 33140 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 33141 for (n_expr = 0;n_expr < gen_nb_xmlExpNodePtr;n_expr++) { 33142 mem_base = xmlMemBlocks(); 33143 buf = gen_xmlBufferPtr(n_buf, 0); 33144 expr = gen_xmlExpNodePtr(n_expr, 1); 33145 33146 xmlExpDump(buf, expr); 33147 call_tests++; 33148 des_xmlBufferPtr(n_buf, buf, 0); 33149 des_xmlExpNodePtr(n_expr, expr, 1); 33150 xmlResetLastError(); 33151 if (mem_base != xmlMemBlocks()) { 33152 printf("Leak of %d blocks found in xmlExpDump", 33153 xmlMemBlocks() - mem_base); 33154 test_ret++; 33155 printf(" %d", n_buf); 33156 printf(" %d", n_expr); 33157 printf("\n"); 33158 } 33159 } 33160 } 33161 function_tests++; 33162 #endif 33163 33164 return(test_ret); 33165 } 33166 33167 33168 static int 33169 test_xmlExpExpDerive(void) { 33170 int test_ret = 0; 33171 33172 33173 /* missing type support */ 33174 return(test_ret); 33175 } 33176 33177 33178 static int 33179 test_xmlExpGetLanguage(void) { 33180 int test_ret = 0; 33181 33182 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED) 33183 int mem_base; 33184 int ret_val; 33185 xmlExpCtxtPtr ctxt; /* the expression context */ 33186 int n_ctxt; 33187 xmlExpNodePtr exp; /* the expression */ 33188 int n_exp; 33189 xmlChar ** langList; /* where to store the tokens */ 33190 int n_langList; 33191 int len; /* the allocated length of @list */ 33192 int n_len; 33193 33194 for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) { 33195 for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) { 33196 for (n_langList = 0;n_langList < gen_nb_const_xmlChar_ptr_ptr;n_langList++) { 33197 for (n_len = 0;n_len < gen_nb_int;n_len++) { 33198 mem_base = xmlMemBlocks(); 33199 ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0); 33200 exp = gen_xmlExpNodePtr(n_exp, 1); 33201 langList = gen_const_xmlChar_ptr_ptr(n_langList, 2); 33202 len = gen_int(n_len, 3); 33203 33204 ret_val = xmlExpGetLanguage(ctxt, exp, (const xmlChar **)langList, len); 33205 desret_int(ret_val); 33206 call_tests++; 33207 des_xmlExpCtxtPtr(n_ctxt, ctxt, 0); 33208 des_xmlExpNodePtr(n_exp, exp, 1); 33209 des_const_xmlChar_ptr_ptr(n_langList, (const xmlChar **)langList, 2); 33210 des_int(n_len, len, 3); 33211 xmlResetLastError(); 33212 if (mem_base != xmlMemBlocks()) { 33213 printf("Leak of %d blocks found in xmlExpGetLanguage", 33214 xmlMemBlocks() - mem_base); 33215 test_ret++; 33216 printf(" %d", n_ctxt); 33217 printf(" %d", n_exp); 33218 printf(" %d", n_langList); 33219 printf(" %d", n_len); 33220 printf("\n"); 33221 } 33222 } 33223 } 33224 } 33225 } 33226 function_tests++; 33227 #endif 33228 33229 return(test_ret); 33230 } 33231 33232 33233 static int 33234 test_xmlExpGetStart(void) { 33235 int test_ret = 0; 33236 33237 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED) 33238 int mem_base; 33239 int ret_val; 33240 xmlExpCtxtPtr ctxt; /* the expression context */ 33241 int n_ctxt; 33242 xmlExpNodePtr exp; /* the expression */ 33243 int n_exp; 33244 xmlChar ** tokList; /* where to store the tokens */ 33245 int n_tokList; 33246 int len; /* the allocated length of @list */ 33247 int n_len; 33248 33249 for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) { 33250 for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) { 33251 for (n_tokList = 0;n_tokList < gen_nb_const_xmlChar_ptr_ptr;n_tokList++) { 33252 for (n_len = 0;n_len < gen_nb_int;n_len++) { 33253 mem_base = xmlMemBlocks(); 33254 ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0); 33255 exp = gen_xmlExpNodePtr(n_exp, 1); 33256 tokList = gen_const_xmlChar_ptr_ptr(n_tokList, 2); 33257 len = gen_int(n_len, 3); 33258 33259 ret_val = xmlExpGetStart(ctxt, exp, (const xmlChar **)tokList, len); 33260 desret_int(ret_val); 33261 call_tests++; 33262 des_xmlExpCtxtPtr(n_ctxt, ctxt, 0); 33263 des_xmlExpNodePtr(n_exp, exp, 1); 33264 des_const_xmlChar_ptr_ptr(n_tokList, (const xmlChar **)tokList, 2); 33265 des_int(n_len, len, 3); 33266 xmlResetLastError(); 33267 if (mem_base != xmlMemBlocks()) { 33268 printf("Leak of %d blocks found in xmlExpGetStart", 33269 xmlMemBlocks() - mem_base); 33270 test_ret++; 33271 printf(" %d", n_ctxt); 33272 printf(" %d", n_exp); 33273 printf(" %d", n_tokList); 33274 printf(" %d", n_len); 33275 printf("\n"); 33276 } 33277 } 33278 } 33279 } 33280 } 33281 function_tests++; 33282 #endif 33283 33284 return(test_ret); 33285 } 33286 33287 33288 static int 33289 test_xmlExpIsNillable(void) { 33290 int test_ret = 0; 33291 33292 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED) 33293 int mem_base; 33294 int ret_val; 33295 xmlExpNodePtr exp; /* the expression */ 33296 int n_exp; 33297 33298 for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) { 33299 mem_base = xmlMemBlocks(); 33300 exp = gen_xmlExpNodePtr(n_exp, 0); 33301 33302 ret_val = xmlExpIsNillable(exp); 33303 desret_int(ret_val); 33304 call_tests++; 33305 des_xmlExpNodePtr(n_exp, exp, 0); 33306 xmlResetLastError(); 33307 if (mem_base != xmlMemBlocks()) { 33308 printf("Leak of %d blocks found in xmlExpIsNillable", 33309 xmlMemBlocks() - mem_base); 33310 test_ret++; 33311 printf(" %d", n_exp); 33312 printf("\n"); 33313 } 33314 } 33315 function_tests++; 33316 #endif 33317 33318 return(test_ret); 33319 } 33320 33321 33322 static int 33323 test_xmlExpMaxToken(void) { 33324 int test_ret = 0; 33325 33326 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED) 33327 int mem_base; 33328 int ret_val; 33329 xmlExpNodePtr expr; /* a compiled expression */ 33330 int n_expr; 33331 33332 for (n_expr = 0;n_expr < gen_nb_xmlExpNodePtr;n_expr++) { 33333 mem_base = xmlMemBlocks(); 33334 expr = gen_xmlExpNodePtr(n_expr, 0); 33335 33336 ret_val = xmlExpMaxToken(expr); 33337 desret_int(ret_val); 33338 call_tests++; 33339 des_xmlExpNodePtr(n_expr, expr, 0); 33340 xmlResetLastError(); 33341 if (mem_base != xmlMemBlocks()) { 33342 printf("Leak of %d blocks found in xmlExpMaxToken", 33343 xmlMemBlocks() - mem_base); 33344 test_ret++; 33345 printf(" %d", n_expr); 33346 printf("\n"); 33347 } 33348 } 33349 function_tests++; 33350 #endif 33351 33352 return(test_ret); 33353 } 33354 33355 33356 static int 33357 test_xmlExpNewAtom(void) { 33358 int test_ret = 0; 33359 33360 33361 /* missing type support */ 33362 return(test_ret); 33363 } 33364 33365 33366 static int 33367 test_xmlExpNewCtxt(void) { 33368 int test_ret = 0; 33369 33370 33371 /* missing type support */ 33372 return(test_ret); 33373 } 33374 33375 33376 static int 33377 test_xmlExpNewOr(void) { 33378 int test_ret = 0; 33379 33380 33381 /* missing type support */ 33382 return(test_ret); 33383 } 33384 33385 33386 static int 33387 test_xmlExpNewRange(void) { 33388 int test_ret = 0; 33389 33390 33391 /* missing type support */ 33392 return(test_ret); 33393 } 33394 33395 33396 static int 33397 test_xmlExpNewSeq(void) { 33398 int test_ret = 0; 33399 33400 33401 /* missing type support */ 33402 return(test_ret); 33403 } 33404 33405 33406 static int 33407 test_xmlExpParse(void) { 33408 int test_ret = 0; 33409 33410 33411 /* missing type support */ 33412 return(test_ret); 33413 } 33414 33415 33416 static int 33417 test_xmlExpRef(void) { 33418 int test_ret = 0; 33419 33420 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED) 33421 int mem_base; 33422 xmlExpNodePtr exp; /* the expression */ 33423 int n_exp; 33424 33425 for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) { 33426 mem_base = xmlMemBlocks(); 33427 exp = gen_xmlExpNodePtr(n_exp, 0); 33428 33429 xmlExpRef(exp); 33430 call_tests++; 33431 des_xmlExpNodePtr(n_exp, exp, 0); 33432 xmlResetLastError(); 33433 if (mem_base != xmlMemBlocks()) { 33434 printf("Leak of %d blocks found in xmlExpRef", 33435 xmlMemBlocks() - mem_base); 33436 test_ret++; 33437 printf(" %d", n_exp); 33438 printf("\n"); 33439 } 33440 } 33441 function_tests++; 33442 #endif 33443 33444 return(test_ret); 33445 } 33446 33447 33448 static int 33449 test_xmlExpStringDerive(void) { 33450 int test_ret = 0; 33451 33452 33453 /* missing type support */ 33454 return(test_ret); 33455 } 33456 33457 33458 static int 33459 test_xmlExpSubsume(void) { 33460 int test_ret = 0; 33461 33462 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED) 33463 int mem_base; 33464 int ret_val; 33465 xmlExpCtxtPtr ctxt; /* the expressions context */ 33466 int n_ctxt; 33467 xmlExpNodePtr exp; /* the englobing expression */ 33468 int n_exp; 33469 xmlExpNodePtr sub; /* the subexpression */ 33470 int n_sub; 33471 33472 for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) { 33473 for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) { 33474 for (n_sub = 0;n_sub < gen_nb_xmlExpNodePtr;n_sub++) { 33475 mem_base = xmlMemBlocks(); 33476 ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0); 33477 exp = gen_xmlExpNodePtr(n_exp, 1); 33478 sub = gen_xmlExpNodePtr(n_sub, 2); 33479 33480 ret_val = xmlExpSubsume(ctxt, exp, sub); 33481 desret_int(ret_val); 33482 call_tests++; 33483 des_xmlExpCtxtPtr(n_ctxt, ctxt, 0); 33484 des_xmlExpNodePtr(n_exp, exp, 1); 33485 des_xmlExpNodePtr(n_sub, sub, 2); 33486 xmlResetLastError(); 33487 if (mem_base != xmlMemBlocks()) { 33488 printf("Leak of %d blocks found in xmlExpSubsume", 33489 xmlMemBlocks() - mem_base); 33490 test_ret++; 33491 printf(" %d", n_ctxt); 33492 printf(" %d", n_exp); 33493 printf(" %d", n_sub); 33494 printf("\n"); 33495 } 33496 } 33497 } 33498 } 33499 function_tests++; 33500 #endif 33501 33502 return(test_ret); 33503 } 33504 33505 #ifdef LIBXML_REGEXP_ENABLED 33506 33507 #define gen_nb_xmlRegExecCtxtPtr 1 33508 static xmlRegExecCtxtPtr gen_xmlRegExecCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 33509 return(NULL); 33510 } 33511 static void des_xmlRegExecCtxtPtr(int no ATTRIBUTE_UNUSED, xmlRegExecCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 33512 } 33513 #endif 33514 33515 33516 static int 33517 test_xmlRegExecErrInfo(void) { 33518 int test_ret = 0; 33519 33520 #if defined(LIBXML_REGEXP_ENABLED) 33521 int mem_base; 33522 int ret_val; 33523 xmlRegExecCtxtPtr exec; /* a regexp execution context generating an error */ 33524 int n_exec; 33525 xmlChar ** string; /* return value for the error string */ 33526 int n_string; 33527 int * nbval; /* pointer to the number of accepted values IN/OUT */ 33528 int n_nbval; 33529 int * nbneg; /* return number of negative transitions */ 33530 int n_nbneg; 33531 xmlChar ** values; /* pointer to the array of acceptable values */ 33532 int n_values; 33533 int * terminal; /* return value if this was a terminal state */ 33534 int n_terminal; 33535 33536 for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) { 33537 for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr_ptr;n_string++) { 33538 for (n_nbval = 0;n_nbval < gen_nb_int_ptr;n_nbval++) { 33539 for (n_nbneg = 0;n_nbneg < gen_nb_int_ptr;n_nbneg++) { 33540 for (n_values = 0;n_values < gen_nb_xmlChar_ptr_ptr;n_values++) { 33541 for (n_terminal = 0;n_terminal < gen_nb_int_ptr;n_terminal++) { 33542 mem_base = xmlMemBlocks(); 33543 exec = gen_xmlRegExecCtxtPtr(n_exec, 0); 33544 string = gen_const_xmlChar_ptr_ptr(n_string, 1); 33545 nbval = gen_int_ptr(n_nbval, 2); 33546 nbneg = gen_int_ptr(n_nbneg, 3); 33547 values = gen_xmlChar_ptr_ptr(n_values, 4); 33548 terminal = gen_int_ptr(n_terminal, 5); 33549 33550 ret_val = xmlRegExecErrInfo(exec, (const xmlChar **)string, nbval, nbneg, values, terminal); 33551 desret_int(ret_val); 33552 call_tests++; 33553 des_xmlRegExecCtxtPtr(n_exec, exec, 0); 33554 des_const_xmlChar_ptr_ptr(n_string, (const xmlChar **)string, 1); 33555 des_int_ptr(n_nbval, nbval, 2); 33556 des_int_ptr(n_nbneg, nbneg, 3); 33557 des_xmlChar_ptr_ptr(n_values, values, 4); 33558 des_int_ptr(n_terminal, terminal, 5); 33559 xmlResetLastError(); 33560 if (mem_base != xmlMemBlocks()) { 33561 printf("Leak of %d blocks found in xmlRegExecErrInfo", 33562 xmlMemBlocks() - mem_base); 33563 test_ret++; 33564 printf(" %d", n_exec); 33565 printf(" %d", n_string); 33566 printf(" %d", n_nbval); 33567 printf(" %d", n_nbneg); 33568 printf(" %d", n_values); 33569 printf(" %d", n_terminal); 33570 printf("\n"); 33571 } 33572 } 33573 } 33574 } 33575 } 33576 } 33577 } 33578 function_tests++; 33579 #endif 33580 33581 return(test_ret); 33582 } 33583 33584 33585 static int 33586 test_xmlRegExecNextValues(void) { 33587 int test_ret = 0; 33588 33589 #if defined(LIBXML_REGEXP_ENABLED) 33590 int mem_base; 33591 int ret_val; 33592 xmlRegExecCtxtPtr exec; /* a regexp execution context */ 33593 int n_exec; 33594 int * nbval; /* pointer to the number of accepted values IN/OUT */ 33595 int n_nbval; 33596 int * nbneg; /* return number of negative transitions */ 33597 int n_nbneg; 33598 xmlChar ** values; /* pointer to the array of acceptable values */ 33599 int n_values; 33600 int * terminal; /* return value if this was a terminal state */ 33601 int n_terminal; 33602 33603 for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) { 33604 for (n_nbval = 0;n_nbval < gen_nb_int_ptr;n_nbval++) { 33605 for (n_nbneg = 0;n_nbneg < gen_nb_int_ptr;n_nbneg++) { 33606 for (n_values = 0;n_values < gen_nb_xmlChar_ptr_ptr;n_values++) { 33607 for (n_terminal = 0;n_terminal < gen_nb_int_ptr;n_terminal++) { 33608 mem_base = xmlMemBlocks(); 33609 exec = gen_xmlRegExecCtxtPtr(n_exec, 0); 33610 nbval = gen_int_ptr(n_nbval, 1); 33611 nbneg = gen_int_ptr(n_nbneg, 2); 33612 values = gen_xmlChar_ptr_ptr(n_values, 3); 33613 terminal = gen_int_ptr(n_terminal, 4); 33614 33615 ret_val = xmlRegExecNextValues(exec, nbval, nbneg, values, terminal); 33616 desret_int(ret_val); 33617 call_tests++; 33618 des_xmlRegExecCtxtPtr(n_exec, exec, 0); 33619 des_int_ptr(n_nbval, nbval, 1); 33620 des_int_ptr(n_nbneg, nbneg, 2); 33621 des_xmlChar_ptr_ptr(n_values, values, 3); 33622 des_int_ptr(n_terminal, terminal, 4); 33623 xmlResetLastError(); 33624 if (mem_base != xmlMemBlocks()) { 33625 printf("Leak of %d blocks found in xmlRegExecNextValues", 33626 xmlMemBlocks() - mem_base); 33627 test_ret++; 33628 printf(" %d", n_exec); 33629 printf(" %d", n_nbval); 33630 printf(" %d", n_nbneg); 33631 printf(" %d", n_values); 33632 printf(" %d", n_terminal); 33633 printf("\n"); 33634 } 33635 } 33636 } 33637 } 33638 } 33639 } 33640 function_tests++; 33641 #endif 33642 33643 return(test_ret); 33644 } 33645 33646 33647 static int 33648 test_xmlRegExecPushString(void) { 33649 int test_ret = 0; 33650 33651 #if defined(LIBXML_REGEXP_ENABLED) 33652 int mem_base; 33653 int ret_val; 33654 xmlRegExecCtxtPtr exec; /* a regexp execution context or NULL to indicate the end */ 33655 int n_exec; 33656 xmlChar * value; /* a string token input */ 33657 int n_value; 33658 void * data; /* data associated to the token to reuse in callbacks */ 33659 int n_data; 33660 33661 for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) { 33662 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 33663 for (n_data = 0;n_data < gen_nb_userdata;n_data++) { 33664 mem_base = xmlMemBlocks(); 33665 exec = gen_xmlRegExecCtxtPtr(n_exec, 0); 33666 value = gen_const_xmlChar_ptr(n_value, 1); 33667 data = gen_userdata(n_data, 2); 33668 33669 ret_val = xmlRegExecPushString(exec, (const xmlChar *)value, data); 33670 desret_int(ret_val); 33671 call_tests++; 33672 des_xmlRegExecCtxtPtr(n_exec, exec, 0); 33673 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1); 33674 des_userdata(n_data, data, 2); 33675 xmlResetLastError(); 33676 if (mem_base != xmlMemBlocks()) { 33677 printf("Leak of %d blocks found in xmlRegExecPushString", 33678 xmlMemBlocks() - mem_base); 33679 test_ret++; 33680 printf(" %d", n_exec); 33681 printf(" %d", n_value); 33682 printf(" %d", n_data); 33683 printf("\n"); 33684 } 33685 } 33686 } 33687 } 33688 function_tests++; 33689 #endif 33690 33691 return(test_ret); 33692 } 33693 33694 33695 static int 33696 test_xmlRegExecPushString2(void) { 33697 int test_ret = 0; 33698 33699 #if defined(LIBXML_REGEXP_ENABLED) 33700 int mem_base; 33701 int ret_val; 33702 xmlRegExecCtxtPtr exec; /* a regexp execution context or NULL to indicate the end */ 33703 int n_exec; 33704 xmlChar * value; /* the first string token input */ 33705 int n_value; 33706 xmlChar * value2; /* the second string token input */ 33707 int n_value2; 33708 void * data; /* data associated to the token to reuse in callbacks */ 33709 int n_data; 33710 33711 for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) { 33712 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 33713 for (n_value2 = 0;n_value2 < gen_nb_const_xmlChar_ptr;n_value2++) { 33714 for (n_data = 0;n_data < gen_nb_userdata;n_data++) { 33715 mem_base = xmlMemBlocks(); 33716 exec = gen_xmlRegExecCtxtPtr(n_exec, 0); 33717 value = gen_const_xmlChar_ptr(n_value, 1); 33718 value2 = gen_const_xmlChar_ptr(n_value2, 2); 33719 data = gen_userdata(n_data, 3); 33720 33721 ret_val = xmlRegExecPushString2(exec, (const xmlChar *)value, (const xmlChar *)value2, data); 33722 desret_int(ret_val); 33723 call_tests++; 33724 des_xmlRegExecCtxtPtr(n_exec, exec, 0); 33725 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1); 33726 des_const_xmlChar_ptr(n_value2, (const xmlChar *)value2, 2); 33727 des_userdata(n_data, data, 3); 33728 xmlResetLastError(); 33729 if (mem_base != xmlMemBlocks()) { 33730 printf("Leak of %d blocks found in xmlRegExecPushString2", 33731 xmlMemBlocks() - mem_base); 33732 test_ret++; 33733 printf(" %d", n_exec); 33734 printf(" %d", n_value); 33735 printf(" %d", n_value2); 33736 printf(" %d", n_data); 33737 printf("\n"); 33738 } 33739 } 33740 } 33741 } 33742 } 33743 function_tests++; 33744 #endif 33745 33746 return(test_ret); 33747 } 33748 33749 #ifdef LIBXML_REGEXP_ENABLED 33750 33751 #define gen_nb_xmlRegexpPtr 1 33752 static xmlRegexpPtr gen_xmlRegexpPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 33753 return(NULL); 33754 } 33755 static void des_xmlRegexpPtr(int no ATTRIBUTE_UNUSED, xmlRegexpPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 33756 } 33757 #endif 33758 33759 33760 static int 33761 test_xmlRegNewExecCtxt(void) { 33762 int test_ret = 0; 33763 33764 33765 /* missing type support */ 33766 return(test_ret); 33767 } 33768 33769 33770 static int 33771 test_xmlRegexpCompile(void) { 33772 int test_ret = 0; 33773 33774 33775 /* missing type support */ 33776 return(test_ret); 33777 } 33778 33779 33780 static int 33781 test_xmlRegexpExec(void) { 33782 int test_ret = 0; 33783 33784 #if defined(LIBXML_REGEXP_ENABLED) 33785 int mem_base; 33786 int ret_val; 33787 xmlRegexpPtr comp; /* the compiled regular expression */ 33788 int n_comp; 33789 xmlChar * content; /* the value to check against the regular expression */ 33790 int n_content; 33791 33792 for (n_comp = 0;n_comp < gen_nb_xmlRegexpPtr;n_comp++) { 33793 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 33794 mem_base = xmlMemBlocks(); 33795 comp = gen_xmlRegexpPtr(n_comp, 0); 33796 content = gen_const_xmlChar_ptr(n_content, 1); 33797 33798 ret_val = xmlRegexpExec(comp, (const xmlChar *)content); 33799 desret_int(ret_val); 33800 call_tests++; 33801 des_xmlRegexpPtr(n_comp, comp, 0); 33802 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1); 33803 xmlResetLastError(); 33804 if (mem_base != xmlMemBlocks()) { 33805 printf("Leak of %d blocks found in xmlRegexpExec", 33806 xmlMemBlocks() - mem_base); 33807 test_ret++; 33808 printf(" %d", n_comp); 33809 printf(" %d", n_content); 33810 printf("\n"); 33811 } 33812 } 33813 } 33814 function_tests++; 33815 #endif 33816 33817 return(test_ret); 33818 } 33819 33820 33821 static int 33822 test_xmlRegexpIsDeterminist(void) { 33823 int test_ret = 0; 33824 33825 #if defined(LIBXML_REGEXP_ENABLED) 33826 int mem_base; 33827 int ret_val; 33828 xmlRegexpPtr comp; /* the compiled regular expression */ 33829 int n_comp; 33830 33831 for (n_comp = 0;n_comp < gen_nb_xmlRegexpPtr;n_comp++) { 33832 mem_base = xmlMemBlocks(); 33833 comp = gen_xmlRegexpPtr(n_comp, 0); 33834 33835 ret_val = xmlRegexpIsDeterminist(comp); 33836 desret_int(ret_val); 33837 call_tests++; 33838 des_xmlRegexpPtr(n_comp, comp, 0); 33839 xmlResetLastError(); 33840 if (mem_base != xmlMemBlocks()) { 33841 printf("Leak of %d blocks found in xmlRegexpIsDeterminist", 33842 xmlMemBlocks() - mem_base); 33843 test_ret++; 33844 printf(" %d", n_comp); 33845 printf("\n"); 33846 } 33847 } 33848 function_tests++; 33849 #endif 33850 33851 return(test_ret); 33852 } 33853 33854 33855 static int 33856 test_xmlRegexpPrint(void) { 33857 int test_ret = 0; 33858 33859 #if defined(LIBXML_REGEXP_ENABLED) 33860 int mem_base; 33861 FILE * output; /* the file for the output debug */ 33862 int n_output; 33863 xmlRegexpPtr regexp; /* the compiled regexp */ 33864 int n_regexp; 33865 33866 for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) { 33867 for (n_regexp = 0;n_regexp < gen_nb_xmlRegexpPtr;n_regexp++) { 33868 mem_base = xmlMemBlocks(); 33869 output = gen_FILE_ptr(n_output, 0); 33870 regexp = gen_xmlRegexpPtr(n_regexp, 1); 33871 33872 xmlRegexpPrint(output, regexp); 33873 call_tests++; 33874 des_FILE_ptr(n_output, output, 0); 33875 des_xmlRegexpPtr(n_regexp, regexp, 1); 33876 xmlResetLastError(); 33877 if (mem_base != xmlMemBlocks()) { 33878 printf("Leak of %d blocks found in xmlRegexpPrint", 33879 xmlMemBlocks() - mem_base); 33880 test_ret++; 33881 printf(" %d", n_output); 33882 printf(" %d", n_regexp); 33883 printf("\n"); 33884 } 33885 } 33886 } 33887 function_tests++; 33888 #endif 33889 33890 return(test_ret); 33891 } 33892 33893 static int 33894 test_xmlregexp(void) { 33895 int test_ret = 0; 33896 33897 if (quiet == 0) printf("Testing xmlregexp : 16 of 30 functions ...\n"); 33898 test_ret += test_xmlExpCtxtNbCons(); 33899 test_ret += test_xmlExpCtxtNbNodes(); 33900 test_ret += test_xmlExpDump(); 33901 test_ret += test_xmlExpExpDerive(); 33902 test_ret += test_xmlExpGetLanguage(); 33903 test_ret += test_xmlExpGetStart(); 33904 test_ret += test_xmlExpIsNillable(); 33905 test_ret += test_xmlExpMaxToken(); 33906 test_ret += test_xmlExpNewAtom(); 33907 test_ret += test_xmlExpNewCtxt(); 33908 test_ret += test_xmlExpNewOr(); 33909 test_ret += test_xmlExpNewRange(); 33910 test_ret += test_xmlExpNewSeq(); 33911 test_ret += test_xmlExpParse(); 33912 test_ret += test_xmlExpRef(); 33913 test_ret += test_xmlExpStringDerive(); 33914 test_ret += test_xmlExpSubsume(); 33915 test_ret += test_xmlRegExecErrInfo(); 33916 test_ret += test_xmlRegExecNextValues(); 33917 test_ret += test_xmlRegExecPushString(); 33918 test_ret += test_xmlRegExecPushString2(); 33919 test_ret += test_xmlRegNewExecCtxt(); 33920 test_ret += test_xmlRegexpCompile(); 33921 test_ret += test_xmlRegexpExec(); 33922 test_ret += test_xmlRegexpIsDeterminist(); 33923 test_ret += test_xmlRegexpPrint(); 33924 33925 if (test_ret != 0) 33926 printf("Module xmlregexp: %d errors\n", test_ret); 33927 return(test_ret); 33928 } 33929 #ifdef LIBXML_OUTPUT_ENABLED 33930 33931 #define gen_nb_xmlSaveCtxtPtr 1 33932 static xmlSaveCtxtPtr gen_xmlSaveCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 33933 return(NULL); 33934 } 33935 static void des_xmlSaveCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSaveCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 33936 } 33937 #endif 33938 33939 33940 static int 33941 test_xmlSaveClose(void) { 33942 int test_ret = 0; 33943 33944 #if defined(LIBXML_OUTPUT_ENABLED) 33945 int mem_base; 33946 int ret_val; 33947 xmlSaveCtxtPtr ctxt; /* a document saving context */ 33948 int n_ctxt; 33949 33950 for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) { 33951 mem_base = xmlMemBlocks(); 33952 ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0); 33953 33954 ret_val = xmlSaveClose(ctxt); 33955 desret_int(ret_val); 33956 call_tests++; 33957 des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0); 33958 xmlResetLastError(); 33959 if (mem_base != xmlMemBlocks()) { 33960 printf("Leak of %d blocks found in xmlSaveClose", 33961 xmlMemBlocks() - mem_base); 33962 test_ret++; 33963 printf(" %d", n_ctxt); 33964 printf("\n"); 33965 } 33966 } 33967 function_tests++; 33968 #endif 33969 33970 return(test_ret); 33971 } 33972 33973 33974 static int 33975 test_xmlSaveDoc(void) { 33976 int test_ret = 0; 33977 33978 #if defined(LIBXML_OUTPUT_ENABLED) 33979 int mem_base; 33980 long ret_val; 33981 xmlSaveCtxtPtr ctxt; /* a document saving context */ 33982 int n_ctxt; 33983 xmlDocPtr doc; /* a document */ 33984 int n_doc; 33985 33986 for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) { 33987 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 33988 mem_base = xmlMemBlocks(); 33989 ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0); 33990 doc = gen_xmlDocPtr(n_doc, 1); 33991 33992 ret_val = xmlSaveDoc(ctxt, doc); 33993 desret_long(ret_val); 33994 call_tests++; 33995 des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0); 33996 des_xmlDocPtr(n_doc, doc, 1); 33997 xmlResetLastError(); 33998 if (mem_base != xmlMemBlocks()) { 33999 printf("Leak of %d blocks found in xmlSaveDoc", 34000 xmlMemBlocks() - mem_base); 34001 test_ret++; 34002 printf(" %d", n_ctxt); 34003 printf(" %d", n_doc); 34004 printf("\n"); 34005 } 34006 } 34007 } 34008 function_tests++; 34009 #endif 34010 34011 return(test_ret); 34012 } 34013 34014 34015 static int 34016 test_xmlSaveFlush(void) { 34017 int test_ret = 0; 34018 34019 #if defined(LIBXML_OUTPUT_ENABLED) 34020 int mem_base; 34021 int ret_val; 34022 xmlSaveCtxtPtr ctxt; /* a document saving context */ 34023 int n_ctxt; 34024 34025 for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) { 34026 mem_base = xmlMemBlocks(); 34027 ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0); 34028 34029 ret_val = xmlSaveFlush(ctxt); 34030 desret_int(ret_val); 34031 call_tests++; 34032 des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0); 34033 xmlResetLastError(); 34034 if (mem_base != xmlMemBlocks()) { 34035 printf("Leak of %d blocks found in xmlSaveFlush", 34036 xmlMemBlocks() - mem_base); 34037 test_ret++; 34038 printf(" %d", n_ctxt); 34039 printf("\n"); 34040 } 34041 } 34042 function_tests++; 34043 #endif 34044 34045 return(test_ret); 34046 } 34047 34048 34049 static int 34050 test_xmlSaveSetAttrEscape(void) { 34051 int test_ret = 0; 34052 34053 34054 /* missing type support */ 34055 return(test_ret); 34056 } 34057 34058 34059 static int 34060 test_xmlSaveSetEscape(void) { 34061 int test_ret = 0; 34062 34063 34064 /* missing type support */ 34065 return(test_ret); 34066 } 34067 34068 34069 static int 34070 test_xmlSaveToBuffer(void) { 34071 int test_ret = 0; 34072 34073 34074 /* missing type support */ 34075 return(test_ret); 34076 } 34077 34078 34079 static int 34080 test_xmlSaveToFd(void) { 34081 int test_ret = 0; 34082 34083 34084 /* missing type support */ 34085 return(test_ret); 34086 } 34087 34088 34089 static int 34090 test_xmlSaveToFilename(void) { 34091 int test_ret = 0; 34092 34093 34094 /* missing type support */ 34095 return(test_ret); 34096 } 34097 34098 34099 static int 34100 test_xmlSaveTree(void) { 34101 int test_ret = 0; 34102 34103 #if defined(LIBXML_OUTPUT_ENABLED) 34104 int mem_base; 34105 long ret_val; 34106 xmlSaveCtxtPtr ctxt; /* a document saving context */ 34107 int n_ctxt; 34108 xmlNodePtr node; /* the top node of the subtree to save */ 34109 int n_node; 34110 34111 for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) { 34112 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 34113 mem_base = xmlMemBlocks(); 34114 ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0); 34115 node = gen_xmlNodePtr(n_node, 1); 34116 34117 ret_val = xmlSaveTree(ctxt, node); 34118 desret_long(ret_val); 34119 call_tests++; 34120 des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0); 34121 des_xmlNodePtr(n_node, node, 1); 34122 xmlResetLastError(); 34123 if (mem_base != xmlMemBlocks()) { 34124 printf("Leak of %d blocks found in xmlSaveTree", 34125 xmlMemBlocks() - mem_base); 34126 test_ret++; 34127 printf(" %d", n_ctxt); 34128 printf(" %d", n_node); 34129 printf("\n"); 34130 } 34131 } 34132 } 34133 function_tests++; 34134 #endif 34135 34136 return(test_ret); 34137 } 34138 34139 static int 34140 test_xmlsave(void) { 34141 int test_ret = 0; 34142 34143 if (quiet == 0) printf("Testing xmlsave : 4 of 10 functions ...\n"); 34144 test_ret += test_xmlSaveClose(); 34145 test_ret += test_xmlSaveDoc(); 34146 test_ret += test_xmlSaveFlush(); 34147 test_ret += test_xmlSaveSetAttrEscape(); 34148 test_ret += test_xmlSaveSetEscape(); 34149 test_ret += test_xmlSaveToBuffer(); 34150 test_ret += test_xmlSaveToFd(); 34151 test_ret += test_xmlSaveToFilename(); 34152 test_ret += test_xmlSaveTree(); 34153 34154 if (test_ret != 0) 34155 printf("Module xmlsave: %d errors\n", test_ret); 34156 return(test_ret); 34157 } 34158 34159 static int 34160 test_xmlSchemaDump(void) { 34161 int test_ret = 0; 34162 34163 #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) 34164 int mem_base; 34165 FILE * output; /* the file output */ 34166 int n_output; 34167 xmlSchemaPtr schema; /* a schema structure */ 34168 int n_schema; 34169 34170 for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) { 34171 for (n_schema = 0;n_schema < gen_nb_xmlSchemaPtr;n_schema++) { 34172 mem_base = xmlMemBlocks(); 34173 output = gen_FILE_ptr(n_output, 0); 34174 schema = gen_xmlSchemaPtr(n_schema, 1); 34175 34176 xmlSchemaDump(output, schema); 34177 call_tests++; 34178 des_FILE_ptr(n_output, output, 0); 34179 des_xmlSchemaPtr(n_schema, schema, 1); 34180 xmlResetLastError(); 34181 if (mem_base != xmlMemBlocks()) { 34182 printf("Leak of %d blocks found in xmlSchemaDump", 34183 xmlMemBlocks() - mem_base); 34184 test_ret++; 34185 printf(" %d", n_output); 34186 printf(" %d", n_schema); 34187 printf("\n"); 34188 } 34189 } 34190 } 34191 function_tests++; 34192 #endif 34193 34194 return(test_ret); 34195 } 34196 34197 #ifdef LIBXML_SCHEMAS_ENABLED 34198 34199 #define gen_nb_xmlSchemaParserCtxtPtr 1 34200 static xmlSchemaParserCtxtPtr gen_xmlSchemaParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 34201 return(NULL); 34202 } 34203 static void des_xmlSchemaParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchemaParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 34204 } 34205 #endif 34206 34207 #ifdef LIBXML_SCHEMAS_ENABLED 34208 34209 #define gen_nb_xmlSchemaValidityErrorFunc_ptr 1 34210 static xmlSchemaValidityErrorFunc * gen_xmlSchemaValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 34211 return(NULL); 34212 } 34213 static void des_xmlSchemaValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlSchemaValidityErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 34214 } 34215 #endif 34216 34217 #ifdef LIBXML_SCHEMAS_ENABLED 34218 34219 #define gen_nb_xmlSchemaValidityWarningFunc_ptr 1 34220 static xmlSchemaValidityWarningFunc * gen_xmlSchemaValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 34221 return(NULL); 34222 } 34223 static void des_xmlSchemaValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, xmlSchemaValidityWarningFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 34224 } 34225 #endif 34226 34227 34228 static int 34229 test_xmlSchemaGetParserErrors(void) { 34230 int test_ret = 0; 34231 34232 #if defined(LIBXML_SCHEMAS_ENABLED) 34233 int mem_base; 34234 int ret_val; 34235 xmlSchemaParserCtxtPtr ctxt; /* a XMl-Schema parser context */ 34236 int n_ctxt; 34237 xmlSchemaValidityErrorFunc * err; /* the error callback result */ 34238 int n_err; 34239 xmlSchemaValidityWarningFunc * warn; /* the warning callback result */ 34240 int n_warn; 34241 void ** ctx; /* contextual data for the callbacks result */ 34242 int n_ctx; 34243 34244 for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaParserCtxtPtr;n_ctxt++) { 34245 for (n_err = 0;n_err < gen_nb_xmlSchemaValidityErrorFunc_ptr;n_err++) { 34246 for (n_warn = 0;n_warn < gen_nb_xmlSchemaValidityWarningFunc_ptr;n_warn++) { 34247 for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) { 34248 mem_base = xmlMemBlocks(); 34249 ctxt = gen_xmlSchemaParserCtxtPtr(n_ctxt, 0); 34250 err = gen_xmlSchemaValidityErrorFunc_ptr(n_err, 1); 34251 warn = gen_xmlSchemaValidityWarningFunc_ptr(n_warn, 2); 34252 ctx = gen_void_ptr_ptr(n_ctx, 3); 34253 34254 ret_val = xmlSchemaGetParserErrors(ctxt, err, warn, ctx); 34255 desret_int(ret_val); 34256 call_tests++; 34257 des_xmlSchemaParserCtxtPtr(n_ctxt, ctxt, 0); 34258 des_xmlSchemaValidityErrorFunc_ptr(n_err, err, 1); 34259 des_xmlSchemaValidityWarningFunc_ptr(n_warn, warn, 2); 34260 des_void_ptr_ptr(n_ctx, ctx, 3); 34261 xmlResetLastError(); 34262 if (mem_base != xmlMemBlocks()) { 34263 printf("Leak of %d blocks found in xmlSchemaGetParserErrors", 34264 xmlMemBlocks() - mem_base); 34265 test_ret++; 34266 printf(" %d", n_ctxt); 34267 printf(" %d", n_err); 34268 printf(" %d", n_warn); 34269 printf(" %d", n_ctx); 34270 printf("\n"); 34271 } 34272 } 34273 } 34274 } 34275 } 34276 function_tests++; 34277 #endif 34278 34279 return(test_ret); 34280 } 34281 34282 34283 static int 34284 test_xmlSchemaGetValidErrors(void) { 34285 int test_ret = 0; 34286 34287 #if defined(LIBXML_SCHEMAS_ENABLED) 34288 int mem_base; 34289 int ret_val; 34290 xmlSchemaValidCtxtPtr ctxt; /* a XML-Schema validation context */ 34291 int n_ctxt; 34292 xmlSchemaValidityErrorFunc * err; /* the error function result */ 34293 int n_err; 34294 xmlSchemaValidityWarningFunc * warn; /* the warning function result */ 34295 int n_warn; 34296 void ** ctx; /* the functions context result */ 34297 int n_ctx; 34298 34299 for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) { 34300 for (n_err = 0;n_err < gen_nb_xmlSchemaValidityErrorFunc_ptr;n_err++) { 34301 for (n_warn = 0;n_warn < gen_nb_xmlSchemaValidityWarningFunc_ptr;n_warn++) { 34302 for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) { 34303 mem_base = xmlMemBlocks(); 34304 ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0); 34305 err = gen_xmlSchemaValidityErrorFunc_ptr(n_err, 1); 34306 warn = gen_xmlSchemaValidityWarningFunc_ptr(n_warn, 2); 34307 ctx = gen_void_ptr_ptr(n_ctx, 3); 34308 34309 ret_val = xmlSchemaGetValidErrors(ctxt, err, warn, ctx); 34310 desret_int(ret_val); 34311 call_tests++; 34312 des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0); 34313 des_xmlSchemaValidityErrorFunc_ptr(n_err, err, 1); 34314 des_xmlSchemaValidityWarningFunc_ptr(n_warn, warn, 2); 34315 des_void_ptr_ptr(n_ctx, ctx, 3); 34316 xmlResetLastError(); 34317 if (mem_base != xmlMemBlocks()) { 34318 printf("Leak of %d blocks found in xmlSchemaGetValidErrors", 34319 xmlMemBlocks() - mem_base); 34320 test_ret++; 34321 printf(" %d", n_ctxt); 34322 printf(" %d", n_err); 34323 printf(" %d", n_warn); 34324 printf(" %d", n_ctx); 34325 printf("\n"); 34326 } 34327 } 34328 } 34329 } 34330 } 34331 function_tests++; 34332 #endif 34333 34334 return(test_ret); 34335 } 34336 34337 34338 static int 34339 test_xmlSchemaIsValid(void) { 34340 int test_ret = 0; 34341 34342 #if defined(LIBXML_SCHEMAS_ENABLED) 34343 int mem_base; 34344 int ret_val; 34345 xmlSchemaValidCtxtPtr ctxt; /* the schema validation context */ 34346 int n_ctxt; 34347 34348 for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) { 34349 mem_base = xmlMemBlocks(); 34350 ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0); 34351 34352 ret_val = xmlSchemaIsValid(ctxt); 34353 desret_int(ret_val); 34354 call_tests++; 34355 des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0); 34356 xmlResetLastError(); 34357 if (mem_base != xmlMemBlocks()) { 34358 printf("Leak of %d blocks found in xmlSchemaIsValid", 34359 xmlMemBlocks() - mem_base); 34360 test_ret++; 34361 printf(" %d", n_ctxt); 34362 printf("\n"); 34363 } 34364 } 34365 function_tests++; 34366 #endif 34367 34368 return(test_ret); 34369 } 34370 34371 34372 static int 34373 test_xmlSchemaNewDocParserCtxt(void) { 34374 int test_ret = 0; 34375 34376 #if defined(LIBXML_SCHEMAS_ENABLED) 34377 int mem_base; 34378 xmlSchemaParserCtxtPtr ret_val; 34379 xmlDocPtr doc; /* a preparsed document tree */ 34380 int n_doc; 34381 34382 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 34383 mem_base = xmlMemBlocks(); 34384 doc = gen_xmlDocPtr(n_doc, 0); 34385 34386 ret_val = xmlSchemaNewDocParserCtxt(doc); 34387 desret_xmlSchemaParserCtxtPtr(ret_val); 34388 call_tests++; 34389 des_xmlDocPtr(n_doc, doc, 0); 34390 xmlResetLastError(); 34391 if (mem_base != xmlMemBlocks()) { 34392 printf("Leak of %d blocks found in xmlSchemaNewDocParserCtxt", 34393 xmlMemBlocks() - mem_base); 34394 test_ret++; 34395 printf(" %d", n_doc); 34396 printf("\n"); 34397 } 34398 } 34399 function_tests++; 34400 #endif 34401 34402 return(test_ret); 34403 } 34404 34405 34406 static int 34407 test_xmlSchemaNewMemParserCtxt(void) { 34408 int test_ret = 0; 34409 34410 #if defined(LIBXML_SCHEMAS_ENABLED) 34411 int mem_base; 34412 xmlSchemaParserCtxtPtr ret_val; 34413 char * buffer; /* a pointer to a char array containing the schemas */ 34414 int n_buffer; 34415 int size; /* the size of the array */ 34416 int n_size; 34417 34418 for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) { 34419 for (n_size = 0;n_size < gen_nb_int;n_size++) { 34420 mem_base = xmlMemBlocks(); 34421 buffer = gen_const_char_ptr(n_buffer, 0); 34422 size = gen_int(n_size, 1); 34423 34424 ret_val = xmlSchemaNewMemParserCtxt((const char *)buffer, size); 34425 desret_xmlSchemaParserCtxtPtr(ret_val); 34426 call_tests++; 34427 des_const_char_ptr(n_buffer, (const char *)buffer, 0); 34428 des_int(n_size, size, 1); 34429 xmlResetLastError(); 34430 if (mem_base != xmlMemBlocks()) { 34431 printf("Leak of %d blocks found in xmlSchemaNewMemParserCtxt", 34432 xmlMemBlocks() - mem_base); 34433 test_ret++; 34434 printf(" %d", n_buffer); 34435 printf(" %d", n_size); 34436 printf("\n"); 34437 } 34438 } 34439 } 34440 function_tests++; 34441 #endif 34442 34443 return(test_ret); 34444 } 34445 34446 34447 static int 34448 test_xmlSchemaNewParserCtxt(void) { 34449 int test_ret = 0; 34450 34451 #if defined(LIBXML_SCHEMAS_ENABLED) 34452 int mem_base; 34453 xmlSchemaParserCtxtPtr ret_val; 34454 char * URL; /* the location of the schema */ 34455 int n_URL; 34456 34457 for (n_URL = 0;n_URL < gen_nb_const_char_ptr;n_URL++) { 34458 mem_base = xmlMemBlocks(); 34459 URL = gen_const_char_ptr(n_URL, 0); 34460 34461 ret_val = xmlSchemaNewParserCtxt((const char *)URL); 34462 desret_xmlSchemaParserCtxtPtr(ret_val); 34463 call_tests++; 34464 des_const_char_ptr(n_URL, (const char *)URL, 0); 34465 xmlResetLastError(); 34466 if (mem_base != xmlMemBlocks()) { 34467 printf("Leak of %d blocks found in xmlSchemaNewParserCtxt", 34468 xmlMemBlocks() - mem_base); 34469 test_ret++; 34470 printf(" %d", n_URL); 34471 printf("\n"); 34472 } 34473 } 34474 function_tests++; 34475 #endif 34476 34477 return(test_ret); 34478 } 34479 34480 34481 static int 34482 test_xmlSchemaNewValidCtxt(void) { 34483 int test_ret = 0; 34484 34485 34486 /* missing type support */ 34487 return(test_ret); 34488 } 34489 34490 34491 static int 34492 test_xmlSchemaParse(void) { 34493 int test_ret = 0; 34494 34495 34496 /* missing type support */ 34497 return(test_ret); 34498 } 34499 34500 #ifdef LIBXML_SCHEMAS_ENABLED 34501 34502 #define gen_nb_xmlSAXHandlerPtr_ptr 1 34503 static xmlSAXHandlerPtr * gen_xmlSAXHandlerPtr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 34504 return(NULL); 34505 } 34506 static void des_xmlSAXHandlerPtr_ptr(int no ATTRIBUTE_UNUSED, xmlSAXHandlerPtr * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 34507 } 34508 #endif 34509 34510 34511 static int 34512 test_xmlSchemaSAXPlug(void) { 34513 int test_ret = 0; 34514 34515 34516 /* missing type support */ 34517 return(test_ret); 34518 } 34519 34520 #ifdef LIBXML_SCHEMAS_ENABLED 34521 34522 #define gen_nb_xmlSchemaSAXPlugPtr 1 34523 static xmlSchemaSAXPlugPtr gen_xmlSchemaSAXPlugPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 34524 return(NULL); 34525 } 34526 static void des_xmlSchemaSAXPlugPtr(int no ATTRIBUTE_UNUSED, xmlSchemaSAXPlugPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 34527 } 34528 #endif 34529 34530 34531 static int 34532 test_xmlSchemaSAXUnplug(void) { 34533 int test_ret = 0; 34534 34535 #if defined(LIBXML_SCHEMAS_ENABLED) 34536 int mem_base; 34537 int ret_val; 34538 xmlSchemaSAXPlugPtr plug; /* a data structure returned by xmlSchemaSAXPlug */ 34539 int n_plug; 34540 34541 for (n_plug = 0;n_plug < gen_nb_xmlSchemaSAXPlugPtr;n_plug++) { 34542 mem_base = xmlMemBlocks(); 34543 plug = gen_xmlSchemaSAXPlugPtr(n_plug, 0); 34544 34545 ret_val = xmlSchemaSAXUnplug(plug); 34546 desret_int(ret_val); 34547 call_tests++; 34548 des_xmlSchemaSAXPlugPtr(n_plug, plug, 0); 34549 xmlResetLastError(); 34550 if (mem_base != xmlMemBlocks()) { 34551 printf("Leak of %d blocks found in xmlSchemaSAXUnplug", 34552 xmlMemBlocks() - mem_base); 34553 test_ret++; 34554 printf(" %d", n_plug); 34555 printf("\n"); 34556 } 34557 } 34558 function_tests++; 34559 #endif 34560 34561 return(test_ret); 34562 } 34563 34564 34565 static int 34566 test_xmlSchemaSetParserErrors(void) { 34567 int test_ret = 0; 34568 34569 34570 /* missing type support */ 34571 return(test_ret); 34572 } 34573 34574 34575 static int 34576 test_xmlSchemaSetParserStructuredErrors(void) { 34577 int test_ret = 0; 34578 34579 34580 /* missing type support */ 34581 return(test_ret); 34582 } 34583 34584 34585 static int 34586 test_xmlSchemaSetValidErrors(void) { 34587 int test_ret = 0; 34588 34589 34590 /* missing type support */ 34591 return(test_ret); 34592 } 34593 34594 34595 static int 34596 test_xmlSchemaSetValidOptions(void) { 34597 int test_ret = 0; 34598 34599 #if defined(LIBXML_SCHEMAS_ENABLED) 34600 int mem_base; 34601 int ret_val; 34602 xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */ 34603 int n_ctxt; 34604 int options; /* a combination of xmlSchemaValidOption */ 34605 int n_options; 34606 34607 for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) { 34608 for (n_options = 0;n_options < gen_nb_int;n_options++) { 34609 mem_base = xmlMemBlocks(); 34610 ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0); 34611 options = gen_int(n_options, 1); 34612 34613 ret_val = xmlSchemaSetValidOptions(ctxt, options); 34614 desret_int(ret_val); 34615 call_tests++; 34616 des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0); 34617 des_int(n_options, options, 1); 34618 xmlResetLastError(); 34619 if (mem_base != xmlMemBlocks()) { 34620 printf("Leak of %d blocks found in xmlSchemaSetValidOptions", 34621 xmlMemBlocks() - mem_base); 34622 test_ret++; 34623 printf(" %d", n_ctxt); 34624 printf(" %d", n_options); 34625 printf("\n"); 34626 } 34627 } 34628 } 34629 function_tests++; 34630 #endif 34631 34632 return(test_ret); 34633 } 34634 34635 34636 static int 34637 test_xmlSchemaSetValidStructuredErrors(void) { 34638 int test_ret = 0; 34639 34640 34641 /* missing type support */ 34642 return(test_ret); 34643 } 34644 34645 34646 static int 34647 test_xmlSchemaValidCtxtGetOptions(void) { 34648 int test_ret = 0; 34649 34650 #if defined(LIBXML_SCHEMAS_ENABLED) 34651 int mem_base; 34652 int ret_val; 34653 xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */ 34654 int n_ctxt; 34655 34656 for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) { 34657 mem_base = xmlMemBlocks(); 34658 ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0); 34659 34660 ret_val = xmlSchemaValidCtxtGetOptions(ctxt); 34661 desret_int(ret_val); 34662 call_tests++; 34663 des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0); 34664 xmlResetLastError(); 34665 if (mem_base != xmlMemBlocks()) { 34666 printf("Leak of %d blocks found in xmlSchemaValidCtxtGetOptions", 34667 xmlMemBlocks() - mem_base); 34668 test_ret++; 34669 printf(" %d", n_ctxt); 34670 printf("\n"); 34671 } 34672 } 34673 function_tests++; 34674 #endif 34675 34676 return(test_ret); 34677 } 34678 34679 34680 static int 34681 test_xmlSchemaValidCtxtGetParserCtxt(void) { 34682 int test_ret = 0; 34683 34684 #if defined(LIBXML_SCHEMAS_ENABLED) 34685 int mem_base; 34686 xmlParserCtxtPtr ret_val; 34687 xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */ 34688 int n_ctxt; 34689 34690 for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) { 34691 mem_base = xmlMemBlocks(); 34692 ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0); 34693 34694 ret_val = xmlSchemaValidCtxtGetParserCtxt(ctxt); 34695 desret_xmlParserCtxtPtr(ret_val); 34696 call_tests++; 34697 des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0); 34698 xmlResetLastError(); 34699 if (mem_base != xmlMemBlocks()) { 34700 printf("Leak of %d blocks found in xmlSchemaValidCtxtGetParserCtxt", 34701 xmlMemBlocks() - mem_base); 34702 test_ret++; 34703 printf(" %d", n_ctxt); 34704 printf("\n"); 34705 } 34706 } 34707 function_tests++; 34708 #endif 34709 34710 return(test_ret); 34711 } 34712 34713 34714 static int 34715 test_xmlSchemaValidateDoc(void) { 34716 int test_ret = 0; 34717 34718 #if defined(LIBXML_SCHEMAS_ENABLED) 34719 int mem_base; 34720 int ret_val; 34721 xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */ 34722 int n_ctxt; 34723 xmlDocPtr doc; /* a parsed document tree */ 34724 int n_doc; 34725 34726 for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) { 34727 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 34728 mem_base = xmlMemBlocks(); 34729 ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0); 34730 doc = gen_xmlDocPtr(n_doc, 1); 34731 34732 ret_val = xmlSchemaValidateDoc(ctxt, doc); 34733 desret_int(ret_val); 34734 call_tests++; 34735 des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0); 34736 des_xmlDocPtr(n_doc, doc, 1); 34737 xmlResetLastError(); 34738 if (mem_base != xmlMemBlocks()) { 34739 printf("Leak of %d blocks found in xmlSchemaValidateDoc", 34740 xmlMemBlocks() - mem_base); 34741 test_ret++; 34742 printf(" %d", n_ctxt); 34743 printf(" %d", n_doc); 34744 printf("\n"); 34745 } 34746 } 34747 } 34748 function_tests++; 34749 #endif 34750 34751 return(test_ret); 34752 } 34753 34754 34755 static int 34756 test_xmlSchemaValidateFile(void) { 34757 int test_ret = 0; 34758 34759 #if defined(LIBXML_SCHEMAS_ENABLED) 34760 int mem_base; 34761 int ret_val; 34762 xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */ 34763 int n_ctxt; 34764 const char * filename; /* the URI of the instance */ 34765 int n_filename; 34766 int options; /* a future set of options, currently unused */ 34767 int n_options; 34768 34769 for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) { 34770 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 34771 for (n_options = 0;n_options < gen_nb_int;n_options++) { 34772 mem_base = xmlMemBlocks(); 34773 ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0); 34774 filename = gen_filepath(n_filename, 1); 34775 options = gen_int(n_options, 2); 34776 34777 ret_val = xmlSchemaValidateFile(ctxt, filename, options); 34778 desret_int(ret_val); 34779 call_tests++; 34780 des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0); 34781 des_filepath(n_filename, filename, 1); 34782 des_int(n_options, options, 2); 34783 xmlResetLastError(); 34784 if (mem_base != xmlMemBlocks()) { 34785 printf("Leak of %d blocks found in xmlSchemaValidateFile", 34786 xmlMemBlocks() - mem_base); 34787 test_ret++; 34788 printf(" %d", n_ctxt); 34789 printf(" %d", n_filename); 34790 printf(" %d", n_options); 34791 printf("\n"); 34792 } 34793 } 34794 } 34795 } 34796 function_tests++; 34797 #endif 34798 34799 return(test_ret); 34800 } 34801 34802 34803 static int 34804 test_xmlSchemaValidateOneElement(void) { 34805 int test_ret = 0; 34806 34807 #if defined(LIBXML_SCHEMAS_ENABLED) 34808 int mem_base; 34809 int ret_val; 34810 xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */ 34811 int n_ctxt; 34812 xmlNodePtr elem; /* an element node */ 34813 int n_elem; 34814 34815 for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) { 34816 for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) { 34817 mem_base = xmlMemBlocks(); 34818 ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0); 34819 elem = gen_xmlNodePtr(n_elem, 1); 34820 34821 ret_val = xmlSchemaValidateOneElement(ctxt, elem); 34822 desret_int(ret_val); 34823 call_tests++; 34824 des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0); 34825 des_xmlNodePtr(n_elem, elem, 1); 34826 xmlResetLastError(); 34827 if (mem_base != xmlMemBlocks()) { 34828 printf("Leak of %d blocks found in xmlSchemaValidateOneElement", 34829 xmlMemBlocks() - mem_base); 34830 test_ret++; 34831 printf(" %d", n_ctxt); 34832 printf(" %d", n_elem); 34833 printf("\n"); 34834 } 34835 } 34836 } 34837 function_tests++; 34838 #endif 34839 34840 return(test_ret); 34841 } 34842 34843 34844 static int 34845 test_xmlSchemaValidateSetFilename(void) { 34846 int test_ret = 0; 34847 34848 #if defined(LIBXML_SCHEMAS_ENABLED) 34849 int mem_base; 34850 xmlSchemaValidCtxtPtr vctxt; /* the schema validation context */ 34851 int n_vctxt; 34852 const char * filename; /* the file name */ 34853 int n_filename; 34854 34855 for (n_vctxt = 0;n_vctxt < gen_nb_xmlSchemaValidCtxtPtr;n_vctxt++) { 34856 for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { 34857 mem_base = xmlMemBlocks(); 34858 vctxt = gen_xmlSchemaValidCtxtPtr(n_vctxt, 0); 34859 filename = gen_filepath(n_filename, 1); 34860 34861 xmlSchemaValidateSetFilename(vctxt, filename); 34862 call_tests++; 34863 des_xmlSchemaValidCtxtPtr(n_vctxt, vctxt, 0); 34864 des_filepath(n_filename, filename, 1); 34865 xmlResetLastError(); 34866 if (mem_base != xmlMemBlocks()) { 34867 printf("Leak of %d blocks found in xmlSchemaValidateSetFilename", 34868 xmlMemBlocks() - mem_base); 34869 test_ret++; 34870 printf(" %d", n_vctxt); 34871 printf(" %d", n_filename); 34872 printf("\n"); 34873 } 34874 } 34875 } 34876 function_tests++; 34877 #endif 34878 34879 return(test_ret); 34880 } 34881 34882 34883 static int 34884 test_xmlSchemaValidateSetLocator(void) { 34885 int test_ret = 0; 34886 34887 34888 /* missing type support */ 34889 return(test_ret); 34890 } 34891 34892 34893 static int 34894 test_xmlSchemaValidateStream(void) { 34895 int test_ret = 0; 34896 34897 #if defined(LIBXML_SCHEMAS_ENABLED) 34898 int mem_base; 34899 int ret_val; 34900 xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */ 34901 int n_ctxt; 34902 xmlParserInputBufferPtr input; /* the input to use for reading the data */ 34903 int n_input; 34904 xmlCharEncoding enc; /* an optional encoding information */ 34905 int n_enc; 34906 xmlSAXHandlerPtr sax; /* a SAX handler for the resulting events */ 34907 int n_sax; 34908 void * user_data; /* the context to provide to the SAX handler. */ 34909 int n_user_data; 34910 34911 for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) { 34912 for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) { 34913 for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) { 34914 for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) { 34915 for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) { 34916 mem_base = xmlMemBlocks(); 34917 ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0); 34918 input = gen_xmlParserInputBufferPtr(n_input, 1); 34919 enc = gen_xmlCharEncoding(n_enc, 2); 34920 sax = gen_xmlSAXHandlerPtr(n_sax, 3); 34921 user_data = gen_userdata(n_user_data, 4); 34922 34923 ret_val = xmlSchemaValidateStream(ctxt, input, enc, sax, user_data); 34924 desret_int(ret_val); 34925 call_tests++; 34926 des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0); 34927 des_xmlParserInputBufferPtr(n_input, input, 1); 34928 des_xmlCharEncoding(n_enc, enc, 2); 34929 des_xmlSAXHandlerPtr(n_sax, sax, 3); 34930 des_userdata(n_user_data, user_data, 4); 34931 xmlResetLastError(); 34932 if (mem_base != xmlMemBlocks()) { 34933 printf("Leak of %d blocks found in xmlSchemaValidateStream", 34934 xmlMemBlocks() - mem_base); 34935 test_ret++; 34936 printf(" %d", n_ctxt); 34937 printf(" %d", n_input); 34938 printf(" %d", n_enc); 34939 printf(" %d", n_sax); 34940 printf(" %d", n_user_data); 34941 printf("\n"); 34942 } 34943 } 34944 } 34945 } 34946 } 34947 } 34948 function_tests++; 34949 #endif 34950 34951 return(test_ret); 34952 } 34953 34954 static int 34955 test_xmlschemas(void) { 34956 int test_ret = 0; 34957 34958 if (quiet == 0) printf("Testing xmlschemas : 16 of 27 functions ...\n"); 34959 test_ret += test_xmlSchemaDump(); 34960 test_ret += test_xmlSchemaGetParserErrors(); 34961 test_ret += test_xmlSchemaGetValidErrors(); 34962 test_ret += test_xmlSchemaIsValid(); 34963 test_ret += test_xmlSchemaNewDocParserCtxt(); 34964 test_ret += test_xmlSchemaNewMemParserCtxt(); 34965 test_ret += test_xmlSchemaNewParserCtxt(); 34966 test_ret += test_xmlSchemaNewValidCtxt(); 34967 test_ret += test_xmlSchemaParse(); 34968 test_ret += test_xmlSchemaSAXPlug(); 34969 test_ret += test_xmlSchemaSAXUnplug(); 34970 test_ret += test_xmlSchemaSetParserErrors(); 34971 test_ret += test_xmlSchemaSetParserStructuredErrors(); 34972 test_ret += test_xmlSchemaSetValidErrors(); 34973 test_ret += test_xmlSchemaSetValidOptions(); 34974 test_ret += test_xmlSchemaSetValidStructuredErrors(); 34975 test_ret += test_xmlSchemaValidCtxtGetOptions(); 34976 test_ret += test_xmlSchemaValidCtxtGetParserCtxt(); 34977 test_ret += test_xmlSchemaValidateDoc(); 34978 test_ret += test_xmlSchemaValidateFile(); 34979 test_ret += test_xmlSchemaValidateOneElement(); 34980 test_ret += test_xmlSchemaValidateSetFilename(); 34981 test_ret += test_xmlSchemaValidateSetLocator(); 34982 test_ret += test_xmlSchemaValidateStream(); 34983 34984 if (test_ret != 0) 34985 printf("Module xmlschemas: %d errors\n", test_ret); 34986 return(test_ret); 34987 } 34988 #ifdef LIBXML_SCHEMAS_ENABLED 34989 34990 #define gen_nb_xmlSchemaFacetPtr 1 34991 static xmlSchemaFacetPtr gen_xmlSchemaFacetPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 34992 return(NULL); 34993 } 34994 static void des_xmlSchemaFacetPtr(int no ATTRIBUTE_UNUSED, xmlSchemaFacetPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 34995 } 34996 #endif 34997 34998 #ifdef LIBXML_SCHEMAS_ENABLED 34999 35000 #define gen_nb_xmlSchemaTypePtr 1 35001 static xmlSchemaTypePtr gen_xmlSchemaTypePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 35002 return(NULL); 35003 } 35004 static void des_xmlSchemaTypePtr(int no ATTRIBUTE_UNUSED, xmlSchemaTypePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 35005 } 35006 #endif 35007 35008 35009 static int 35010 test_xmlSchemaCheckFacet(void) { 35011 int test_ret = 0; 35012 35013 #if defined(LIBXML_SCHEMAS_ENABLED) 35014 int mem_base; 35015 int ret_val; 35016 xmlSchemaFacetPtr facet; /* the facet */ 35017 int n_facet; 35018 xmlSchemaTypePtr typeDecl; /* the schema type definition */ 35019 int n_typeDecl; 35020 xmlSchemaParserCtxtPtr pctxt; /* the schema parser context or NULL */ 35021 int n_pctxt; 35022 xmlChar * name; /* the optional name of the type */ 35023 int n_name; 35024 35025 for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) { 35026 for (n_typeDecl = 0;n_typeDecl < gen_nb_xmlSchemaTypePtr;n_typeDecl++) { 35027 for (n_pctxt = 0;n_pctxt < gen_nb_xmlSchemaParserCtxtPtr;n_pctxt++) { 35028 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 35029 mem_base = xmlMemBlocks(); 35030 facet = gen_xmlSchemaFacetPtr(n_facet, 0); 35031 typeDecl = gen_xmlSchemaTypePtr(n_typeDecl, 1); 35032 pctxt = gen_xmlSchemaParserCtxtPtr(n_pctxt, 2); 35033 name = gen_const_xmlChar_ptr(n_name, 3); 35034 35035 ret_val = xmlSchemaCheckFacet(facet, typeDecl, pctxt, (const xmlChar *)name); 35036 desret_int(ret_val); 35037 call_tests++; 35038 des_xmlSchemaFacetPtr(n_facet, facet, 0); 35039 des_xmlSchemaTypePtr(n_typeDecl, typeDecl, 1); 35040 des_xmlSchemaParserCtxtPtr(n_pctxt, pctxt, 2); 35041 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 3); 35042 xmlResetLastError(); 35043 if (mem_base != xmlMemBlocks()) { 35044 printf("Leak of %d blocks found in xmlSchemaCheckFacet", 35045 xmlMemBlocks() - mem_base); 35046 test_ret++; 35047 printf(" %d", n_facet); 35048 printf(" %d", n_typeDecl); 35049 printf(" %d", n_pctxt); 35050 printf(" %d", n_name); 35051 printf("\n"); 35052 } 35053 } 35054 } 35055 } 35056 } 35057 function_tests++; 35058 #endif 35059 35060 return(test_ret); 35061 } 35062 35063 35064 static int 35065 test_xmlSchemaCleanupTypes(void) { 35066 int test_ret = 0; 35067 35068 #if defined(LIBXML_SCHEMAS_ENABLED) 35069 35070 35071 xmlSchemaCleanupTypes(); 35072 call_tests++; 35073 xmlResetLastError(); 35074 function_tests++; 35075 #endif 35076 35077 return(test_ret); 35078 } 35079 35080 35081 static int 35082 test_xmlSchemaCollapseString(void) { 35083 int test_ret = 0; 35084 35085 #if defined(LIBXML_SCHEMAS_ENABLED) 35086 int mem_base; 35087 xmlChar * ret_val; 35088 xmlChar * value; /* a value */ 35089 int n_value; 35090 35091 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 35092 mem_base = xmlMemBlocks(); 35093 value = gen_const_xmlChar_ptr(n_value, 0); 35094 35095 ret_val = xmlSchemaCollapseString((const xmlChar *)value); 35096 desret_xmlChar_ptr(ret_val); 35097 call_tests++; 35098 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0); 35099 xmlResetLastError(); 35100 if (mem_base != xmlMemBlocks()) { 35101 printf("Leak of %d blocks found in xmlSchemaCollapseString", 35102 xmlMemBlocks() - mem_base); 35103 test_ret++; 35104 printf(" %d", n_value); 35105 printf("\n"); 35106 } 35107 } 35108 function_tests++; 35109 #endif 35110 35111 return(test_ret); 35112 } 35113 35114 #ifdef LIBXML_SCHEMAS_ENABLED 35115 35116 #define gen_nb_xmlSchemaValPtr 1 35117 static xmlSchemaValPtr gen_xmlSchemaValPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 35118 return(NULL); 35119 } 35120 static void des_xmlSchemaValPtr(int no ATTRIBUTE_UNUSED, xmlSchemaValPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 35121 } 35122 #endif 35123 35124 35125 static int 35126 test_xmlSchemaCompareValues(void) { 35127 int test_ret = 0; 35128 35129 #if defined(LIBXML_SCHEMAS_ENABLED) 35130 int mem_base; 35131 int ret_val; 35132 xmlSchemaValPtr x; /* a first value */ 35133 int n_x; 35134 xmlSchemaValPtr y; /* a second value */ 35135 int n_y; 35136 35137 for (n_x = 0;n_x < gen_nb_xmlSchemaValPtr;n_x++) { 35138 for (n_y = 0;n_y < gen_nb_xmlSchemaValPtr;n_y++) { 35139 mem_base = xmlMemBlocks(); 35140 x = gen_xmlSchemaValPtr(n_x, 0); 35141 y = gen_xmlSchemaValPtr(n_y, 1); 35142 35143 ret_val = xmlSchemaCompareValues(x, y); 35144 desret_int(ret_val); 35145 call_tests++; 35146 des_xmlSchemaValPtr(n_x, x, 0); 35147 des_xmlSchemaValPtr(n_y, y, 1); 35148 xmlResetLastError(); 35149 if (mem_base != xmlMemBlocks()) { 35150 printf("Leak of %d blocks found in xmlSchemaCompareValues", 35151 xmlMemBlocks() - mem_base); 35152 test_ret++; 35153 printf(" %d", n_x); 35154 printf(" %d", n_y); 35155 printf("\n"); 35156 } 35157 } 35158 } 35159 function_tests++; 35160 #endif 35161 35162 return(test_ret); 35163 } 35164 35165 35166 static int 35167 test_xmlSchemaCompareValuesWhtsp(void) { 35168 int test_ret = 0; 35169 35170 #if defined(LIBXML_SCHEMAS_ENABLED) 35171 int mem_base; 35172 int ret_val; 35173 xmlSchemaValPtr x; /* a first value */ 35174 int n_x; 35175 xmlSchemaWhitespaceValueType xws; /* the whitespace value of x */ 35176 int n_xws; 35177 xmlSchemaValPtr y; /* a second value */ 35178 int n_y; 35179 xmlSchemaWhitespaceValueType yws; /* the whitespace value of y */ 35180 int n_yws; 35181 35182 for (n_x = 0;n_x < gen_nb_xmlSchemaValPtr;n_x++) { 35183 for (n_xws = 0;n_xws < gen_nb_xmlSchemaWhitespaceValueType;n_xws++) { 35184 for (n_y = 0;n_y < gen_nb_xmlSchemaValPtr;n_y++) { 35185 for (n_yws = 0;n_yws < gen_nb_xmlSchemaWhitespaceValueType;n_yws++) { 35186 mem_base = xmlMemBlocks(); 35187 x = gen_xmlSchemaValPtr(n_x, 0); 35188 xws = gen_xmlSchemaWhitespaceValueType(n_xws, 1); 35189 y = gen_xmlSchemaValPtr(n_y, 2); 35190 yws = gen_xmlSchemaWhitespaceValueType(n_yws, 3); 35191 35192 ret_val = xmlSchemaCompareValuesWhtsp(x, xws, y, yws); 35193 desret_int(ret_val); 35194 call_tests++; 35195 des_xmlSchemaValPtr(n_x, x, 0); 35196 des_xmlSchemaWhitespaceValueType(n_xws, xws, 1); 35197 des_xmlSchemaValPtr(n_y, y, 2); 35198 des_xmlSchemaWhitespaceValueType(n_yws, yws, 3); 35199 xmlResetLastError(); 35200 if (mem_base != xmlMemBlocks()) { 35201 printf("Leak of %d blocks found in xmlSchemaCompareValuesWhtsp", 35202 xmlMemBlocks() - mem_base); 35203 test_ret++; 35204 printf(" %d", n_x); 35205 printf(" %d", n_xws); 35206 printf(" %d", n_y); 35207 printf(" %d", n_yws); 35208 printf("\n"); 35209 } 35210 } 35211 } 35212 } 35213 } 35214 function_tests++; 35215 #endif 35216 35217 return(test_ret); 35218 } 35219 35220 35221 static int 35222 test_xmlSchemaCopyValue(void) { 35223 int test_ret = 0; 35224 35225 35226 /* missing type support */ 35227 return(test_ret); 35228 } 35229 35230 35231 static int 35232 test_xmlSchemaGetBuiltInListSimpleTypeItemType(void) { 35233 int test_ret = 0; 35234 35235 #if defined(LIBXML_SCHEMAS_ENABLED) 35236 int mem_base; 35237 xmlSchemaTypePtr ret_val; 35238 xmlSchemaTypePtr type; /* the built-in simple type. */ 35239 int n_type; 35240 35241 for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) { 35242 mem_base = xmlMemBlocks(); 35243 type = gen_xmlSchemaTypePtr(n_type, 0); 35244 35245 ret_val = xmlSchemaGetBuiltInListSimpleTypeItemType(type); 35246 desret_xmlSchemaTypePtr(ret_val); 35247 call_tests++; 35248 des_xmlSchemaTypePtr(n_type, type, 0); 35249 xmlResetLastError(); 35250 if (mem_base != xmlMemBlocks()) { 35251 printf("Leak of %d blocks found in xmlSchemaGetBuiltInListSimpleTypeItemType", 35252 xmlMemBlocks() - mem_base); 35253 test_ret++; 35254 printf(" %d", n_type); 35255 printf("\n"); 35256 } 35257 } 35258 function_tests++; 35259 #endif 35260 35261 return(test_ret); 35262 } 35263 35264 35265 static int 35266 test_xmlSchemaGetBuiltInType(void) { 35267 int test_ret = 0; 35268 35269 #if defined(LIBXML_SCHEMAS_ENABLED) 35270 xmlSchemaTypePtr ret_val; 35271 xmlSchemaValType type; /* the type of the built in type */ 35272 int n_type; 35273 35274 for (n_type = 0;n_type < gen_nb_xmlSchemaValType;n_type++) { 35275 type = gen_xmlSchemaValType(n_type, 0); 35276 35277 ret_val = xmlSchemaGetBuiltInType(type); 35278 desret_xmlSchemaTypePtr(ret_val); 35279 call_tests++; 35280 des_xmlSchemaValType(n_type, type, 0); 35281 xmlResetLastError(); 35282 } 35283 function_tests++; 35284 #endif 35285 35286 return(test_ret); 35287 } 35288 35289 35290 static int 35291 test_xmlSchemaGetCanonValue(void) { 35292 int test_ret = 0; 35293 35294 #if defined(LIBXML_SCHEMAS_ENABLED) 35295 int mem_base; 35296 int ret_val; 35297 xmlSchemaValPtr val; /* the precomputed value */ 35298 int n_val; 35299 xmlChar ** retValue; /* the returned value */ 35300 int n_retValue; 35301 35302 for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) { 35303 for (n_retValue = 0;n_retValue < gen_nb_const_xmlChar_ptr_ptr;n_retValue++) { 35304 mem_base = xmlMemBlocks(); 35305 val = gen_xmlSchemaValPtr(n_val, 0); 35306 retValue = gen_const_xmlChar_ptr_ptr(n_retValue, 1); 35307 35308 ret_val = xmlSchemaGetCanonValue(val, (const xmlChar **)retValue); 35309 desret_int(ret_val); 35310 call_tests++; 35311 des_xmlSchemaValPtr(n_val, val, 0); 35312 des_const_xmlChar_ptr_ptr(n_retValue, (const xmlChar **)retValue, 1); 35313 xmlResetLastError(); 35314 if (mem_base != xmlMemBlocks()) { 35315 printf("Leak of %d blocks found in xmlSchemaGetCanonValue", 35316 xmlMemBlocks() - mem_base); 35317 test_ret++; 35318 printf(" %d", n_val); 35319 printf(" %d", n_retValue); 35320 printf("\n"); 35321 } 35322 } 35323 } 35324 function_tests++; 35325 #endif 35326 35327 return(test_ret); 35328 } 35329 35330 35331 static int 35332 test_xmlSchemaGetCanonValueWhtsp(void) { 35333 int test_ret = 0; 35334 35335 #if defined(LIBXML_SCHEMAS_ENABLED) 35336 int mem_base; 35337 int ret_val; 35338 xmlSchemaValPtr val; /* the precomputed value */ 35339 int n_val; 35340 xmlChar ** retValue; /* the returned value */ 35341 int n_retValue; 35342 xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */ 35343 int n_ws; 35344 35345 for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) { 35346 for (n_retValue = 0;n_retValue < gen_nb_const_xmlChar_ptr_ptr;n_retValue++) { 35347 for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) { 35348 mem_base = xmlMemBlocks(); 35349 val = gen_xmlSchemaValPtr(n_val, 0); 35350 retValue = gen_const_xmlChar_ptr_ptr(n_retValue, 1); 35351 ws = gen_xmlSchemaWhitespaceValueType(n_ws, 2); 35352 35353 ret_val = xmlSchemaGetCanonValueWhtsp(val, (const xmlChar **)retValue, ws); 35354 desret_int(ret_val); 35355 call_tests++; 35356 des_xmlSchemaValPtr(n_val, val, 0); 35357 des_const_xmlChar_ptr_ptr(n_retValue, (const xmlChar **)retValue, 1); 35358 des_xmlSchemaWhitespaceValueType(n_ws, ws, 2); 35359 xmlResetLastError(); 35360 if (mem_base != xmlMemBlocks()) { 35361 printf("Leak of %d blocks found in xmlSchemaGetCanonValueWhtsp", 35362 xmlMemBlocks() - mem_base); 35363 test_ret++; 35364 printf(" %d", n_val); 35365 printf(" %d", n_retValue); 35366 printf(" %d", n_ws); 35367 printf("\n"); 35368 } 35369 } 35370 } 35371 } 35372 function_tests++; 35373 #endif 35374 35375 return(test_ret); 35376 } 35377 35378 35379 static int 35380 test_xmlSchemaGetFacetValueAsULong(void) { 35381 int test_ret = 0; 35382 35383 #if defined(LIBXML_SCHEMAS_ENABLED) 35384 int mem_base; 35385 unsigned long ret_val; 35386 xmlSchemaFacetPtr facet; /* an schemas type facet */ 35387 int n_facet; 35388 35389 for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) { 35390 mem_base = xmlMemBlocks(); 35391 facet = gen_xmlSchemaFacetPtr(n_facet, 0); 35392 35393 ret_val = xmlSchemaGetFacetValueAsULong(facet); 35394 desret_unsigned_long(ret_val); 35395 call_tests++; 35396 des_xmlSchemaFacetPtr(n_facet, facet, 0); 35397 xmlResetLastError(); 35398 if (mem_base != xmlMemBlocks()) { 35399 printf("Leak of %d blocks found in xmlSchemaGetFacetValueAsULong", 35400 xmlMemBlocks() - mem_base); 35401 test_ret++; 35402 printf(" %d", n_facet); 35403 printf("\n"); 35404 } 35405 } 35406 function_tests++; 35407 #endif 35408 35409 return(test_ret); 35410 } 35411 35412 35413 static int 35414 test_xmlSchemaGetPredefinedType(void) { 35415 int test_ret = 0; 35416 35417 #if defined(LIBXML_SCHEMAS_ENABLED) 35418 int mem_base; 35419 xmlSchemaTypePtr ret_val; 35420 xmlChar * name; /* the type name */ 35421 int n_name; 35422 xmlChar * ns; /* the URI of the namespace usually "http://www.w3.org/2001/XMLSchema" */ 35423 int n_ns; 35424 35425 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 35426 for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) { 35427 mem_base = xmlMemBlocks(); 35428 name = gen_const_xmlChar_ptr(n_name, 0); 35429 ns = gen_const_xmlChar_ptr(n_ns, 1); 35430 35431 ret_val = xmlSchemaGetPredefinedType((const xmlChar *)name, (const xmlChar *)ns); 35432 desret_xmlSchemaTypePtr(ret_val); 35433 call_tests++; 35434 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0); 35435 des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 1); 35436 xmlResetLastError(); 35437 if (mem_base != xmlMemBlocks()) { 35438 printf("Leak of %d blocks found in xmlSchemaGetPredefinedType", 35439 xmlMemBlocks() - mem_base); 35440 test_ret++; 35441 printf(" %d", n_name); 35442 printf(" %d", n_ns); 35443 printf("\n"); 35444 } 35445 } 35446 } 35447 function_tests++; 35448 #endif 35449 35450 return(test_ret); 35451 } 35452 35453 35454 static int 35455 test_xmlSchemaGetValType(void) { 35456 int test_ret = 0; 35457 35458 #if defined(LIBXML_SCHEMAS_ENABLED) 35459 int mem_base; 35460 xmlSchemaValType ret_val; 35461 xmlSchemaValPtr val; /* a schemas value */ 35462 int n_val; 35463 35464 for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) { 35465 mem_base = xmlMemBlocks(); 35466 val = gen_xmlSchemaValPtr(n_val, 0); 35467 35468 ret_val = xmlSchemaGetValType(val); 35469 desret_xmlSchemaValType(ret_val); 35470 call_tests++; 35471 des_xmlSchemaValPtr(n_val, val, 0); 35472 xmlResetLastError(); 35473 if (mem_base != xmlMemBlocks()) { 35474 printf("Leak of %d blocks found in xmlSchemaGetValType", 35475 xmlMemBlocks() - mem_base); 35476 test_ret++; 35477 printf(" %d", n_val); 35478 printf("\n"); 35479 } 35480 } 35481 function_tests++; 35482 #endif 35483 35484 return(test_ret); 35485 } 35486 35487 35488 static int 35489 test_xmlSchemaInitTypes(void) { 35490 int test_ret = 0; 35491 35492 #if defined(LIBXML_SCHEMAS_ENABLED) 35493 35494 35495 xmlSchemaInitTypes(); 35496 call_tests++; 35497 xmlResetLastError(); 35498 function_tests++; 35499 #endif 35500 35501 return(test_ret); 35502 } 35503 35504 35505 static int 35506 test_xmlSchemaIsBuiltInTypeFacet(void) { 35507 int test_ret = 0; 35508 35509 #if defined(LIBXML_SCHEMAS_ENABLED) 35510 int mem_base; 35511 int ret_val; 35512 xmlSchemaTypePtr type; /* the built-in type */ 35513 int n_type; 35514 int facetType; /* the facet type */ 35515 int n_facetType; 35516 35517 for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) { 35518 for (n_facetType = 0;n_facetType < gen_nb_int;n_facetType++) { 35519 mem_base = xmlMemBlocks(); 35520 type = gen_xmlSchemaTypePtr(n_type, 0); 35521 facetType = gen_int(n_facetType, 1); 35522 35523 ret_val = xmlSchemaIsBuiltInTypeFacet(type, facetType); 35524 desret_int(ret_val); 35525 call_tests++; 35526 des_xmlSchemaTypePtr(n_type, type, 0); 35527 des_int(n_facetType, facetType, 1); 35528 xmlResetLastError(); 35529 if (mem_base != xmlMemBlocks()) { 35530 printf("Leak of %d blocks found in xmlSchemaIsBuiltInTypeFacet", 35531 xmlMemBlocks() - mem_base); 35532 test_ret++; 35533 printf(" %d", n_type); 35534 printf(" %d", n_facetType); 35535 printf("\n"); 35536 } 35537 } 35538 } 35539 function_tests++; 35540 #endif 35541 35542 return(test_ret); 35543 } 35544 35545 35546 static int 35547 test_xmlSchemaNewFacet(void) { 35548 int test_ret = 0; 35549 35550 35551 /* missing type support */ 35552 return(test_ret); 35553 } 35554 35555 35556 static int 35557 test_xmlSchemaNewNOTATIONValue(void) { 35558 int test_ret = 0; 35559 35560 35561 /* missing type support */ 35562 return(test_ret); 35563 } 35564 35565 35566 static int 35567 test_xmlSchemaNewQNameValue(void) { 35568 int test_ret = 0; 35569 35570 35571 /* missing type support */ 35572 return(test_ret); 35573 } 35574 35575 35576 static int 35577 test_xmlSchemaNewStringValue(void) { 35578 int test_ret = 0; 35579 35580 35581 /* missing type support */ 35582 return(test_ret); 35583 } 35584 35585 #ifdef LIBXML_SCHEMAS_ENABLED 35586 35587 #define gen_nb_xmlSchemaValPtr_ptr 1 35588 static xmlSchemaValPtr * gen_xmlSchemaValPtr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 35589 return(NULL); 35590 } 35591 static void des_xmlSchemaValPtr_ptr(int no ATTRIBUTE_UNUSED, xmlSchemaValPtr * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 35592 } 35593 #endif 35594 35595 35596 static int 35597 test_xmlSchemaValPredefTypeNode(void) { 35598 int test_ret = 0; 35599 35600 #if defined(LIBXML_SCHEMAS_ENABLED) 35601 int mem_base; 35602 int ret_val; 35603 xmlSchemaTypePtr type; /* the predefined type */ 35604 int n_type; 35605 xmlChar * value; /* the value to check */ 35606 int n_value; 35607 xmlSchemaValPtr * val; /* the return computed value */ 35608 int n_val; 35609 xmlNodePtr node; /* the node containing the value */ 35610 int n_node; 35611 35612 for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) { 35613 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 35614 for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) { 35615 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 35616 mem_base = xmlMemBlocks(); 35617 type = gen_xmlSchemaTypePtr(n_type, 0); 35618 value = gen_const_xmlChar_ptr(n_value, 1); 35619 val = gen_xmlSchemaValPtr_ptr(n_val, 2); 35620 node = gen_xmlNodePtr(n_node, 3); 35621 35622 ret_val = xmlSchemaValPredefTypeNode(type, (const xmlChar *)value, val, node); 35623 desret_int(ret_val); 35624 call_tests++; 35625 des_xmlSchemaTypePtr(n_type, type, 0); 35626 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1); 35627 des_xmlSchemaValPtr_ptr(n_val, val, 2); 35628 des_xmlNodePtr(n_node, node, 3); 35629 xmlResetLastError(); 35630 if (mem_base != xmlMemBlocks()) { 35631 printf("Leak of %d blocks found in xmlSchemaValPredefTypeNode", 35632 xmlMemBlocks() - mem_base); 35633 test_ret++; 35634 printf(" %d", n_type); 35635 printf(" %d", n_value); 35636 printf(" %d", n_val); 35637 printf(" %d", n_node); 35638 printf("\n"); 35639 } 35640 } 35641 } 35642 } 35643 } 35644 function_tests++; 35645 #endif 35646 35647 return(test_ret); 35648 } 35649 35650 35651 static int 35652 test_xmlSchemaValPredefTypeNodeNoNorm(void) { 35653 int test_ret = 0; 35654 35655 #if defined(LIBXML_SCHEMAS_ENABLED) 35656 int mem_base; 35657 int ret_val; 35658 xmlSchemaTypePtr type; /* the predefined type */ 35659 int n_type; 35660 xmlChar * value; /* the value to check */ 35661 int n_value; 35662 xmlSchemaValPtr * val; /* the return computed value */ 35663 int n_val; 35664 xmlNodePtr node; /* the node containing the value */ 35665 int n_node; 35666 35667 for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) { 35668 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 35669 for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) { 35670 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 35671 mem_base = xmlMemBlocks(); 35672 type = gen_xmlSchemaTypePtr(n_type, 0); 35673 value = gen_const_xmlChar_ptr(n_value, 1); 35674 val = gen_xmlSchemaValPtr_ptr(n_val, 2); 35675 node = gen_xmlNodePtr(n_node, 3); 35676 35677 ret_val = xmlSchemaValPredefTypeNodeNoNorm(type, (const xmlChar *)value, val, node); 35678 desret_int(ret_val); 35679 call_tests++; 35680 des_xmlSchemaTypePtr(n_type, type, 0); 35681 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1); 35682 des_xmlSchemaValPtr_ptr(n_val, val, 2); 35683 des_xmlNodePtr(n_node, node, 3); 35684 xmlResetLastError(); 35685 if (mem_base != xmlMemBlocks()) { 35686 printf("Leak of %d blocks found in xmlSchemaValPredefTypeNodeNoNorm", 35687 xmlMemBlocks() - mem_base); 35688 test_ret++; 35689 printf(" %d", n_type); 35690 printf(" %d", n_value); 35691 printf(" %d", n_val); 35692 printf(" %d", n_node); 35693 printf("\n"); 35694 } 35695 } 35696 } 35697 } 35698 } 35699 function_tests++; 35700 #endif 35701 35702 return(test_ret); 35703 } 35704 35705 35706 static int 35707 test_xmlSchemaValidateFacet(void) { 35708 int test_ret = 0; 35709 35710 #if defined(LIBXML_SCHEMAS_ENABLED) 35711 int mem_base; 35712 int ret_val; 35713 xmlSchemaTypePtr base; /* the base type */ 35714 int n_base; 35715 xmlSchemaFacetPtr facet; /* the facet to check */ 35716 int n_facet; 35717 xmlChar * value; /* the lexical repr of the value to validate */ 35718 int n_value; 35719 xmlSchemaValPtr val; /* the precomputed value */ 35720 int n_val; 35721 35722 for (n_base = 0;n_base < gen_nb_xmlSchemaTypePtr;n_base++) { 35723 for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) { 35724 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 35725 for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) { 35726 mem_base = xmlMemBlocks(); 35727 base = gen_xmlSchemaTypePtr(n_base, 0); 35728 facet = gen_xmlSchemaFacetPtr(n_facet, 1); 35729 value = gen_const_xmlChar_ptr(n_value, 2); 35730 val = gen_xmlSchemaValPtr(n_val, 3); 35731 35732 ret_val = xmlSchemaValidateFacet(base, facet, (const xmlChar *)value, val); 35733 desret_int(ret_val); 35734 call_tests++; 35735 des_xmlSchemaTypePtr(n_base, base, 0); 35736 des_xmlSchemaFacetPtr(n_facet, facet, 1); 35737 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2); 35738 des_xmlSchemaValPtr(n_val, val, 3); 35739 xmlResetLastError(); 35740 if (mem_base != xmlMemBlocks()) { 35741 printf("Leak of %d blocks found in xmlSchemaValidateFacet", 35742 xmlMemBlocks() - mem_base); 35743 test_ret++; 35744 printf(" %d", n_base); 35745 printf(" %d", n_facet); 35746 printf(" %d", n_value); 35747 printf(" %d", n_val); 35748 printf("\n"); 35749 } 35750 } 35751 } 35752 } 35753 } 35754 function_tests++; 35755 #endif 35756 35757 return(test_ret); 35758 } 35759 35760 35761 static int 35762 test_xmlSchemaValidateFacetWhtsp(void) { 35763 int test_ret = 0; 35764 35765 #if defined(LIBXML_SCHEMAS_ENABLED) 35766 int mem_base; 35767 int ret_val; 35768 xmlSchemaFacetPtr facet; /* the facet to check */ 35769 int n_facet; 35770 xmlSchemaWhitespaceValueType fws; /* the whitespace type of the facet's value */ 35771 int n_fws; 35772 xmlSchemaValType valType; /* the built-in type of the value */ 35773 int n_valType; 35774 xmlChar * value; /* the lexical (or normalized for pattern) repr of the value to validate */ 35775 int n_value; 35776 xmlSchemaValPtr val; /* the precomputed value */ 35777 int n_val; 35778 xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */ 35779 int n_ws; 35780 35781 for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) { 35782 for (n_fws = 0;n_fws < gen_nb_xmlSchemaWhitespaceValueType;n_fws++) { 35783 for (n_valType = 0;n_valType < gen_nb_xmlSchemaValType;n_valType++) { 35784 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 35785 for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) { 35786 for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) { 35787 mem_base = xmlMemBlocks(); 35788 facet = gen_xmlSchemaFacetPtr(n_facet, 0); 35789 fws = gen_xmlSchemaWhitespaceValueType(n_fws, 1); 35790 valType = gen_xmlSchemaValType(n_valType, 2); 35791 value = gen_const_xmlChar_ptr(n_value, 3); 35792 val = gen_xmlSchemaValPtr(n_val, 4); 35793 ws = gen_xmlSchemaWhitespaceValueType(n_ws, 5); 35794 35795 ret_val = xmlSchemaValidateFacetWhtsp(facet, fws, valType, (const xmlChar *)value, val, ws); 35796 desret_int(ret_val); 35797 call_tests++; 35798 des_xmlSchemaFacetPtr(n_facet, facet, 0); 35799 des_xmlSchemaWhitespaceValueType(n_fws, fws, 1); 35800 des_xmlSchemaValType(n_valType, valType, 2); 35801 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3); 35802 des_xmlSchemaValPtr(n_val, val, 4); 35803 des_xmlSchemaWhitespaceValueType(n_ws, ws, 5); 35804 xmlResetLastError(); 35805 if (mem_base != xmlMemBlocks()) { 35806 printf("Leak of %d blocks found in xmlSchemaValidateFacetWhtsp", 35807 xmlMemBlocks() - mem_base); 35808 test_ret++; 35809 printf(" %d", n_facet); 35810 printf(" %d", n_fws); 35811 printf(" %d", n_valType); 35812 printf(" %d", n_value); 35813 printf(" %d", n_val); 35814 printf(" %d", n_ws); 35815 printf("\n"); 35816 } 35817 } 35818 } 35819 } 35820 } 35821 } 35822 } 35823 function_tests++; 35824 #endif 35825 35826 return(test_ret); 35827 } 35828 35829 35830 static int 35831 test_xmlSchemaValidateLengthFacet(void) { 35832 int test_ret = 0; 35833 35834 #if defined(LIBXML_SCHEMAS_ENABLED) 35835 int mem_base; 35836 int ret_val; 35837 xmlSchemaTypePtr type; /* the built-in type */ 35838 int n_type; 35839 xmlSchemaFacetPtr facet; /* the facet to check */ 35840 int n_facet; 35841 xmlChar * value; /* the lexical repr. of the value to be validated */ 35842 int n_value; 35843 xmlSchemaValPtr val; /* the precomputed value */ 35844 int n_val; 35845 unsigned long * length; /* the actual length of the value */ 35846 int n_length; 35847 35848 for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) { 35849 for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) { 35850 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 35851 for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) { 35852 for (n_length = 0;n_length < gen_nb_unsigned_long_ptr;n_length++) { 35853 mem_base = xmlMemBlocks(); 35854 type = gen_xmlSchemaTypePtr(n_type, 0); 35855 facet = gen_xmlSchemaFacetPtr(n_facet, 1); 35856 value = gen_const_xmlChar_ptr(n_value, 2); 35857 val = gen_xmlSchemaValPtr(n_val, 3); 35858 length = gen_unsigned_long_ptr(n_length, 4); 35859 35860 ret_val = xmlSchemaValidateLengthFacet(type, facet, (const xmlChar *)value, val, length); 35861 desret_int(ret_val); 35862 call_tests++; 35863 des_xmlSchemaTypePtr(n_type, type, 0); 35864 des_xmlSchemaFacetPtr(n_facet, facet, 1); 35865 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2); 35866 des_xmlSchemaValPtr(n_val, val, 3); 35867 des_unsigned_long_ptr(n_length, length, 4); 35868 xmlResetLastError(); 35869 if (mem_base != xmlMemBlocks()) { 35870 printf("Leak of %d blocks found in xmlSchemaValidateLengthFacet", 35871 xmlMemBlocks() - mem_base); 35872 test_ret++; 35873 printf(" %d", n_type); 35874 printf(" %d", n_facet); 35875 printf(" %d", n_value); 35876 printf(" %d", n_val); 35877 printf(" %d", n_length); 35878 printf("\n"); 35879 } 35880 } 35881 } 35882 } 35883 } 35884 } 35885 function_tests++; 35886 #endif 35887 35888 return(test_ret); 35889 } 35890 35891 35892 static int 35893 test_xmlSchemaValidateLengthFacetWhtsp(void) { 35894 int test_ret = 0; 35895 35896 #if defined(LIBXML_SCHEMAS_ENABLED) 35897 int mem_base; 35898 int ret_val; 35899 xmlSchemaFacetPtr facet; /* the facet to check */ 35900 int n_facet; 35901 xmlSchemaValType valType; /* the built-in type */ 35902 int n_valType; 35903 xmlChar * value; /* the lexical repr. of the value to be validated */ 35904 int n_value; 35905 xmlSchemaValPtr val; /* the precomputed value */ 35906 int n_val; 35907 unsigned long * length; /* the actual length of the value */ 35908 int n_length; 35909 xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */ 35910 int n_ws; 35911 35912 for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) { 35913 for (n_valType = 0;n_valType < gen_nb_xmlSchemaValType;n_valType++) { 35914 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 35915 for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) { 35916 for (n_length = 0;n_length < gen_nb_unsigned_long_ptr;n_length++) { 35917 for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) { 35918 mem_base = xmlMemBlocks(); 35919 facet = gen_xmlSchemaFacetPtr(n_facet, 0); 35920 valType = gen_xmlSchemaValType(n_valType, 1); 35921 value = gen_const_xmlChar_ptr(n_value, 2); 35922 val = gen_xmlSchemaValPtr(n_val, 3); 35923 length = gen_unsigned_long_ptr(n_length, 4); 35924 ws = gen_xmlSchemaWhitespaceValueType(n_ws, 5); 35925 35926 ret_val = xmlSchemaValidateLengthFacetWhtsp(facet, valType, (const xmlChar *)value, val, length, ws); 35927 desret_int(ret_val); 35928 call_tests++; 35929 des_xmlSchemaFacetPtr(n_facet, facet, 0); 35930 des_xmlSchemaValType(n_valType, valType, 1); 35931 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2); 35932 des_xmlSchemaValPtr(n_val, val, 3); 35933 des_unsigned_long_ptr(n_length, length, 4); 35934 des_xmlSchemaWhitespaceValueType(n_ws, ws, 5); 35935 xmlResetLastError(); 35936 if (mem_base != xmlMemBlocks()) { 35937 printf("Leak of %d blocks found in xmlSchemaValidateLengthFacetWhtsp", 35938 xmlMemBlocks() - mem_base); 35939 test_ret++; 35940 printf(" %d", n_facet); 35941 printf(" %d", n_valType); 35942 printf(" %d", n_value); 35943 printf(" %d", n_val); 35944 printf(" %d", n_length); 35945 printf(" %d", n_ws); 35946 printf("\n"); 35947 } 35948 } 35949 } 35950 } 35951 } 35952 } 35953 } 35954 function_tests++; 35955 #endif 35956 35957 return(test_ret); 35958 } 35959 35960 35961 static int 35962 test_xmlSchemaValidateListSimpleTypeFacet(void) { 35963 int test_ret = 0; 35964 35965 #if defined(LIBXML_SCHEMAS_ENABLED) 35966 int mem_base; 35967 int ret_val; 35968 xmlSchemaFacetPtr facet; /* the facet to check */ 35969 int n_facet; 35970 xmlChar * value; /* the lexical repr of the value to validate */ 35971 int n_value; 35972 unsigned long actualLen; /* the number of list items */ 35973 int n_actualLen; 35974 unsigned long * expectedLen; /* the resulting expected number of list items */ 35975 int n_expectedLen; 35976 35977 for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) { 35978 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 35979 for (n_actualLen = 0;n_actualLen < gen_nb_unsigned_long;n_actualLen++) { 35980 for (n_expectedLen = 0;n_expectedLen < gen_nb_unsigned_long_ptr;n_expectedLen++) { 35981 mem_base = xmlMemBlocks(); 35982 facet = gen_xmlSchemaFacetPtr(n_facet, 0); 35983 value = gen_const_xmlChar_ptr(n_value, 1); 35984 actualLen = gen_unsigned_long(n_actualLen, 2); 35985 expectedLen = gen_unsigned_long_ptr(n_expectedLen, 3); 35986 35987 ret_val = xmlSchemaValidateListSimpleTypeFacet(facet, (const xmlChar *)value, actualLen, expectedLen); 35988 desret_int(ret_val); 35989 call_tests++; 35990 des_xmlSchemaFacetPtr(n_facet, facet, 0); 35991 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1); 35992 des_unsigned_long(n_actualLen, actualLen, 2); 35993 des_unsigned_long_ptr(n_expectedLen, expectedLen, 3); 35994 xmlResetLastError(); 35995 if (mem_base != xmlMemBlocks()) { 35996 printf("Leak of %d blocks found in xmlSchemaValidateListSimpleTypeFacet", 35997 xmlMemBlocks() - mem_base); 35998 test_ret++; 35999 printf(" %d", n_facet); 36000 printf(" %d", n_value); 36001 printf(" %d", n_actualLen); 36002 printf(" %d", n_expectedLen); 36003 printf("\n"); 36004 } 36005 } 36006 } 36007 } 36008 } 36009 function_tests++; 36010 #endif 36011 36012 return(test_ret); 36013 } 36014 36015 36016 static int 36017 test_xmlSchemaValidatePredefinedType(void) { 36018 int test_ret = 0; 36019 36020 #if defined(LIBXML_SCHEMAS_ENABLED) 36021 int mem_base; 36022 int ret_val; 36023 xmlSchemaTypePtr type; /* the predefined type */ 36024 int n_type; 36025 xmlChar * value; /* the value to check */ 36026 int n_value; 36027 xmlSchemaValPtr * val; /* the return computed value */ 36028 int n_val; 36029 36030 for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) { 36031 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 36032 for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) { 36033 mem_base = xmlMemBlocks(); 36034 type = gen_xmlSchemaTypePtr(n_type, 0); 36035 value = gen_const_xmlChar_ptr(n_value, 1); 36036 val = gen_xmlSchemaValPtr_ptr(n_val, 2); 36037 36038 ret_val = xmlSchemaValidatePredefinedType(type, (const xmlChar *)value, val); 36039 desret_int(ret_val); 36040 call_tests++; 36041 des_xmlSchemaTypePtr(n_type, type, 0); 36042 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1); 36043 des_xmlSchemaValPtr_ptr(n_val, val, 2); 36044 xmlResetLastError(); 36045 if (mem_base != xmlMemBlocks()) { 36046 printf("Leak of %d blocks found in xmlSchemaValidatePredefinedType", 36047 xmlMemBlocks() - mem_base); 36048 test_ret++; 36049 printf(" %d", n_type); 36050 printf(" %d", n_value); 36051 printf(" %d", n_val); 36052 printf("\n"); 36053 } 36054 } 36055 } 36056 } 36057 function_tests++; 36058 #endif 36059 36060 return(test_ret); 36061 } 36062 36063 36064 static int 36065 test_xmlSchemaValueAppend(void) { 36066 int test_ret = 0; 36067 36068 #if defined(LIBXML_SCHEMAS_ENABLED) 36069 int mem_base; 36070 int ret_val; 36071 xmlSchemaValPtr prev; /* the value */ 36072 int n_prev; 36073 xmlSchemaValPtr cur; /* the value to be appended */ 36074 int n_cur; 36075 36076 for (n_prev = 0;n_prev < gen_nb_xmlSchemaValPtr;n_prev++) { 36077 for (n_cur = 0;n_cur < gen_nb_xmlSchemaValPtr;n_cur++) { 36078 mem_base = xmlMemBlocks(); 36079 prev = gen_xmlSchemaValPtr(n_prev, 0); 36080 cur = gen_xmlSchemaValPtr(n_cur, 1); 36081 36082 ret_val = xmlSchemaValueAppend(prev, cur); 36083 desret_int(ret_val); 36084 call_tests++; 36085 des_xmlSchemaValPtr(n_prev, prev, 0); 36086 des_xmlSchemaValPtr(n_cur, cur, 1); 36087 xmlResetLastError(); 36088 if (mem_base != xmlMemBlocks()) { 36089 printf("Leak of %d blocks found in xmlSchemaValueAppend", 36090 xmlMemBlocks() - mem_base); 36091 test_ret++; 36092 printf(" %d", n_prev); 36093 printf(" %d", n_cur); 36094 printf("\n"); 36095 } 36096 } 36097 } 36098 function_tests++; 36099 #endif 36100 36101 return(test_ret); 36102 } 36103 36104 36105 static int 36106 test_xmlSchemaValueGetAsBoolean(void) { 36107 int test_ret = 0; 36108 36109 #if defined(LIBXML_SCHEMAS_ENABLED) 36110 int mem_base; 36111 int ret_val; 36112 xmlSchemaValPtr val; /* the value */ 36113 int n_val; 36114 36115 for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) { 36116 mem_base = xmlMemBlocks(); 36117 val = gen_xmlSchemaValPtr(n_val, 0); 36118 36119 ret_val = xmlSchemaValueGetAsBoolean(val); 36120 desret_int(ret_val); 36121 call_tests++; 36122 des_xmlSchemaValPtr(n_val, val, 0); 36123 xmlResetLastError(); 36124 if (mem_base != xmlMemBlocks()) { 36125 printf("Leak of %d blocks found in xmlSchemaValueGetAsBoolean", 36126 xmlMemBlocks() - mem_base); 36127 test_ret++; 36128 printf(" %d", n_val); 36129 printf("\n"); 36130 } 36131 } 36132 function_tests++; 36133 #endif 36134 36135 return(test_ret); 36136 } 36137 36138 36139 static int 36140 test_xmlSchemaValueGetAsString(void) { 36141 int test_ret = 0; 36142 36143 #if defined(LIBXML_SCHEMAS_ENABLED) 36144 int mem_base; 36145 const xmlChar * ret_val; 36146 xmlSchemaValPtr val; /* the value */ 36147 int n_val; 36148 36149 for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) { 36150 mem_base = xmlMemBlocks(); 36151 val = gen_xmlSchemaValPtr(n_val, 0); 36152 36153 ret_val = xmlSchemaValueGetAsString(val); 36154 desret_const_xmlChar_ptr(ret_val); 36155 call_tests++; 36156 des_xmlSchemaValPtr(n_val, val, 0); 36157 xmlResetLastError(); 36158 if (mem_base != xmlMemBlocks()) { 36159 printf("Leak of %d blocks found in xmlSchemaValueGetAsString", 36160 xmlMemBlocks() - mem_base); 36161 test_ret++; 36162 printf(" %d", n_val); 36163 printf("\n"); 36164 } 36165 } 36166 function_tests++; 36167 #endif 36168 36169 return(test_ret); 36170 } 36171 36172 36173 static int 36174 test_xmlSchemaValueGetNext(void) { 36175 int test_ret = 0; 36176 36177 36178 /* missing type support */ 36179 return(test_ret); 36180 } 36181 36182 36183 static int 36184 test_xmlSchemaWhiteSpaceReplace(void) { 36185 int test_ret = 0; 36186 36187 #if defined(LIBXML_SCHEMAS_ENABLED) 36188 int mem_base; 36189 xmlChar * ret_val; 36190 xmlChar * value; /* a value */ 36191 int n_value; 36192 36193 for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) { 36194 mem_base = xmlMemBlocks(); 36195 value = gen_const_xmlChar_ptr(n_value, 0); 36196 36197 ret_val = xmlSchemaWhiteSpaceReplace((const xmlChar *)value); 36198 desret_xmlChar_ptr(ret_val); 36199 call_tests++; 36200 des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0); 36201 xmlResetLastError(); 36202 if (mem_base != xmlMemBlocks()) { 36203 printf("Leak of %d blocks found in xmlSchemaWhiteSpaceReplace", 36204 xmlMemBlocks() - mem_base); 36205 test_ret++; 36206 printf(" %d", n_value); 36207 printf("\n"); 36208 } 36209 } 36210 function_tests++; 36211 #endif 36212 36213 return(test_ret); 36214 } 36215 36216 static int 36217 test_xmlschemastypes(void) { 36218 int test_ret = 0; 36219 36220 if (quiet == 0) printf("Testing xmlschemastypes : 26 of 34 functions ...\n"); 36221 test_ret += test_xmlSchemaCheckFacet(); 36222 test_ret += test_xmlSchemaCleanupTypes(); 36223 test_ret += test_xmlSchemaCollapseString(); 36224 test_ret += test_xmlSchemaCompareValues(); 36225 test_ret += test_xmlSchemaCompareValuesWhtsp(); 36226 test_ret += test_xmlSchemaCopyValue(); 36227 test_ret += test_xmlSchemaGetBuiltInListSimpleTypeItemType(); 36228 test_ret += test_xmlSchemaGetBuiltInType(); 36229 test_ret += test_xmlSchemaGetCanonValue(); 36230 test_ret += test_xmlSchemaGetCanonValueWhtsp(); 36231 test_ret += test_xmlSchemaGetFacetValueAsULong(); 36232 test_ret += test_xmlSchemaGetPredefinedType(); 36233 test_ret += test_xmlSchemaGetValType(); 36234 test_ret += test_xmlSchemaInitTypes(); 36235 test_ret += test_xmlSchemaIsBuiltInTypeFacet(); 36236 test_ret += test_xmlSchemaNewFacet(); 36237 test_ret += test_xmlSchemaNewNOTATIONValue(); 36238 test_ret += test_xmlSchemaNewQNameValue(); 36239 test_ret += test_xmlSchemaNewStringValue(); 36240 test_ret += test_xmlSchemaValPredefTypeNode(); 36241 test_ret += test_xmlSchemaValPredefTypeNodeNoNorm(); 36242 test_ret += test_xmlSchemaValidateFacet(); 36243 test_ret += test_xmlSchemaValidateFacetWhtsp(); 36244 test_ret += test_xmlSchemaValidateLengthFacet(); 36245 test_ret += test_xmlSchemaValidateLengthFacetWhtsp(); 36246 test_ret += test_xmlSchemaValidateListSimpleTypeFacet(); 36247 test_ret += test_xmlSchemaValidatePredefinedType(); 36248 test_ret += test_xmlSchemaValueAppend(); 36249 test_ret += test_xmlSchemaValueGetAsBoolean(); 36250 test_ret += test_xmlSchemaValueGetAsString(); 36251 test_ret += test_xmlSchemaValueGetNext(); 36252 test_ret += test_xmlSchemaWhiteSpaceReplace(); 36253 36254 if (test_ret != 0) 36255 printf("Module xmlschemastypes: %d errors\n", test_ret); 36256 return(test_ret); 36257 } 36258 36259 static int 36260 test_xmlCharStrdup(void) { 36261 int test_ret = 0; 36262 36263 int mem_base; 36264 xmlChar * ret_val; 36265 char * cur; /* the input char * */ 36266 int n_cur; 36267 36268 for (n_cur = 0;n_cur < gen_nb_const_char_ptr;n_cur++) { 36269 mem_base = xmlMemBlocks(); 36270 cur = gen_const_char_ptr(n_cur, 0); 36271 36272 ret_val = xmlCharStrdup((const char *)cur); 36273 desret_xmlChar_ptr(ret_val); 36274 call_tests++; 36275 des_const_char_ptr(n_cur, (const char *)cur, 0); 36276 xmlResetLastError(); 36277 if (mem_base != xmlMemBlocks()) { 36278 printf("Leak of %d blocks found in xmlCharStrdup", 36279 xmlMemBlocks() - mem_base); 36280 test_ret++; 36281 printf(" %d", n_cur); 36282 printf("\n"); 36283 } 36284 } 36285 function_tests++; 36286 36287 return(test_ret); 36288 } 36289 36290 36291 static int 36292 test_xmlCharStrndup(void) { 36293 int test_ret = 0; 36294 36295 int mem_base; 36296 xmlChar * ret_val; 36297 char * cur; /* the input char * */ 36298 int n_cur; 36299 int len; /* the len of @cur */ 36300 int n_len; 36301 36302 for (n_cur = 0;n_cur < gen_nb_const_char_ptr;n_cur++) { 36303 for (n_len = 0;n_len < gen_nb_int;n_len++) { 36304 mem_base = xmlMemBlocks(); 36305 cur = gen_const_char_ptr(n_cur, 0); 36306 len = gen_int(n_len, 1); 36307 36308 ret_val = xmlCharStrndup((const char *)cur, len); 36309 desret_xmlChar_ptr(ret_val); 36310 call_tests++; 36311 des_const_char_ptr(n_cur, (const char *)cur, 0); 36312 des_int(n_len, len, 1); 36313 xmlResetLastError(); 36314 if (mem_base != xmlMemBlocks()) { 36315 printf("Leak of %d blocks found in xmlCharStrndup", 36316 xmlMemBlocks() - mem_base); 36317 test_ret++; 36318 printf(" %d", n_cur); 36319 printf(" %d", n_len); 36320 printf("\n"); 36321 } 36322 } 36323 } 36324 function_tests++; 36325 36326 return(test_ret); 36327 } 36328 36329 36330 static int 36331 test_xmlCheckUTF8(void) { 36332 int test_ret = 0; 36333 36334 int mem_base; 36335 int ret_val; 36336 unsigned char * utf; /* Pointer to putative UTF-8 encoded string. */ 36337 int n_utf; 36338 36339 for (n_utf = 0;n_utf < gen_nb_const_unsigned_char_ptr;n_utf++) { 36340 mem_base = xmlMemBlocks(); 36341 utf = gen_const_unsigned_char_ptr(n_utf, 0); 36342 36343 ret_val = xmlCheckUTF8((const unsigned char *)utf); 36344 desret_int(ret_val); 36345 call_tests++; 36346 des_const_unsigned_char_ptr(n_utf, (const unsigned char *)utf, 0); 36347 xmlResetLastError(); 36348 if (mem_base != xmlMemBlocks()) { 36349 printf("Leak of %d blocks found in xmlCheckUTF8", 36350 xmlMemBlocks() - mem_base); 36351 test_ret++; 36352 printf(" %d", n_utf); 36353 printf("\n"); 36354 } 36355 } 36356 function_tests++; 36357 36358 return(test_ret); 36359 } 36360 36361 36362 static int 36363 test_xmlGetUTF8Char(void) { 36364 int test_ret = 0; 36365 36366 int mem_base; 36367 int ret_val; 36368 unsigned char * utf; /* a sequence of UTF-8 encoded bytes */ 36369 int n_utf; 36370 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. */ 36371 int n_len; 36372 36373 for (n_utf = 0;n_utf < gen_nb_const_unsigned_char_ptr;n_utf++) { 36374 for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) { 36375 mem_base = xmlMemBlocks(); 36376 utf = gen_const_unsigned_char_ptr(n_utf, 0); 36377 len = gen_int_ptr(n_len, 1); 36378 36379 ret_val = xmlGetUTF8Char((const unsigned char *)utf, len); 36380 desret_int(ret_val); 36381 call_tests++; 36382 des_const_unsigned_char_ptr(n_utf, (const unsigned char *)utf, 0); 36383 des_int_ptr(n_len, len, 1); 36384 xmlResetLastError(); 36385 if (mem_base != xmlMemBlocks()) { 36386 printf("Leak of %d blocks found in xmlGetUTF8Char", 36387 xmlMemBlocks() - mem_base); 36388 test_ret++; 36389 printf(" %d", n_utf); 36390 printf(" %d", n_len); 36391 printf("\n"); 36392 } 36393 } 36394 } 36395 function_tests++; 36396 36397 return(test_ret); 36398 } 36399 36400 36401 static int 36402 test_xmlStrEqual(void) { 36403 int test_ret = 0; 36404 36405 int mem_base; 36406 int ret_val; 36407 xmlChar * str1; /* the first xmlChar * */ 36408 int n_str1; 36409 xmlChar * str2; /* the second xmlChar * */ 36410 int n_str2; 36411 36412 for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) { 36413 for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) { 36414 mem_base = xmlMemBlocks(); 36415 str1 = gen_const_xmlChar_ptr(n_str1, 0); 36416 str2 = gen_const_xmlChar_ptr(n_str2, 1); 36417 36418 ret_val = xmlStrEqual((const xmlChar *)str1, (const xmlChar *)str2); 36419 desret_int(ret_val); 36420 call_tests++; 36421 des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0); 36422 des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1); 36423 xmlResetLastError(); 36424 if (mem_base != xmlMemBlocks()) { 36425 printf("Leak of %d blocks found in xmlStrEqual", 36426 xmlMemBlocks() - mem_base); 36427 test_ret++; 36428 printf(" %d", n_str1); 36429 printf(" %d", n_str2); 36430 printf("\n"); 36431 } 36432 } 36433 } 36434 function_tests++; 36435 36436 return(test_ret); 36437 } 36438 36439 36440 static int 36441 test_xmlStrPrintf(void) { 36442 int test_ret = 0; 36443 36444 36445 /* missing type support */ 36446 return(test_ret); 36447 } 36448 36449 36450 static int 36451 test_xmlStrQEqual(void) { 36452 int test_ret = 0; 36453 36454 int mem_base; 36455 int ret_val; 36456 xmlChar * pref; /* the prefix of the QName */ 36457 int n_pref; 36458 xmlChar * name; /* the localname of the QName */ 36459 int n_name; 36460 xmlChar * str; /* the second xmlChar * */ 36461 int n_str; 36462 36463 for (n_pref = 0;n_pref < gen_nb_const_xmlChar_ptr;n_pref++) { 36464 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 36465 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 36466 mem_base = xmlMemBlocks(); 36467 pref = gen_const_xmlChar_ptr(n_pref, 0); 36468 name = gen_const_xmlChar_ptr(n_name, 1); 36469 str = gen_const_xmlChar_ptr(n_str, 2); 36470 36471 ret_val = xmlStrQEqual((const xmlChar *)pref, (const xmlChar *)name, (const xmlChar *)str); 36472 desret_int(ret_val); 36473 call_tests++; 36474 des_const_xmlChar_ptr(n_pref, (const xmlChar *)pref, 0); 36475 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 36476 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 2); 36477 xmlResetLastError(); 36478 if (mem_base != xmlMemBlocks()) { 36479 printf("Leak of %d blocks found in xmlStrQEqual", 36480 xmlMemBlocks() - mem_base); 36481 test_ret++; 36482 printf(" %d", n_pref); 36483 printf(" %d", n_name); 36484 printf(" %d", n_str); 36485 printf("\n"); 36486 } 36487 } 36488 } 36489 } 36490 function_tests++; 36491 36492 return(test_ret); 36493 } 36494 36495 36496 static int 36497 test_xmlStrVPrintf(void) { 36498 int test_ret = 0; 36499 36500 36501 /* missing type support */ 36502 return(test_ret); 36503 } 36504 36505 36506 static int 36507 test_xmlStrcasecmp(void) { 36508 int test_ret = 0; 36509 36510 int mem_base; 36511 int ret_val; 36512 xmlChar * str1; /* the first xmlChar * */ 36513 int n_str1; 36514 xmlChar * str2; /* the second xmlChar * */ 36515 int n_str2; 36516 36517 for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) { 36518 for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) { 36519 mem_base = xmlMemBlocks(); 36520 str1 = gen_const_xmlChar_ptr(n_str1, 0); 36521 str2 = gen_const_xmlChar_ptr(n_str2, 1); 36522 36523 ret_val = xmlStrcasecmp((const xmlChar *)str1, (const xmlChar *)str2); 36524 desret_int(ret_val); 36525 call_tests++; 36526 des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0); 36527 des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1); 36528 xmlResetLastError(); 36529 if (mem_base != xmlMemBlocks()) { 36530 printf("Leak of %d blocks found in xmlStrcasecmp", 36531 xmlMemBlocks() - mem_base); 36532 test_ret++; 36533 printf(" %d", n_str1); 36534 printf(" %d", n_str2); 36535 printf("\n"); 36536 } 36537 } 36538 } 36539 function_tests++; 36540 36541 return(test_ret); 36542 } 36543 36544 36545 static int 36546 test_xmlStrcasestr(void) { 36547 int test_ret = 0; 36548 36549 int mem_base; 36550 const xmlChar * ret_val; 36551 xmlChar * str; /* the xmlChar * array (haystack) */ 36552 int n_str; 36553 xmlChar * val; /* the xmlChar to search (needle) */ 36554 int n_val; 36555 36556 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 36557 for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) { 36558 mem_base = xmlMemBlocks(); 36559 str = gen_const_xmlChar_ptr(n_str, 0); 36560 val = gen_const_xmlChar_ptr(n_val, 1); 36561 36562 ret_val = xmlStrcasestr((const xmlChar *)str, (const xmlChar *)val); 36563 desret_const_xmlChar_ptr(ret_val); 36564 call_tests++; 36565 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); 36566 des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 1); 36567 xmlResetLastError(); 36568 if (mem_base != xmlMemBlocks()) { 36569 printf("Leak of %d blocks found in xmlStrcasestr", 36570 xmlMemBlocks() - mem_base); 36571 test_ret++; 36572 printf(" %d", n_str); 36573 printf(" %d", n_val); 36574 printf("\n"); 36575 } 36576 } 36577 } 36578 function_tests++; 36579 36580 return(test_ret); 36581 } 36582 36583 36584 static int 36585 test_xmlStrchr(void) { 36586 int test_ret = 0; 36587 36588 int mem_base; 36589 const xmlChar * ret_val; 36590 xmlChar * str; /* the xmlChar * array */ 36591 int n_str; 36592 xmlChar val; /* the xmlChar to search */ 36593 int n_val; 36594 36595 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 36596 for (n_val = 0;n_val < gen_nb_xmlChar;n_val++) { 36597 mem_base = xmlMemBlocks(); 36598 str = gen_const_xmlChar_ptr(n_str, 0); 36599 val = gen_xmlChar(n_val, 1); 36600 36601 ret_val = xmlStrchr((const xmlChar *)str, val); 36602 desret_const_xmlChar_ptr(ret_val); 36603 call_tests++; 36604 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); 36605 des_xmlChar(n_val, val, 1); 36606 xmlResetLastError(); 36607 if (mem_base != xmlMemBlocks()) { 36608 printf("Leak of %d blocks found in xmlStrchr", 36609 xmlMemBlocks() - mem_base); 36610 test_ret++; 36611 printf(" %d", n_str); 36612 printf(" %d", n_val); 36613 printf("\n"); 36614 } 36615 } 36616 } 36617 function_tests++; 36618 36619 return(test_ret); 36620 } 36621 36622 36623 static int 36624 test_xmlStrcmp(void) { 36625 int test_ret = 0; 36626 36627 int mem_base; 36628 int ret_val; 36629 xmlChar * str1; /* the first xmlChar * */ 36630 int n_str1; 36631 xmlChar * str2; /* the second xmlChar * */ 36632 int n_str2; 36633 36634 for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) { 36635 for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) { 36636 mem_base = xmlMemBlocks(); 36637 str1 = gen_const_xmlChar_ptr(n_str1, 0); 36638 str2 = gen_const_xmlChar_ptr(n_str2, 1); 36639 36640 ret_val = xmlStrcmp((const xmlChar *)str1, (const xmlChar *)str2); 36641 desret_int(ret_val); 36642 call_tests++; 36643 des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0); 36644 des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1); 36645 xmlResetLastError(); 36646 if (mem_base != xmlMemBlocks()) { 36647 printf("Leak of %d blocks found in xmlStrcmp", 36648 xmlMemBlocks() - mem_base); 36649 test_ret++; 36650 printf(" %d", n_str1); 36651 printf(" %d", n_str2); 36652 printf("\n"); 36653 } 36654 } 36655 } 36656 function_tests++; 36657 36658 return(test_ret); 36659 } 36660 36661 36662 static int 36663 test_xmlStrdup(void) { 36664 int test_ret = 0; 36665 36666 int mem_base; 36667 xmlChar * ret_val; 36668 xmlChar * cur; /* the input xmlChar * */ 36669 int n_cur; 36670 36671 for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) { 36672 mem_base = xmlMemBlocks(); 36673 cur = gen_const_xmlChar_ptr(n_cur, 0); 36674 36675 ret_val = xmlStrdup((const xmlChar *)cur); 36676 desret_xmlChar_ptr(ret_val); 36677 call_tests++; 36678 des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0); 36679 xmlResetLastError(); 36680 if (mem_base != xmlMemBlocks()) { 36681 printf("Leak of %d blocks found in xmlStrdup", 36682 xmlMemBlocks() - mem_base); 36683 test_ret++; 36684 printf(" %d", n_cur); 36685 printf("\n"); 36686 } 36687 } 36688 function_tests++; 36689 36690 return(test_ret); 36691 } 36692 36693 36694 static int 36695 test_xmlStrlen(void) { 36696 int test_ret = 0; 36697 36698 int mem_base; 36699 int ret_val; 36700 xmlChar * str; /* the xmlChar * array */ 36701 int n_str; 36702 36703 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 36704 mem_base = xmlMemBlocks(); 36705 str = gen_const_xmlChar_ptr(n_str, 0); 36706 36707 ret_val = xmlStrlen((const xmlChar *)str); 36708 desret_int(ret_val); 36709 call_tests++; 36710 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); 36711 xmlResetLastError(); 36712 if (mem_base != xmlMemBlocks()) { 36713 printf("Leak of %d blocks found in xmlStrlen", 36714 xmlMemBlocks() - mem_base); 36715 test_ret++; 36716 printf(" %d", n_str); 36717 printf("\n"); 36718 } 36719 } 36720 function_tests++; 36721 36722 return(test_ret); 36723 } 36724 36725 36726 static int 36727 test_xmlStrncasecmp(void) { 36728 int test_ret = 0; 36729 36730 int mem_base; 36731 int ret_val; 36732 xmlChar * str1; /* the first xmlChar * */ 36733 int n_str1; 36734 xmlChar * str2; /* the second xmlChar * */ 36735 int n_str2; 36736 int len; /* the max comparison length */ 36737 int n_len; 36738 36739 for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) { 36740 for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) { 36741 for (n_len = 0;n_len < gen_nb_int;n_len++) { 36742 mem_base = xmlMemBlocks(); 36743 str1 = gen_const_xmlChar_ptr(n_str1, 0); 36744 str2 = gen_const_xmlChar_ptr(n_str2, 1); 36745 len = gen_int(n_len, 2); 36746 36747 ret_val = xmlStrncasecmp((const xmlChar *)str1, (const xmlChar *)str2, len); 36748 desret_int(ret_val); 36749 call_tests++; 36750 des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0); 36751 des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1); 36752 des_int(n_len, len, 2); 36753 xmlResetLastError(); 36754 if (mem_base != xmlMemBlocks()) { 36755 printf("Leak of %d blocks found in xmlStrncasecmp", 36756 xmlMemBlocks() - mem_base); 36757 test_ret++; 36758 printf(" %d", n_str1); 36759 printf(" %d", n_str2); 36760 printf(" %d", n_len); 36761 printf("\n"); 36762 } 36763 } 36764 } 36765 } 36766 function_tests++; 36767 36768 return(test_ret); 36769 } 36770 36771 36772 static int 36773 test_xmlStrncatNew(void) { 36774 int test_ret = 0; 36775 36776 int mem_base; 36777 xmlChar * ret_val; 36778 xmlChar * str1; /* first xmlChar string */ 36779 int n_str1; 36780 xmlChar * str2; /* second xmlChar string */ 36781 int n_str2; 36782 int len; /* the len of @str2 or < 0 */ 36783 int n_len; 36784 36785 for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) { 36786 for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) { 36787 for (n_len = 0;n_len < gen_nb_int;n_len++) { 36788 mem_base = xmlMemBlocks(); 36789 str1 = gen_const_xmlChar_ptr(n_str1, 0); 36790 str2 = gen_const_xmlChar_ptr(n_str2, 1); 36791 len = gen_int(n_len, 2); 36792 36793 ret_val = xmlStrncatNew((const xmlChar *)str1, (const xmlChar *)str2, len); 36794 desret_xmlChar_ptr(ret_val); 36795 call_tests++; 36796 des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0); 36797 des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1); 36798 des_int(n_len, len, 2); 36799 xmlResetLastError(); 36800 if (mem_base != xmlMemBlocks()) { 36801 printf("Leak of %d blocks found in xmlStrncatNew", 36802 xmlMemBlocks() - mem_base); 36803 test_ret++; 36804 printf(" %d", n_str1); 36805 printf(" %d", n_str2); 36806 printf(" %d", n_len); 36807 printf("\n"); 36808 } 36809 } 36810 } 36811 } 36812 function_tests++; 36813 36814 return(test_ret); 36815 } 36816 36817 36818 static int 36819 test_xmlStrncmp(void) { 36820 int test_ret = 0; 36821 36822 int mem_base; 36823 int ret_val; 36824 xmlChar * str1; /* the first xmlChar * */ 36825 int n_str1; 36826 xmlChar * str2; /* the second xmlChar * */ 36827 int n_str2; 36828 int len; /* the max comparison length */ 36829 int n_len; 36830 36831 for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) { 36832 for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) { 36833 for (n_len = 0;n_len < gen_nb_int;n_len++) { 36834 mem_base = xmlMemBlocks(); 36835 str1 = gen_const_xmlChar_ptr(n_str1, 0); 36836 str2 = gen_const_xmlChar_ptr(n_str2, 1); 36837 len = gen_int(n_len, 2); 36838 36839 ret_val = xmlStrncmp((const xmlChar *)str1, (const xmlChar *)str2, len); 36840 desret_int(ret_val); 36841 call_tests++; 36842 des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0); 36843 des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1); 36844 des_int(n_len, len, 2); 36845 xmlResetLastError(); 36846 if (mem_base != xmlMemBlocks()) { 36847 printf("Leak of %d blocks found in xmlStrncmp", 36848 xmlMemBlocks() - mem_base); 36849 test_ret++; 36850 printf(" %d", n_str1); 36851 printf(" %d", n_str2); 36852 printf(" %d", n_len); 36853 printf("\n"); 36854 } 36855 } 36856 } 36857 } 36858 function_tests++; 36859 36860 return(test_ret); 36861 } 36862 36863 36864 static int 36865 test_xmlStrndup(void) { 36866 int test_ret = 0; 36867 36868 int mem_base; 36869 xmlChar * ret_val; 36870 xmlChar * cur; /* the input xmlChar * */ 36871 int n_cur; 36872 int len; /* the len of @cur */ 36873 int n_len; 36874 36875 for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) { 36876 for (n_len = 0;n_len < gen_nb_int;n_len++) { 36877 mem_base = xmlMemBlocks(); 36878 cur = gen_const_xmlChar_ptr(n_cur, 0); 36879 len = gen_int(n_len, 1); 36880 36881 ret_val = xmlStrndup((const xmlChar *)cur, len); 36882 desret_xmlChar_ptr(ret_val); 36883 call_tests++; 36884 des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0); 36885 des_int(n_len, len, 1); 36886 xmlResetLastError(); 36887 if (mem_base != xmlMemBlocks()) { 36888 printf("Leak of %d blocks found in xmlStrndup", 36889 xmlMemBlocks() - mem_base); 36890 test_ret++; 36891 printf(" %d", n_cur); 36892 printf(" %d", n_len); 36893 printf("\n"); 36894 } 36895 } 36896 } 36897 function_tests++; 36898 36899 return(test_ret); 36900 } 36901 36902 36903 static int 36904 test_xmlStrstr(void) { 36905 int test_ret = 0; 36906 36907 int mem_base; 36908 const xmlChar * ret_val; 36909 xmlChar * str; /* the xmlChar * array (haystack) */ 36910 int n_str; 36911 xmlChar * val; /* the xmlChar to search (needle) */ 36912 int n_val; 36913 36914 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 36915 for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) { 36916 mem_base = xmlMemBlocks(); 36917 str = gen_const_xmlChar_ptr(n_str, 0); 36918 val = gen_const_xmlChar_ptr(n_val, 1); 36919 36920 ret_val = xmlStrstr((const xmlChar *)str, (const xmlChar *)val); 36921 desret_const_xmlChar_ptr(ret_val); 36922 call_tests++; 36923 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); 36924 des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 1); 36925 xmlResetLastError(); 36926 if (mem_base != xmlMemBlocks()) { 36927 printf("Leak of %d blocks found in xmlStrstr", 36928 xmlMemBlocks() - mem_base); 36929 test_ret++; 36930 printf(" %d", n_str); 36931 printf(" %d", n_val); 36932 printf("\n"); 36933 } 36934 } 36935 } 36936 function_tests++; 36937 36938 return(test_ret); 36939 } 36940 36941 36942 static int 36943 test_xmlStrsub(void) { 36944 int test_ret = 0; 36945 36946 int mem_base; 36947 xmlChar * ret_val; 36948 xmlChar * str; /* the xmlChar * array (haystack) */ 36949 int n_str; 36950 int start; /* the index of the first char (zero based) */ 36951 int n_start; 36952 int len; /* the length of the substring */ 36953 int n_len; 36954 36955 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 36956 for (n_start = 0;n_start < gen_nb_int;n_start++) { 36957 for (n_len = 0;n_len < gen_nb_int;n_len++) { 36958 mem_base = xmlMemBlocks(); 36959 str = gen_const_xmlChar_ptr(n_str, 0); 36960 start = gen_int(n_start, 1); 36961 len = gen_int(n_len, 2); 36962 36963 ret_val = xmlStrsub((const xmlChar *)str, start, len); 36964 desret_xmlChar_ptr(ret_val); 36965 call_tests++; 36966 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); 36967 des_int(n_start, start, 1); 36968 des_int(n_len, len, 2); 36969 xmlResetLastError(); 36970 if (mem_base != xmlMemBlocks()) { 36971 printf("Leak of %d blocks found in xmlStrsub", 36972 xmlMemBlocks() - mem_base); 36973 test_ret++; 36974 printf(" %d", n_str); 36975 printf(" %d", n_start); 36976 printf(" %d", n_len); 36977 printf("\n"); 36978 } 36979 } 36980 } 36981 } 36982 function_tests++; 36983 36984 return(test_ret); 36985 } 36986 36987 36988 static int 36989 test_xmlUTF8Charcmp(void) { 36990 int test_ret = 0; 36991 36992 int mem_base; 36993 int ret_val; 36994 xmlChar * utf1; /* pointer to first UTF8 char */ 36995 int n_utf1; 36996 xmlChar * utf2; /* pointer to second UTF8 char */ 36997 int n_utf2; 36998 36999 for (n_utf1 = 0;n_utf1 < gen_nb_const_xmlChar_ptr;n_utf1++) { 37000 for (n_utf2 = 0;n_utf2 < gen_nb_const_xmlChar_ptr;n_utf2++) { 37001 mem_base = xmlMemBlocks(); 37002 utf1 = gen_const_xmlChar_ptr(n_utf1, 0); 37003 utf2 = gen_const_xmlChar_ptr(n_utf2, 1); 37004 37005 ret_val = xmlUTF8Charcmp((const xmlChar *)utf1, (const xmlChar *)utf2); 37006 desret_int(ret_val); 37007 call_tests++; 37008 des_const_xmlChar_ptr(n_utf1, (const xmlChar *)utf1, 0); 37009 des_const_xmlChar_ptr(n_utf2, (const xmlChar *)utf2, 1); 37010 xmlResetLastError(); 37011 if (mem_base != xmlMemBlocks()) { 37012 printf("Leak of %d blocks found in xmlUTF8Charcmp", 37013 xmlMemBlocks() - mem_base); 37014 test_ret++; 37015 printf(" %d", n_utf1); 37016 printf(" %d", n_utf2); 37017 printf("\n"); 37018 } 37019 } 37020 } 37021 function_tests++; 37022 37023 return(test_ret); 37024 } 37025 37026 37027 static int 37028 test_xmlUTF8Size(void) { 37029 int test_ret = 0; 37030 37031 int mem_base; 37032 int ret_val; 37033 xmlChar * utf; /* pointer to the UTF8 character */ 37034 int n_utf; 37035 37036 for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) { 37037 mem_base = xmlMemBlocks(); 37038 utf = gen_const_xmlChar_ptr(n_utf, 0); 37039 37040 ret_val = xmlUTF8Size((const xmlChar *)utf); 37041 desret_int(ret_val); 37042 call_tests++; 37043 des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0); 37044 xmlResetLastError(); 37045 if (mem_base != xmlMemBlocks()) { 37046 printf("Leak of %d blocks found in xmlUTF8Size", 37047 xmlMemBlocks() - mem_base); 37048 test_ret++; 37049 printf(" %d", n_utf); 37050 printf("\n"); 37051 } 37052 } 37053 function_tests++; 37054 37055 return(test_ret); 37056 } 37057 37058 37059 static int 37060 test_xmlUTF8Strlen(void) { 37061 int test_ret = 0; 37062 37063 int mem_base; 37064 int ret_val; 37065 xmlChar * utf; /* a sequence of UTF-8 encoded bytes */ 37066 int n_utf; 37067 37068 for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) { 37069 mem_base = xmlMemBlocks(); 37070 utf = gen_const_xmlChar_ptr(n_utf, 0); 37071 37072 ret_val = xmlUTF8Strlen((const xmlChar *)utf); 37073 desret_int(ret_val); 37074 call_tests++; 37075 des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0); 37076 xmlResetLastError(); 37077 if (mem_base != xmlMemBlocks()) { 37078 printf("Leak of %d blocks found in xmlUTF8Strlen", 37079 xmlMemBlocks() - mem_base); 37080 test_ret++; 37081 printf(" %d", n_utf); 37082 printf("\n"); 37083 } 37084 } 37085 function_tests++; 37086 37087 return(test_ret); 37088 } 37089 37090 37091 static int 37092 test_xmlUTF8Strloc(void) { 37093 int test_ret = 0; 37094 37095 int mem_base; 37096 int ret_val; 37097 xmlChar * utf; /* the input UTF8 * */ 37098 int n_utf; 37099 xmlChar * utfchar; /* the UTF8 character to be found */ 37100 int n_utfchar; 37101 37102 for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) { 37103 for (n_utfchar = 0;n_utfchar < gen_nb_const_xmlChar_ptr;n_utfchar++) { 37104 mem_base = xmlMemBlocks(); 37105 utf = gen_const_xmlChar_ptr(n_utf, 0); 37106 utfchar = gen_const_xmlChar_ptr(n_utfchar, 1); 37107 37108 ret_val = xmlUTF8Strloc((const xmlChar *)utf, (const xmlChar *)utfchar); 37109 desret_int(ret_val); 37110 call_tests++; 37111 des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0); 37112 des_const_xmlChar_ptr(n_utfchar, (const xmlChar *)utfchar, 1); 37113 xmlResetLastError(); 37114 if (mem_base != xmlMemBlocks()) { 37115 printf("Leak of %d blocks found in xmlUTF8Strloc", 37116 xmlMemBlocks() - mem_base); 37117 test_ret++; 37118 printf(" %d", n_utf); 37119 printf(" %d", n_utfchar); 37120 printf("\n"); 37121 } 37122 } 37123 } 37124 function_tests++; 37125 37126 return(test_ret); 37127 } 37128 37129 37130 static int 37131 test_xmlUTF8Strndup(void) { 37132 int test_ret = 0; 37133 37134 int mem_base; 37135 xmlChar * ret_val; 37136 xmlChar * utf; /* the input UTF8 * */ 37137 int n_utf; 37138 int len; /* the len of @utf (in chars) */ 37139 int n_len; 37140 37141 for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) { 37142 for (n_len = 0;n_len < gen_nb_int;n_len++) { 37143 mem_base = xmlMemBlocks(); 37144 utf = gen_const_xmlChar_ptr(n_utf, 0); 37145 len = gen_int(n_len, 1); 37146 37147 ret_val = xmlUTF8Strndup((const xmlChar *)utf, len); 37148 desret_xmlChar_ptr(ret_val); 37149 call_tests++; 37150 des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0); 37151 des_int(n_len, len, 1); 37152 xmlResetLastError(); 37153 if (mem_base != xmlMemBlocks()) { 37154 printf("Leak of %d blocks found in xmlUTF8Strndup", 37155 xmlMemBlocks() - mem_base); 37156 test_ret++; 37157 printf(" %d", n_utf); 37158 printf(" %d", n_len); 37159 printf("\n"); 37160 } 37161 } 37162 } 37163 function_tests++; 37164 37165 return(test_ret); 37166 } 37167 37168 37169 static int 37170 test_xmlUTF8Strpos(void) { 37171 int test_ret = 0; 37172 37173 int mem_base; 37174 const xmlChar * ret_val; 37175 xmlChar * utf; /* the input UTF8 * */ 37176 int n_utf; 37177 int pos; /* the position of the desired UTF8 char (in chars) */ 37178 int n_pos; 37179 37180 for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) { 37181 for (n_pos = 0;n_pos < gen_nb_int;n_pos++) { 37182 mem_base = xmlMemBlocks(); 37183 utf = gen_const_xmlChar_ptr(n_utf, 0); 37184 pos = gen_int(n_pos, 1); 37185 37186 ret_val = xmlUTF8Strpos((const xmlChar *)utf, pos); 37187 desret_const_xmlChar_ptr(ret_val); 37188 call_tests++; 37189 des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0); 37190 des_int(n_pos, pos, 1); 37191 xmlResetLastError(); 37192 if (mem_base != xmlMemBlocks()) { 37193 printf("Leak of %d blocks found in xmlUTF8Strpos", 37194 xmlMemBlocks() - mem_base); 37195 test_ret++; 37196 printf(" %d", n_utf); 37197 printf(" %d", n_pos); 37198 printf("\n"); 37199 } 37200 } 37201 } 37202 function_tests++; 37203 37204 return(test_ret); 37205 } 37206 37207 37208 static int 37209 test_xmlUTF8Strsize(void) { 37210 int test_ret = 0; 37211 37212 int mem_base; 37213 int ret_val; 37214 xmlChar * utf; /* a sequence of UTF-8 encoded bytes */ 37215 int n_utf; 37216 int len; /* the number of characters in the array */ 37217 int n_len; 37218 37219 for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) { 37220 for (n_len = 0;n_len < gen_nb_int;n_len++) { 37221 mem_base = xmlMemBlocks(); 37222 utf = gen_const_xmlChar_ptr(n_utf, 0); 37223 len = gen_int(n_len, 1); 37224 37225 ret_val = xmlUTF8Strsize((const xmlChar *)utf, len); 37226 desret_int(ret_val); 37227 call_tests++; 37228 des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0); 37229 des_int(n_len, len, 1); 37230 xmlResetLastError(); 37231 if (mem_base != xmlMemBlocks()) { 37232 printf("Leak of %d blocks found in xmlUTF8Strsize", 37233 xmlMemBlocks() - mem_base); 37234 test_ret++; 37235 printf(" %d", n_utf); 37236 printf(" %d", n_len); 37237 printf("\n"); 37238 } 37239 } 37240 } 37241 function_tests++; 37242 37243 return(test_ret); 37244 } 37245 37246 37247 static int 37248 test_xmlUTF8Strsub(void) { 37249 int test_ret = 0; 37250 37251 int mem_base; 37252 xmlChar * ret_val; 37253 xmlChar * utf; /* a sequence of UTF-8 encoded bytes */ 37254 int n_utf; 37255 int start; /* relative pos of first char */ 37256 int n_start; 37257 int len; /* total number to copy */ 37258 int n_len; 37259 37260 for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) { 37261 for (n_start = 0;n_start < gen_nb_int;n_start++) { 37262 for (n_len = 0;n_len < gen_nb_int;n_len++) { 37263 mem_base = xmlMemBlocks(); 37264 utf = gen_const_xmlChar_ptr(n_utf, 0); 37265 start = gen_int(n_start, 1); 37266 len = gen_int(n_len, 2); 37267 37268 ret_val = xmlUTF8Strsub((const xmlChar *)utf, start, len); 37269 desret_xmlChar_ptr(ret_val); 37270 call_tests++; 37271 des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0); 37272 des_int(n_start, start, 1); 37273 des_int(n_len, len, 2); 37274 xmlResetLastError(); 37275 if (mem_base != xmlMemBlocks()) { 37276 printf("Leak of %d blocks found in xmlUTF8Strsub", 37277 xmlMemBlocks() - mem_base); 37278 test_ret++; 37279 printf(" %d", n_utf); 37280 printf(" %d", n_start); 37281 printf(" %d", n_len); 37282 printf("\n"); 37283 } 37284 } 37285 } 37286 } 37287 function_tests++; 37288 37289 return(test_ret); 37290 } 37291 37292 static int 37293 test_xmlstring(void) { 37294 int test_ret = 0; 37295 37296 if (quiet == 0) printf("Testing xmlstring : 26 of 30 functions ...\n"); 37297 test_ret += test_xmlCharStrdup(); 37298 test_ret += test_xmlCharStrndup(); 37299 test_ret += test_xmlCheckUTF8(); 37300 test_ret += test_xmlGetUTF8Char(); 37301 test_ret += test_xmlStrEqual(); 37302 test_ret += test_xmlStrPrintf(); 37303 test_ret += test_xmlStrQEqual(); 37304 test_ret += test_xmlStrVPrintf(); 37305 test_ret += test_xmlStrcasecmp(); 37306 test_ret += test_xmlStrcasestr(); 37307 test_ret += test_xmlStrchr(); 37308 test_ret += test_xmlStrcmp(); 37309 test_ret += test_xmlStrdup(); 37310 test_ret += test_xmlStrlen(); 37311 test_ret += test_xmlStrncasecmp(); 37312 test_ret += test_xmlStrncatNew(); 37313 test_ret += test_xmlStrncmp(); 37314 test_ret += test_xmlStrndup(); 37315 test_ret += test_xmlStrstr(); 37316 test_ret += test_xmlStrsub(); 37317 test_ret += test_xmlUTF8Charcmp(); 37318 test_ret += test_xmlUTF8Size(); 37319 test_ret += test_xmlUTF8Strlen(); 37320 test_ret += test_xmlUTF8Strloc(); 37321 test_ret += test_xmlUTF8Strndup(); 37322 test_ret += test_xmlUTF8Strpos(); 37323 test_ret += test_xmlUTF8Strsize(); 37324 test_ret += test_xmlUTF8Strsub(); 37325 37326 if (test_ret != 0) 37327 printf("Module xmlstring: %d errors\n", test_ret); 37328 return(test_ret); 37329 } 37330 37331 static int 37332 test_xmlUCSIsAegeanNumbers(void) { 37333 int test_ret = 0; 37334 37335 #if defined(LIBXML_UNICODE_ENABLED) 37336 int mem_base; 37337 int ret_val; 37338 int code; /* UCS code point */ 37339 int n_code; 37340 37341 for (n_code = 0;n_code < gen_nb_int;n_code++) { 37342 mem_base = xmlMemBlocks(); 37343 code = gen_int(n_code, 0); 37344 37345 ret_val = xmlUCSIsAegeanNumbers(code); 37346 desret_int(ret_val); 37347 call_tests++; 37348 des_int(n_code, code, 0); 37349 xmlResetLastError(); 37350 if (mem_base != xmlMemBlocks()) { 37351 printf("Leak of %d blocks found in xmlUCSIsAegeanNumbers", 37352 xmlMemBlocks() - mem_base); 37353 test_ret++; 37354 printf(" %d", n_code); 37355 printf("\n"); 37356 } 37357 } 37358 function_tests++; 37359 #endif 37360 37361 return(test_ret); 37362 } 37363 37364 37365 static int 37366 test_xmlUCSIsAlphabeticPresentationForms(void) { 37367 int test_ret = 0; 37368 37369 #if defined(LIBXML_UNICODE_ENABLED) 37370 int mem_base; 37371 int ret_val; 37372 int code; /* UCS code point */ 37373 int n_code; 37374 37375 for (n_code = 0;n_code < gen_nb_int;n_code++) { 37376 mem_base = xmlMemBlocks(); 37377 code = gen_int(n_code, 0); 37378 37379 ret_val = xmlUCSIsAlphabeticPresentationForms(code); 37380 desret_int(ret_val); 37381 call_tests++; 37382 des_int(n_code, code, 0); 37383 xmlResetLastError(); 37384 if (mem_base != xmlMemBlocks()) { 37385 printf("Leak of %d blocks found in xmlUCSIsAlphabeticPresentationForms", 37386 xmlMemBlocks() - mem_base); 37387 test_ret++; 37388 printf(" %d", n_code); 37389 printf("\n"); 37390 } 37391 } 37392 function_tests++; 37393 #endif 37394 37395 return(test_ret); 37396 } 37397 37398 37399 static int 37400 test_xmlUCSIsArabic(void) { 37401 int test_ret = 0; 37402 37403 #if defined(LIBXML_UNICODE_ENABLED) 37404 int mem_base; 37405 int ret_val; 37406 int code; /* UCS code point */ 37407 int n_code; 37408 37409 for (n_code = 0;n_code < gen_nb_int;n_code++) { 37410 mem_base = xmlMemBlocks(); 37411 code = gen_int(n_code, 0); 37412 37413 ret_val = xmlUCSIsArabic(code); 37414 desret_int(ret_val); 37415 call_tests++; 37416 des_int(n_code, code, 0); 37417 xmlResetLastError(); 37418 if (mem_base != xmlMemBlocks()) { 37419 printf("Leak of %d blocks found in xmlUCSIsArabic", 37420 xmlMemBlocks() - mem_base); 37421 test_ret++; 37422 printf(" %d", n_code); 37423 printf("\n"); 37424 } 37425 } 37426 function_tests++; 37427 #endif 37428 37429 return(test_ret); 37430 } 37431 37432 37433 static int 37434 test_xmlUCSIsArabicPresentationFormsA(void) { 37435 int test_ret = 0; 37436 37437 #if defined(LIBXML_UNICODE_ENABLED) 37438 int mem_base; 37439 int ret_val; 37440 int code; /* UCS code point */ 37441 int n_code; 37442 37443 for (n_code = 0;n_code < gen_nb_int;n_code++) { 37444 mem_base = xmlMemBlocks(); 37445 code = gen_int(n_code, 0); 37446 37447 ret_val = xmlUCSIsArabicPresentationFormsA(code); 37448 desret_int(ret_val); 37449 call_tests++; 37450 des_int(n_code, code, 0); 37451 xmlResetLastError(); 37452 if (mem_base != xmlMemBlocks()) { 37453 printf("Leak of %d blocks found in xmlUCSIsArabicPresentationFormsA", 37454 xmlMemBlocks() - mem_base); 37455 test_ret++; 37456 printf(" %d", n_code); 37457 printf("\n"); 37458 } 37459 } 37460 function_tests++; 37461 #endif 37462 37463 return(test_ret); 37464 } 37465 37466 37467 static int 37468 test_xmlUCSIsArabicPresentationFormsB(void) { 37469 int test_ret = 0; 37470 37471 #if defined(LIBXML_UNICODE_ENABLED) 37472 int mem_base; 37473 int ret_val; 37474 int code; /* UCS code point */ 37475 int n_code; 37476 37477 for (n_code = 0;n_code < gen_nb_int;n_code++) { 37478 mem_base = xmlMemBlocks(); 37479 code = gen_int(n_code, 0); 37480 37481 ret_val = xmlUCSIsArabicPresentationFormsB(code); 37482 desret_int(ret_val); 37483 call_tests++; 37484 des_int(n_code, code, 0); 37485 xmlResetLastError(); 37486 if (mem_base != xmlMemBlocks()) { 37487 printf("Leak of %d blocks found in xmlUCSIsArabicPresentationFormsB", 37488 xmlMemBlocks() - mem_base); 37489 test_ret++; 37490 printf(" %d", n_code); 37491 printf("\n"); 37492 } 37493 } 37494 function_tests++; 37495 #endif 37496 37497 return(test_ret); 37498 } 37499 37500 37501 static int 37502 test_xmlUCSIsArmenian(void) { 37503 int test_ret = 0; 37504 37505 #if defined(LIBXML_UNICODE_ENABLED) 37506 int mem_base; 37507 int ret_val; 37508 int code; /* UCS code point */ 37509 int n_code; 37510 37511 for (n_code = 0;n_code < gen_nb_int;n_code++) { 37512 mem_base = xmlMemBlocks(); 37513 code = gen_int(n_code, 0); 37514 37515 ret_val = xmlUCSIsArmenian(code); 37516 desret_int(ret_val); 37517 call_tests++; 37518 des_int(n_code, code, 0); 37519 xmlResetLastError(); 37520 if (mem_base != xmlMemBlocks()) { 37521 printf("Leak of %d blocks found in xmlUCSIsArmenian", 37522 xmlMemBlocks() - mem_base); 37523 test_ret++; 37524 printf(" %d", n_code); 37525 printf("\n"); 37526 } 37527 } 37528 function_tests++; 37529 #endif 37530 37531 return(test_ret); 37532 } 37533 37534 37535 static int 37536 test_xmlUCSIsArrows(void) { 37537 int test_ret = 0; 37538 37539 #if defined(LIBXML_UNICODE_ENABLED) 37540 int mem_base; 37541 int ret_val; 37542 int code; /* UCS code point */ 37543 int n_code; 37544 37545 for (n_code = 0;n_code < gen_nb_int;n_code++) { 37546 mem_base = xmlMemBlocks(); 37547 code = gen_int(n_code, 0); 37548 37549 ret_val = xmlUCSIsArrows(code); 37550 desret_int(ret_val); 37551 call_tests++; 37552 des_int(n_code, code, 0); 37553 xmlResetLastError(); 37554 if (mem_base != xmlMemBlocks()) { 37555 printf("Leak of %d blocks found in xmlUCSIsArrows", 37556 xmlMemBlocks() - mem_base); 37557 test_ret++; 37558 printf(" %d", n_code); 37559 printf("\n"); 37560 } 37561 } 37562 function_tests++; 37563 #endif 37564 37565 return(test_ret); 37566 } 37567 37568 37569 static int 37570 test_xmlUCSIsBasicLatin(void) { 37571 int test_ret = 0; 37572 37573 #if defined(LIBXML_UNICODE_ENABLED) 37574 int mem_base; 37575 int ret_val; 37576 int code; /* UCS code point */ 37577 int n_code; 37578 37579 for (n_code = 0;n_code < gen_nb_int;n_code++) { 37580 mem_base = xmlMemBlocks(); 37581 code = gen_int(n_code, 0); 37582 37583 ret_val = xmlUCSIsBasicLatin(code); 37584 desret_int(ret_val); 37585 call_tests++; 37586 des_int(n_code, code, 0); 37587 xmlResetLastError(); 37588 if (mem_base != xmlMemBlocks()) { 37589 printf("Leak of %d blocks found in xmlUCSIsBasicLatin", 37590 xmlMemBlocks() - mem_base); 37591 test_ret++; 37592 printf(" %d", n_code); 37593 printf("\n"); 37594 } 37595 } 37596 function_tests++; 37597 #endif 37598 37599 return(test_ret); 37600 } 37601 37602 37603 static int 37604 test_xmlUCSIsBengali(void) { 37605 int test_ret = 0; 37606 37607 #if defined(LIBXML_UNICODE_ENABLED) 37608 int mem_base; 37609 int ret_val; 37610 int code; /* UCS code point */ 37611 int n_code; 37612 37613 for (n_code = 0;n_code < gen_nb_int;n_code++) { 37614 mem_base = xmlMemBlocks(); 37615 code = gen_int(n_code, 0); 37616 37617 ret_val = xmlUCSIsBengali(code); 37618 desret_int(ret_val); 37619 call_tests++; 37620 des_int(n_code, code, 0); 37621 xmlResetLastError(); 37622 if (mem_base != xmlMemBlocks()) { 37623 printf("Leak of %d blocks found in xmlUCSIsBengali", 37624 xmlMemBlocks() - mem_base); 37625 test_ret++; 37626 printf(" %d", n_code); 37627 printf("\n"); 37628 } 37629 } 37630 function_tests++; 37631 #endif 37632 37633 return(test_ret); 37634 } 37635 37636 37637 static int 37638 test_xmlUCSIsBlock(void) { 37639 int test_ret = 0; 37640 37641 #if defined(LIBXML_UNICODE_ENABLED) 37642 int mem_base; 37643 int ret_val; 37644 int code; /* UCS code point */ 37645 int n_code; 37646 char * block; /* UCS block name */ 37647 int n_block; 37648 37649 for (n_code = 0;n_code < gen_nb_int;n_code++) { 37650 for (n_block = 0;n_block < gen_nb_const_char_ptr;n_block++) { 37651 mem_base = xmlMemBlocks(); 37652 code = gen_int(n_code, 0); 37653 block = gen_const_char_ptr(n_block, 1); 37654 37655 ret_val = xmlUCSIsBlock(code, (const char *)block); 37656 desret_int(ret_val); 37657 call_tests++; 37658 des_int(n_code, code, 0); 37659 des_const_char_ptr(n_block, (const char *)block, 1); 37660 xmlResetLastError(); 37661 if (mem_base != xmlMemBlocks()) { 37662 printf("Leak of %d blocks found in xmlUCSIsBlock", 37663 xmlMemBlocks() - mem_base); 37664 test_ret++; 37665 printf(" %d", n_code); 37666 printf(" %d", n_block); 37667 printf("\n"); 37668 } 37669 } 37670 } 37671 function_tests++; 37672 #endif 37673 37674 return(test_ret); 37675 } 37676 37677 37678 static int 37679 test_xmlUCSIsBlockElements(void) { 37680 int test_ret = 0; 37681 37682 #if defined(LIBXML_UNICODE_ENABLED) 37683 int mem_base; 37684 int ret_val; 37685 int code; /* UCS code point */ 37686 int n_code; 37687 37688 for (n_code = 0;n_code < gen_nb_int;n_code++) { 37689 mem_base = xmlMemBlocks(); 37690 code = gen_int(n_code, 0); 37691 37692 ret_val = xmlUCSIsBlockElements(code); 37693 desret_int(ret_val); 37694 call_tests++; 37695 des_int(n_code, code, 0); 37696 xmlResetLastError(); 37697 if (mem_base != xmlMemBlocks()) { 37698 printf("Leak of %d blocks found in xmlUCSIsBlockElements", 37699 xmlMemBlocks() - mem_base); 37700 test_ret++; 37701 printf(" %d", n_code); 37702 printf("\n"); 37703 } 37704 } 37705 function_tests++; 37706 #endif 37707 37708 return(test_ret); 37709 } 37710 37711 37712 static int 37713 test_xmlUCSIsBopomofo(void) { 37714 int test_ret = 0; 37715 37716 #if defined(LIBXML_UNICODE_ENABLED) 37717 int mem_base; 37718 int ret_val; 37719 int code; /* UCS code point */ 37720 int n_code; 37721 37722 for (n_code = 0;n_code < gen_nb_int;n_code++) { 37723 mem_base = xmlMemBlocks(); 37724 code = gen_int(n_code, 0); 37725 37726 ret_val = xmlUCSIsBopomofo(code); 37727 desret_int(ret_val); 37728 call_tests++; 37729 des_int(n_code, code, 0); 37730 xmlResetLastError(); 37731 if (mem_base != xmlMemBlocks()) { 37732 printf("Leak of %d blocks found in xmlUCSIsBopomofo", 37733 xmlMemBlocks() - mem_base); 37734 test_ret++; 37735 printf(" %d", n_code); 37736 printf("\n"); 37737 } 37738 } 37739 function_tests++; 37740 #endif 37741 37742 return(test_ret); 37743 } 37744 37745 37746 static int 37747 test_xmlUCSIsBopomofoExtended(void) { 37748 int test_ret = 0; 37749 37750 #if defined(LIBXML_UNICODE_ENABLED) 37751 int mem_base; 37752 int ret_val; 37753 int code; /* UCS code point */ 37754 int n_code; 37755 37756 for (n_code = 0;n_code < gen_nb_int;n_code++) { 37757 mem_base = xmlMemBlocks(); 37758 code = gen_int(n_code, 0); 37759 37760 ret_val = xmlUCSIsBopomofoExtended(code); 37761 desret_int(ret_val); 37762 call_tests++; 37763 des_int(n_code, code, 0); 37764 xmlResetLastError(); 37765 if (mem_base != xmlMemBlocks()) { 37766 printf("Leak of %d blocks found in xmlUCSIsBopomofoExtended", 37767 xmlMemBlocks() - mem_base); 37768 test_ret++; 37769 printf(" %d", n_code); 37770 printf("\n"); 37771 } 37772 } 37773 function_tests++; 37774 #endif 37775 37776 return(test_ret); 37777 } 37778 37779 37780 static int 37781 test_xmlUCSIsBoxDrawing(void) { 37782 int test_ret = 0; 37783 37784 #if defined(LIBXML_UNICODE_ENABLED) 37785 int mem_base; 37786 int ret_val; 37787 int code; /* UCS code point */ 37788 int n_code; 37789 37790 for (n_code = 0;n_code < gen_nb_int;n_code++) { 37791 mem_base = xmlMemBlocks(); 37792 code = gen_int(n_code, 0); 37793 37794 ret_val = xmlUCSIsBoxDrawing(code); 37795 desret_int(ret_val); 37796 call_tests++; 37797 des_int(n_code, code, 0); 37798 xmlResetLastError(); 37799 if (mem_base != xmlMemBlocks()) { 37800 printf("Leak of %d blocks found in xmlUCSIsBoxDrawing", 37801 xmlMemBlocks() - mem_base); 37802 test_ret++; 37803 printf(" %d", n_code); 37804 printf("\n"); 37805 } 37806 } 37807 function_tests++; 37808 #endif 37809 37810 return(test_ret); 37811 } 37812 37813 37814 static int 37815 test_xmlUCSIsBraillePatterns(void) { 37816 int test_ret = 0; 37817 37818 #if defined(LIBXML_UNICODE_ENABLED) 37819 int mem_base; 37820 int ret_val; 37821 int code; /* UCS code point */ 37822 int n_code; 37823 37824 for (n_code = 0;n_code < gen_nb_int;n_code++) { 37825 mem_base = xmlMemBlocks(); 37826 code = gen_int(n_code, 0); 37827 37828 ret_val = xmlUCSIsBraillePatterns(code); 37829 desret_int(ret_val); 37830 call_tests++; 37831 des_int(n_code, code, 0); 37832 xmlResetLastError(); 37833 if (mem_base != xmlMemBlocks()) { 37834 printf("Leak of %d blocks found in xmlUCSIsBraillePatterns", 37835 xmlMemBlocks() - mem_base); 37836 test_ret++; 37837 printf(" %d", n_code); 37838 printf("\n"); 37839 } 37840 } 37841 function_tests++; 37842 #endif 37843 37844 return(test_ret); 37845 } 37846 37847 37848 static int 37849 test_xmlUCSIsBuhid(void) { 37850 int test_ret = 0; 37851 37852 #if defined(LIBXML_UNICODE_ENABLED) 37853 int mem_base; 37854 int ret_val; 37855 int code; /* UCS code point */ 37856 int n_code; 37857 37858 for (n_code = 0;n_code < gen_nb_int;n_code++) { 37859 mem_base = xmlMemBlocks(); 37860 code = gen_int(n_code, 0); 37861 37862 ret_val = xmlUCSIsBuhid(code); 37863 desret_int(ret_val); 37864 call_tests++; 37865 des_int(n_code, code, 0); 37866 xmlResetLastError(); 37867 if (mem_base != xmlMemBlocks()) { 37868 printf("Leak of %d blocks found in xmlUCSIsBuhid", 37869 xmlMemBlocks() - mem_base); 37870 test_ret++; 37871 printf(" %d", n_code); 37872 printf("\n"); 37873 } 37874 } 37875 function_tests++; 37876 #endif 37877 37878 return(test_ret); 37879 } 37880 37881 37882 static int 37883 test_xmlUCSIsByzantineMusicalSymbols(void) { 37884 int test_ret = 0; 37885 37886 #if defined(LIBXML_UNICODE_ENABLED) 37887 int mem_base; 37888 int ret_val; 37889 int code; /* UCS code point */ 37890 int n_code; 37891 37892 for (n_code = 0;n_code < gen_nb_int;n_code++) { 37893 mem_base = xmlMemBlocks(); 37894 code = gen_int(n_code, 0); 37895 37896 ret_val = xmlUCSIsByzantineMusicalSymbols(code); 37897 desret_int(ret_val); 37898 call_tests++; 37899 des_int(n_code, code, 0); 37900 xmlResetLastError(); 37901 if (mem_base != xmlMemBlocks()) { 37902 printf("Leak of %d blocks found in xmlUCSIsByzantineMusicalSymbols", 37903 xmlMemBlocks() - mem_base); 37904 test_ret++; 37905 printf(" %d", n_code); 37906 printf("\n"); 37907 } 37908 } 37909 function_tests++; 37910 #endif 37911 37912 return(test_ret); 37913 } 37914 37915 37916 static int 37917 test_xmlUCSIsCJKCompatibility(void) { 37918 int test_ret = 0; 37919 37920 #if defined(LIBXML_UNICODE_ENABLED) 37921 int mem_base; 37922 int ret_val; 37923 int code; /* UCS code point */ 37924 int n_code; 37925 37926 for (n_code = 0;n_code < gen_nb_int;n_code++) { 37927 mem_base = xmlMemBlocks(); 37928 code = gen_int(n_code, 0); 37929 37930 ret_val = xmlUCSIsCJKCompatibility(code); 37931 desret_int(ret_val); 37932 call_tests++; 37933 des_int(n_code, code, 0); 37934 xmlResetLastError(); 37935 if (mem_base != xmlMemBlocks()) { 37936 printf("Leak of %d blocks found in xmlUCSIsCJKCompatibility", 37937 xmlMemBlocks() - mem_base); 37938 test_ret++; 37939 printf(" %d", n_code); 37940 printf("\n"); 37941 } 37942 } 37943 function_tests++; 37944 #endif 37945 37946 return(test_ret); 37947 } 37948 37949 37950 static int 37951 test_xmlUCSIsCJKCompatibilityForms(void) { 37952 int test_ret = 0; 37953 37954 #if defined(LIBXML_UNICODE_ENABLED) 37955 int mem_base; 37956 int ret_val; 37957 int code; /* UCS code point */ 37958 int n_code; 37959 37960 for (n_code = 0;n_code < gen_nb_int;n_code++) { 37961 mem_base = xmlMemBlocks(); 37962 code = gen_int(n_code, 0); 37963 37964 ret_val = xmlUCSIsCJKCompatibilityForms(code); 37965 desret_int(ret_val); 37966 call_tests++; 37967 des_int(n_code, code, 0); 37968 xmlResetLastError(); 37969 if (mem_base != xmlMemBlocks()) { 37970 printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityForms", 37971 xmlMemBlocks() - mem_base); 37972 test_ret++; 37973 printf(" %d", n_code); 37974 printf("\n"); 37975 } 37976 } 37977 function_tests++; 37978 #endif 37979 37980 return(test_ret); 37981 } 37982 37983 37984 static int 37985 test_xmlUCSIsCJKCompatibilityIdeographs(void) { 37986 int test_ret = 0; 37987 37988 #if defined(LIBXML_UNICODE_ENABLED) 37989 int mem_base; 37990 int ret_val; 37991 int code; /* UCS code point */ 37992 int n_code; 37993 37994 for (n_code = 0;n_code < gen_nb_int;n_code++) { 37995 mem_base = xmlMemBlocks(); 37996 code = gen_int(n_code, 0); 37997 37998 ret_val = xmlUCSIsCJKCompatibilityIdeographs(code); 37999 desret_int(ret_val); 38000 call_tests++; 38001 des_int(n_code, code, 0); 38002 xmlResetLastError(); 38003 if (mem_base != xmlMemBlocks()) { 38004 printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityIdeographs", 38005 xmlMemBlocks() - mem_base); 38006 test_ret++; 38007 printf(" %d", n_code); 38008 printf("\n"); 38009 } 38010 } 38011 function_tests++; 38012 #endif 38013 38014 return(test_ret); 38015 } 38016 38017 38018 static int 38019 test_xmlUCSIsCJKCompatibilityIdeographsSupplement(void) { 38020 int test_ret = 0; 38021 38022 #if defined(LIBXML_UNICODE_ENABLED) 38023 int mem_base; 38024 int ret_val; 38025 int code; /* UCS code point */ 38026 int n_code; 38027 38028 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38029 mem_base = xmlMemBlocks(); 38030 code = gen_int(n_code, 0); 38031 38032 ret_val = xmlUCSIsCJKCompatibilityIdeographsSupplement(code); 38033 desret_int(ret_val); 38034 call_tests++; 38035 des_int(n_code, code, 0); 38036 xmlResetLastError(); 38037 if (mem_base != xmlMemBlocks()) { 38038 printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityIdeographsSupplement", 38039 xmlMemBlocks() - mem_base); 38040 test_ret++; 38041 printf(" %d", n_code); 38042 printf("\n"); 38043 } 38044 } 38045 function_tests++; 38046 #endif 38047 38048 return(test_ret); 38049 } 38050 38051 38052 static int 38053 test_xmlUCSIsCJKRadicalsSupplement(void) { 38054 int test_ret = 0; 38055 38056 #if defined(LIBXML_UNICODE_ENABLED) 38057 int mem_base; 38058 int ret_val; 38059 int code; /* UCS code point */ 38060 int n_code; 38061 38062 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38063 mem_base = xmlMemBlocks(); 38064 code = gen_int(n_code, 0); 38065 38066 ret_val = xmlUCSIsCJKRadicalsSupplement(code); 38067 desret_int(ret_val); 38068 call_tests++; 38069 des_int(n_code, code, 0); 38070 xmlResetLastError(); 38071 if (mem_base != xmlMemBlocks()) { 38072 printf("Leak of %d blocks found in xmlUCSIsCJKRadicalsSupplement", 38073 xmlMemBlocks() - mem_base); 38074 test_ret++; 38075 printf(" %d", n_code); 38076 printf("\n"); 38077 } 38078 } 38079 function_tests++; 38080 #endif 38081 38082 return(test_ret); 38083 } 38084 38085 38086 static int 38087 test_xmlUCSIsCJKSymbolsandPunctuation(void) { 38088 int test_ret = 0; 38089 38090 #if defined(LIBXML_UNICODE_ENABLED) 38091 int mem_base; 38092 int ret_val; 38093 int code; /* UCS code point */ 38094 int n_code; 38095 38096 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38097 mem_base = xmlMemBlocks(); 38098 code = gen_int(n_code, 0); 38099 38100 ret_val = xmlUCSIsCJKSymbolsandPunctuation(code); 38101 desret_int(ret_val); 38102 call_tests++; 38103 des_int(n_code, code, 0); 38104 xmlResetLastError(); 38105 if (mem_base != xmlMemBlocks()) { 38106 printf("Leak of %d blocks found in xmlUCSIsCJKSymbolsandPunctuation", 38107 xmlMemBlocks() - mem_base); 38108 test_ret++; 38109 printf(" %d", n_code); 38110 printf("\n"); 38111 } 38112 } 38113 function_tests++; 38114 #endif 38115 38116 return(test_ret); 38117 } 38118 38119 38120 static int 38121 test_xmlUCSIsCJKUnifiedIdeographs(void) { 38122 int test_ret = 0; 38123 38124 #if defined(LIBXML_UNICODE_ENABLED) 38125 int mem_base; 38126 int ret_val; 38127 int code; /* UCS code point */ 38128 int n_code; 38129 38130 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38131 mem_base = xmlMemBlocks(); 38132 code = gen_int(n_code, 0); 38133 38134 ret_val = xmlUCSIsCJKUnifiedIdeographs(code); 38135 desret_int(ret_val); 38136 call_tests++; 38137 des_int(n_code, code, 0); 38138 xmlResetLastError(); 38139 if (mem_base != xmlMemBlocks()) { 38140 printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographs", 38141 xmlMemBlocks() - mem_base); 38142 test_ret++; 38143 printf(" %d", n_code); 38144 printf("\n"); 38145 } 38146 } 38147 function_tests++; 38148 #endif 38149 38150 return(test_ret); 38151 } 38152 38153 38154 static int 38155 test_xmlUCSIsCJKUnifiedIdeographsExtensionA(void) { 38156 int test_ret = 0; 38157 38158 #if defined(LIBXML_UNICODE_ENABLED) 38159 int mem_base; 38160 int ret_val; 38161 int code; /* UCS code point */ 38162 int n_code; 38163 38164 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38165 mem_base = xmlMemBlocks(); 38166 code = gen_int(n_code, 0); 38167 38168 ret_val = xmlUCSIsCJKUnifiedIdeographsExtensionA(code); 38169 desret_int(ret_val); 38170 call_tests++; 38171 des_int(n_code, code, 0); 38172 xmlResetLastError(); 38173 if (mem_base != xmlMemBlocks()) { 38174 printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographsExtensionA", 38175 xmlMemBlocks() - mem_base); 38176 test_ret++; 38177 printf(" %d", n_code); 38178 printf("\n"); 38179 } 38180 } 38181 function_tests++; 38182 #endif 38183 38184 return(test_ret); 38185 } 38186 38187 38188 static int 38189 test_xmlUCSIsCJKUnifiedIdeographsExtensionB(void) { 38190 int test_ret = 0; 38191 38192 #if defined(LIBXML_UNICODE_ENABLED) 38193 int mem_base; 38194 int ret_val; 38195 int code; /* UCS code point */ 38196 int n_code; 38197 38198 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38199 mem_base = xmlMemBlocks(); 38200 code = gen_int(n_code, 0); 38201 38202 ret_val = xmlUCSIsCJKUnifiedIdeographsExtensionB(code); 38203 desret_int(ret_val); 38204 call_tests++; 38205 des_int(n_code, code, 0); 38206 xmlResetLastError(); 38207 if (mem_base != xmlMemBlocks()) { 38208 printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographsExtensionB", 38209 xmlMemBlocks() - mem_base); 38210 test_ret++; 38211 printf(" %d", n_code); 38212 printf("\n"); 38213 } 38214 } 38215 function_tests++; 38216 #endif 38217 38218 return(test_ret); 38219 } 38220 38221 38222 static int 38223 test_xmlUCSIsCat(void) { 38224 int test_ret = 0; 38225 38226 #if defined(LIBXML_UNICODE_ENABLED) 38227 int mem_base; 38228 int ret_val; 38229 int code; /* UCS code point */ 38230 int n_code; 38231 char * cat; /* UCS Category name */ 38232 int n_cat; 38233 38234 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38235 for (n_cat = 0;n_cat < gen_nb_const_char_ptr;n_cat++) { 38236 mem_base = xmlMemBlocks(); 38237 code = gen_int(n_code, 0); 38238 cat = gen_const_char_ptr(n_cat, 1); 38239 38240 ret_val = xmlUCSIsCat(code, (const char *)cat); 38241 desret_int(ret_val); 38242 call_tests++; 38243 des_int(n_code, code, 0); 38244 des_const_char_ptr(n_cat, (const char *)cat, 1); 38245 xmlResetLastError(); 38246 if (mem_base != xmlMemBlocks()) { 38247 printf("Leak of %d blocks found in xmlUCSIsCat", 38248 xmlMemBlocks() - mem_base); 38249 test_ret++; 38250 printf(" %d", n_code); 38251 printf(" %d", n_cat); 38252 printf("\n"); 38253 } 38254 } 38255 } 38256 function_tests++; 38257 #endif 38258 38259 return(test_ret); 38260 } 38261 38262 38263 static int 38264 test_xmlUCSIsCatC(void) { 38265 int test_ret = 0; 38266 38267 #if defined(LIBXML_UNICODE_ENABLED) 38268 int mem_base; 38269 int ret_val; 38270 int code; /* UCS code point */ 38271 int n_code; 38272 38273 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38274 mem_base = xmlMemBlocks(); 38275 code = gen_int(n_code, 0); 38276 38277 ret_val = xmlUCSIsCatC(code); 38278 desret_int(ret_val); 38279 call_tests++; 38280 des_int(n_code, code, 0); 38281 xmlResetLastError(); 38282 if (mem_base != xmlMemBlocks()) { 38283 printf("Leak of %d blocks found in xmlUCSIsCatC", 38284 xmlMemBlocks() - mem_base); 38285 test_ret++; 38286 printf(" %d", n_code); 38287 printf("\n"); 38288 } 38289 } 38290 function_tests++; 38291 #endif 38292 38293 return(test_ret); 38294 } 38295 38296 38297 static int 38298 test_xmlUCSIsCatCc(void) { 38299 int test_ret = 0; 38300 38301 #if defined(LIBXML_UNICODE_ENABLED) 38302 int mem_base; 38303 int ret_val; 38304 int code; /* UCS code point */ 38305 int n_code; 38306 38307 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38308 mem_base = xmlMemBlocks(); 38309 code = gen_int(n_code, 0); 38310 38311 ret_val = xmlUCSIsCatCc(code); 38312 desret_int(ret_val); 38313 call_tests++; 38314 des_int(n_code, code, 0); 38315 xmlResetLastError(); 38316 if (mem_base != xmlMemBlocks()) { 38317 printf("Leak of %d blocks found in xmlUCSIsCatCc", 38318 xmlMemBlocks() - mem_base); 38319 test_ret++; 38320 printf(" %d", n_code); 38321 printf("\n"); 38322 } 38323 } 38324 function_tests++; 38325 #endif 38326 38327 return(test_ret); 38328 } 38329 38330 38331 static int 38332 test_xmlUCSIsCatCf(void) { 38333 int test_ret = 0; 38334 38335 #if defined(LIBXML_UNICODE_ENABLED) 38336 int mem_base; 38337 int ret_val; 38338 int code; /* UCS code point */ 38339 int n_code; 38340 38341 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38342 mem_base = xmlMemBlocks(); 38343 code = gen_int(n_code, 0); 38344 38345 ret_val = xmlUCSIsCatCf(code); 38346 desret_int(ret_val); 38347 call_tests++; 38348 des_int(n_code, code, 0); 38349 xmlResetLastError(); 38350 if (mem_base != xmlMemBlocks()) { 38351 printf("Leak of %d blocks found in xmlUCSIsCatCf", 38352 xmlMemBlocks() - mem_base); 38353 test_ret++; 38354 printf(" %d", n_code); 38355 printf("\n"); 38356 } 38357 } 38358 function_tests++; 38359 #endif 38360 38361 return(test_ret); 38362 } 38363 38364 38365 static int 38366 test_xmlUCSIsCatCo(void) { 38367 int test_ret = 0; 38368 38369 #if defined(LIBXML_UNICODE_ENABLED) 38370 int mem_base; 38371 int ret_val; 38372 int code; /* UCS code point */ 38373 int n_code; 38374 38375 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38376 mem_base = xmlMemBlocks(); 38377 code = gen_int(n_code, 0); 38378 38379 ret_val = xmlUCSIsCatCo(code); 38380 desret_int(ret_val); 38381 call_tests++; 38382 des_int(n_code, code, 0); 38383 xmlResetLastError(); 38384 if (mem_base != xmlMemBlocks()) { 38385 printf("Leak of %d blocks found in xmlUCSIsCatCo", 38386 xmlMemBlocks() - mem_base); 38387 test_ret++; 38388 printf(" %d", n_code); 38389 printf("\n"); 38390 } 38391 } 38392 function_tests++; 38393 #endif 38394 38395 return(test_ret); 38396 } 38397 38398 38399 static int 38400 test_xmlUCSIsCatCs(void) { 38401 int test_ret = 0; 38402 38403 #if defined(LIBXML_UNICODE_ENABLED) 38404 int mem_base; 38405 int ret_val; 38406 int code; /* UCS code point */ 38407 int n_code; 38408 38409 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38410 mem_base = xmlMemBlocks(); 38411 code = gen_int(n_code, 0); 38412 38413 ret_val = xmlUCSIsCatCs(code); 38414 desret_int(ret_val); 38415 call_tests++; 38416 des_int(n_code, code, 0); 38417 xmlResetLastError(); 38418 if (mem_base != xmlMemBlocks()) { 38419 printf("Leak of %d blocks found in xmlUCSIsCatCs", 38420 xmlMemBlocks() - mem_base); 38421 test_ret++; 38422 printf(" %d", n_code); 38423 printf("\n"); 38424 } 38425 } 38426 function_tests++; 38427 #endif 38428 38429 return(test_ret); 38430 } 38431 38432 38433 static int 38434 test_xmlUCSIsCatL(void) { 38435 int test_ret = 0; 38436 38437 #if defined(LIBXML_UNICODE_ENABLED) 38438 int mem_base; 38439 int ret_val; 38440 int code; /* UCS code point */ 38441 int n_code; 38442 38443 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38444 mem_base = xmlMemBlocks(); 38445 code = gen_int(n_code, 0); 38446 38447 ret_val = xmlUCSIsCatL(code); 38448 desret_int(ret_val); 38449 call_tests++; 38450 des_int(n_code, code, 0); 38451 xmlResetLastError(); 38452 if (mem_base != xmlMemBlocks()) { 38453 printf("Leak of %d blocks found in xmlUCSIsCatL", 38454 xmlMemBlocks() - mem_base); 38455 test_ret++; 38456 printf(" %d", n_code); 38457 printf("\n"); 38458 } 38459 } 38460 function_tests++; 38461 #endif 38462 38463 return(test_ret); 38464 } 38465 38466 38467 static int 38468 test_xmlUCSIsCatLl(void) { 38469 int test_ret = 0; 38470 38471 #if defined(LIBXML_UNICODE_ENABLED) 38472 int mem_base; 38473 int ret_val; 38474 int code; /* UCS code point */ 38475 int n_code; 38476 38477 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38478 mem_base = xmlMemBlocks(); 38479 code = gen_int(n_code, 0); 38480 38481 ret_val = xmlUCSIsCatLl(code); 38482 desret_int(ret_val); 38483 call_tests++; 38484 des_int(n_code, code, 0); 38485 xmlResetLastError(); 38486 if (mem_base != xmlMemBlocks()) { 38487 printf("Leak of %d blocks found in xmlUCSIsCatLl", 38488 xmlMemBlocks() - mem_base); 38489 test_ret++; 38490 printf(" %d", n_code); 38491 printf("\n"); 38492 } 38493 } 38494 function_tests++; 38495 #endif 38496 38497 return(test_ret); 38498 } 38499 38500 38501 static int 38502 test_xmlUCSIsCatLm(void) { 38503 int test_ret = 0; 38504 38505 #if defined(LIBXML_UNICODE_ENABLED) 38506 int mem_base; 38507 int ret_val; 38508 int code; /* UCS code point */ 38509 int n_code; 38510 38511 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38512 mem_base = xmlMemBlocks(); 38513 code = gen_int(n_code, 0); 38514 38515 ret_val = xmlUCSIsCatLm(code); 38516 desret_int(ret_val); 38517 call_tests++; 38518 des_int(n_code, code, 0); 38519 xmlResetLastError(); 38520 if (mem_base != xmlMemBlocks()) { 38521 printf("Leak of %d blocks found in xmlUCSIsCatLm", 38522 xmlMemBlocks() - mem_base); 38523 test_ret++; 38524 printf(" %d", n_code); 38525 printf("\n"); 38526 } 38527 } 38528 function_tests++; 38529 #endif 38530 38531 return(test_ret); 38532 } 38533 38534 38535 static int 38536 test_xmlUCSIsCatLo(void) { 38537 int test_ret = 0; 38538 38539 #if defined(LIBXML_UNICODE_ENABLED) 38540 int mem_base; 38541 int ret_val; 38542 int code; /* UCS code point */ 38543 int n_code; 38544 38545 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38546 mem_base = xmlMemBlocks(); 38547 code = gen_int(n_code, 0); 38548 38549 ret_val = xmlUCSIsCatLo(code); 38550 desret_int(ret_val); 38551 call_tests++; 38552 des_int(n_code, code, 0); 38553 xmlResetLastError(); 38554 if (mem_base != xmlMemBlocks()) { 38555 printf("Leak of %d blocks found in xmlUCSIsCatLo", 38556 xmlMemBlocks() - mem_base); 38557 test_ret++; 38558 printf(" %d", n_code); 38559 printf("\n"); 38560 } 38561 } 38562 function_tests++; 38563 #endif 38564 38565 return(test_ret); 38566 } 38567 38568 38569 static int 38570 test_xmlUCSIsCatLt(void) { 38571 int test_ret = 0; 38572 38573 #if defined(LIBXML_UNICODE_ENABLED) 38574 int mem_base; 38575 int ret_val; 38576 int code; /* UCS code point */ 38577 int n_code; 38578 38579 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38580 mem_base = xmlMemBlocks(); 38581 code = gen_int(n_code, 0); 38582 38583 ret_val = xmlUCSIsCatLt(code); 38584 desret_int(ret_val); 38585 call_tests++; 38586 des_int(n_code, code, 0); 38587 xmlResetLastError(); 38588 if (mem_base != xmlMemBlocks()) { 38589 printf("Leak of %d blocks found in xmlUCSIsCatLt", 38590 xmlMemBlocks() - mem_base); 38591 test_ret++; 38592 printf(" %d", n_code); 38593 printf("\n"); 38594 } 38595 } 38596 function_tests++; 38597 #endif 38598 38599 return(test_ret); 38600 } 38601 38602 38603 static int 38604 test_xmlUCSIsCatLu(void) { 38605 int test_ret = 0; 38606 38607 #if defined(LIBXML_UNICODE_ENABLED) 38608 int mem_base; 38609 int ret_val; 38610 int code; /* UCS code point */ 38611 int n_code; 38612 38613 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38614 mem_base = xmlMemBlocks(); 38615 code = gen_int(n_code, 0); 38616 38617 ret_val = xmlUCSIsCatLu(code); 38618 desret_int(ret_val); 38619 call_tests++; 38620 des_int(n_code, code, 0); 38621 xmlResetLastError(); 38622 if (mem_base != xmlMemBlocks()) { 38623 printf("Leak of %d blocks found in xmlUCSIsCatLu", 38624 xmlMemBlocks() - mem_base); 38625 test_ret++; 38626 printf(" %d", n_code); 38627 printf("\n"); 38628 } 38629 } 38630 function_tests++; 38631 #endif 38632 38633 return(test_ret); 38634 } 38635 38636 38637 static int 38638 test_xmlUCSIsCatM(void) { 38639 int test_ret = 0; 38640 38641 #if defined(LIBXML_UNICODE_ENABLED) 38642 int mem_base; 38643 int ret_val; 38644 int code; /* UCS code point */ 38645 int n_code; 38646 38647 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38648 mem_base = xmlMemBlocks(); 38649 code = gen_int(n_code, 0); 38650 38651 ret_val = xmlUCSIsCatM(code); 38652 desret_int(ret_val); 38653 call_tests++; 38654 des_int(n_code, code, 0); 38655 xmlResetLastError(); 38656 if (mem_base != xmlMemBlocks()) { 38657 printf("Leak of %d blocks found in xmlUCSIsCatM", 38658 xmlMemBlocks() - mem_base); 38659 test_ret++; 38660 printf(" %d", n_code); 38661 printf("\n"); 38662 } 38663 } 38664 function_tests++; 38665 #endif 38666 38667 return(test_ret); 38668 } 38669 38670 38671 static int 38672 test_xmlUCSIsCatMc(void) { 38673 int test_ret = 0; 38674 38675 #if defined(LIBXML_UNICODE_ENABLED) 38676 int mem_base; 38677 int ret_val; 38678 int code; /* UCS code point */ 38679 int n_code; 38680 38681 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38682 mem_base = xmlMemBlocks(); 38683 code = gen_int(n_code, 0); 38684 38685 ret_val = xmlUCSIsCatMc(code); 38686 desret_int(ret_val); 38687 call_tests++; 38688 des_int(n_code, code, 0); 38689 xmlResetLastError(); 38690 if (mem_base != xmlMemBlocks()) { 38691 printf("Leak of %d blocks found in xmlUCSIsCatMc", 38692 xmlMemBlocks() - mem_base); 38693 test_ret++; 38694 printf(" %d", n_code); 38695 printf("\n"); 38696 } 38697 } 38698 function_tests++; 38699 #endif 38700 38701 return(test_ret); 38702 } 38703 38704 38705 static int 38706 test_xmlUCSIsCatMe(void) { 38707 int test_ret = 0; 38708 38709 #if defined(LIBXML_UNICODE_ENABLED) 38710 int mem_base; 38711 int ret_val; 38712 int code; /* UCS code point */ 38713 int n_code; 38714 38715 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38716 mem_base = xmlMemBlocks(); 38717 code = gen_int(n_code, 0); 38718 38719 ret_val = xmlUCSIsCatMe(code); 38720 desret_int(ret_val); 38721 call_tests++; 38722 des_int(n_code, code, 0); 38723 xmlResetLastError(); 38724 if (mem_base != xmlMemBlocks()) { 38725 printf("Leak of %d blocks found in xmlUCSIsCatMe", 38726 xmlMemBlocks() - mem_base); 38727 test_ret++; 38728 printf(" %d", n_code); 38729 printf("\n"); 38730 } 38731 } 38732 function_tests++; 38733 #endif 38734 38735 return(test_ret); 38736 } 38737 38738 38739 static int 38740 test_xmlUCSIsCatMn(void) { 38741 int test_ret = 0; 38742 38743 #if defined(LIBXML_UNICODE_ENABLED) 38744 int mem_base; 38745 int ret_val; 38746 int code; /* UCS code point */ 38747 int n_code; 38748 38749 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38750 mem_base = xmlMemBlocks(); 38751 code = gen_int(n_code, 0); 38752 38753 ret_val = xmlUCSIsCatMn(code); 38754 desret_int(ret_val); 38755 call_tests++; 38756 des_int(n_code, code, 0); 38757 xmlResetLastError(); 38758 if (mem_base != xmlMemBlocks()) { 38759 printf("Leak of %d blocks found in xmlUCSIsCatMn", 38760 xmlMemBlocks() - mem_base); 38761 test_ret++; 38762 printf(" %d", n_code); 38763 printf("\n"); 38764 } 38765 } 38766 function_tests++; 38767 #endif 38768 38769 return(test_ret); 38770 } 38771 38772 38773 static int 38774 test_xmlUCSIsCatN(void) { 38775 int test_ret = 0; 38776 38777 #if defined(LIBXML_UNICODE_ENABLED) 38778 int mem_base; 38779 int ret_val; 38780 int code; /* UCS code point */ 38781 int n_code; 38782 38783 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38784 mem_base = xmlMemBlocks(); 38785 code = gen_int(n_code, 0); 38786 38787 ret_val = xmlUCSIsCatN(code); 38788 desret_int(ret_val); 38789 call_tests++; 38790 des_int(n_code, code, 0); 38791 xmlResetLastError(); 38792 if (mem_base != xmlMemBlocks()) { 38793 printf("Leak of %d blocks found in xmlUCSIsCatN", 38794 xmlMemBlocks() - mem_base); 38795 test_ret++; 38796 printf(" %d", n_code); 38797 printf("\n"); 38798 } 38799 } 38800 function_tests++; 38801 #endif 38802 38803 return(test_ret); 38804 } 38805 38806 38807 static int 38808 test_xmlUCSIsCatNd(void) { 38809 int test_ret = 0; 38810 38811 #if defined(LIBXML_UNICODE_ENABLED) 38812 int mem_base; 38813 int ret_val; 38814 int code; /* UCS code point */ 38815 int n_code; 38816 38817 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38818 mem_base = xmlMemBlocks(); 38819 code = gen_int(n_code, 0); 38820 38821 ret_val = xmlUCSIsCatNd(code); 38822 desret_int(ret_val); 38823 call_tests++; 38824 des_int(n_code, code, 0); 38825 xmlResetLastError(); 38826 if (mem_base != xmlMemBlocks()) { 38827 printf("Leak of %d blocks found in xmlUCSIsCatNd", 38828 xmlMemBlocks() - mem_base); 38829 test_ret++; 38830 printf(" %d", n_code); 38831 printf("\n"); 38832 } 38833 } 38834 function_tests++; 38835 #endif 38836 38837 return(test_ret); 38838 } 38839 38840 38841 static int 38842 test_xmlUCSIsCatNl(void) { 38843 int test_ret = 0; 38844 38845 #if defined(LIBXML_UNICODE_ENABLED) 38846 int mem_base; 38847 int ret_val; 38848 int code; /* UCS code point */ 38849 int n_code; 38850 38851 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38852 mem_base = xmlMemBlocks(); 38853 code = gen_int(n_code, 0); 38854 38855 ret_val = xmlUCSIsCatNl(code); 38856 desret_int(ret_val); 38857 call_tests++; 38858 des_int(n_code, code, 0); 38859 xmlResetLastError(); 38860 if (mem_base != xmlMemBlocks()) { 38861 printf("Leak of %d blocks found in xmlUCSIsCatNl", 38862 xmlMemBlocks() - mem_base); 38863 test_ret++; 38864 printf(" %d", n_code); 38865 printf("\n"); 38866 } 38867 } 38868 function_tests++; 38869 #endif 38870 38871 return(test_ret); 38872 } 38873 38874 38875 static int 38876 test_xmlUCSIsCatNo(void) { 38877 int test_ret = 0; 38878 38879 #if defined(LIBXML_UNICODE_ENABLED) 38880 int mem_base; 38881 int ret_val; 38882 int code; /* UCS code point */ 38883 int n_code; 38884 38885 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38886 mem_base = xmlMemBlocks(); 38887 code = gen_int(n_code, 0); 38888 38889 ret_val = xmlUCSIsCatNo(code); 38890 desret_int(ret_val); 38891 call_tests++; 38892 des_int(n_code, code, 0); 38893 xmlResetLastError(); 38894 if (mem_base != xmlMemBlocks()) { 38895 printf("Leak of %d blocks found in xmlUCSIsCatNo", 38896 xmlMemBlocks() - mem_base); 38897 test_ret++; 38898 printf(" %d", n_code); 38899 printf("\n"); 38900 } 38901 } 38902 function_tests++; 38903 #endif 38904 38905 return(test_ret); 38906 } 38907 38908 38909 static int 38910 test_xmlUCSIsCatP(void) { 38911 int test_ret = 0; 38912 38913 #if defined(LIBXML_UNICODE_ENABLED) 38914 int mem_base; 38915 int ret_val; 38916 int code; /* UCS code point */ 38917 int n_code; 38918 38919 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38920 mem_base = xmlMemBlocks(); 38921 code = gen_int(n_code, 0); 38922 38923 ret_val = xmlUCSIsCatP(code); 38924 desret_int(ret_val); 38925 call_tests++; 38926 des_int(n_code, code, 0); 38927 xmlResetLastError(); 38928 if (mem_base != xmlMemBlocks()) { 38929 printf("Leak of %d blocks found in xmlUCSIsCatP", 38930 xmlMemBlocks() - mem_base); 38931 test_ret++; 38932 printf(" %d", n_code); 38933 printf("\n"); 38934 } 38935 } 38936 function_tests++; 38937 #endif 38938 38939 return(test_ret); 38940 } 38941 38942 38943 static int 38944 test_xmlUCSIsCatPc(void) { 38945 int test_ret = 0; 38946 38947 #if defined(LIBXML_UNICODE_ENABLED) 38948 int mem_base; 38949 int ret_val; 38950 int code; /* UCS code point */ 38951 int n_code; 38952 38953 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38954 mem_base = xmlMemBlocks(); 38955 code = gen_int(n_code, 0); 38956 38957 ret_val = xmlUCSIsCatPc(code); 38958 desret_int(ret_val); 38959 call_tests++; 38960 des_int(n_code, code, 0); 38961 xmlResetLastError(); 38962 if (mem_base != xmlMemBlocks()) { 38963 printf("Leak of %d blocks found in xmlUCSIsCatPc", 38964 xmlMemBlocks() - mem_base); 38965 test_ret++; 38966 printf(" %d", n_code); 38967 printf("\n"); 38968 } 38969 } 38970 function_tests++; 38971 #endif 38972 38973 return(test_ret); 38974 } 38975 38976 38977 static int 38978 test_xmlUCSIsCatPd(void) { 38979 int test_ret = 0; 38980 38981 #if defined(LIBXML_UNICODE_ENABLED) 38982 int mem_base; 38983 int ret_val; 38984 int code; /* UCS code point */ 38985 int n_code; 38986 38987 for (n_code = 0;n_code < gen_nb_int;n_code++) { 38988 mem_base = xmlMemBlocks(); 38989 code = gen_int(n_code, 0); 38990 38991 ret_val = xmlUCSIsCatPd(code); 38992 desret_int(ret_val); 38993 call_tests++; 38994 des_int(n_code, code, 0); 38995 xmlResetLastError(); 38996 if (mem_base != xmlMemBlocks()) { 38997 printf("Leak of %d blocks found in xmlUCSIsCatPd", 38998 xmlMemBlocks() - mem_base); 38999 test_ret++; 39000 printf(" %d", n_code); 39001 printf("\n"); 39002 } 39003 } 39004 function_tests++; 39005 #endif 39006 39007 return(test_ret); 39008 } 39009 39010 39011 static int 39012 test_xmlUCSIsCatPe(void) { 39013 int test_ret = 0; 39014 39015 #if defined(LIBXML_UNICODE_ENABLED) 39016 int mem_base; 39017 int ret_val; 39018 int code; /* UCS code point */ 39019 int n_code; 39020 39021 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39022 mem_base = xmlMemBlocks(); 39023 code = gen_int(n_code, 0); 39024 39025 ret_val = xmlUCSIsCatPe(code); 39026 desret_int(ret_val); 39027 call_tests++; 39028 des_int(n_code, code, 0); 39029 xmlResetLastError(); 39030 if (mem_base != xmlMemBlocks()) { 39031 printf("Leak of %d blocks found in xmlUCSIsCatPe", 39032 xmlMemBlocks() - mem_base); 39033 test_ret++; 39034 printf(" %d", n_code); 39035 printf("\n"); 39036 } 39037 } 39038 function_tests++; 39039 #endif 39040 39041 return(test_ret); 39042 } 39043 39044 39045 static int 39046 test_xmlUCSIsCatPf(void) { 39047 int test_ret = 0; 39048 39049 #if defined(LIBXML_UNICODE_ENABLED) 39050 int mem_base; 39051 int ret_val; 39052 int code; /* UCS code point */ 39053 int n_code; 39054 39055 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39056 mem_base = xmlMemBlocks(); 39057 code = gen_int(n_code, 0); 39058 39059 ret_val = xmlUCSIsCatPf(code); 39060 desret_int(ret_val); 39061 call_tests++; 39062 des_int(n_code, code, 0); 39063 xmlResetLastError(); 39064 if (mem_base != xmlMemBlocks()) { 39065 printf("Leak of %d blocks found in xmlUCSIsCatPf", 39066 xmlMemBlocks() - mem_base); 39067 test_ret++; 39068 printf(" %d", n_code); 39069 printf("\n"); 39070 } 39071 } 39072 function_tests++; 39073 #endif 39074 39075 return(test_ret); 39076 } 39077 39078 39079 static int 39080 test_xmlUCSIsCatPi(void) { 39081 int test_ret = 0; 39082 39083 #if defined(LIBXML_UNICODE_ENABLED) 39084 int mem_base; 39085 int ret_val; 39086 int code; /* UCS code point */ 39087 int n_code; 39088 39089 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39090 mem_base = xmlMemBlocks(); 39091 code = gen_int(n_code, 0); 39092 39093 ret_val = xmlUCSIsCatPi(code); 39094 desret_int(ret_val); 39095 call_tests++; 39096 des_int(n_code, code, 0); 39097 xmlResetLastError(); 39098 if (mem_base != xmlMemBlocks()) { 39099 printf("Leak of %d blocks found in xmlUCSIsCatPi", 39100 xmlMemBlocks() - mem_base); 39101 test_ret++; 39102 printf(" %d", n_code); 39103 printf("\n"); 39104 } 39105 } 39106 function_tests++; 39107 #endif 39108 39109 return(test_ret); 39110 } 39111 39112 39113 static int 39114 test_xmlUCSIsCatPo(void) { 39115 int test_ret = 0; 39116 39117 #if defined(LIBXML_UNICODE_ENABLED) 39118 int mem_base; 39119 int ret_val; 39120 int code; /* UCS code point */ 39121 int n_code; 39122 39123 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39124 mem_base = xmlMemBlocks(); 39125 code = gen_int(n_code, 0); 39126 39127 ret_val = xmlUCSIsCatPo(code); 39128 desret_int(ret_val); 39129 call_tests++; 39130 des_int(n_code, code, 0); 39131 xmlResetLastError(); 39132 if (mem_base != xmlMemBlocks()) { 39133 printf("Leak of %d blocks found in xmlUCSIsCatPo", 39134 xmlMemBlocks() - mem_base); 39135 test_ret++; 39136 printf(" %d", n_code); 39137 printf("\n"); 39138 } 39139 } 39140 function_tests++; 39141 #endif 39142 39143 return(test_ret); 39144 } 39145 39146 39147 static int 39148 test_xmlUCSIsCatPs(void) { 39149 int test_ret = 0; 39150 39151 #if defined(LIBXML_UNICODE_ENABLED) 39152 int mem_base; 39153 int ret_val; 39154 int code; /* UCS code point */ 39155 int n_code; 39156 39157 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39158 mem_base = xmlMemBlocks(); 39159 code = gen_int(n_code, 0); 39160 39161 ret_val = xmlUCSIsCatPs(code); 39162 desret_int(ret_val); 39163 call_tests++; 39164 des_int(n_code, code, 0); 39165 xmlResetLastError(); 39166 if (mem_base != xmlMemBlocks()) { 39167 printf("Leak of %d blocks found in xmlUCSIsCatPs", 39168 xmlMemBlocks() - mem_base); 39169 test_ret++; 39170 printf(" %d", n_code); 39171 printf("\n"); 39172 } 39173 } 39174 function_tests++; 39175 #endif 39176 39177 return(test_ret); 39178 } 39179 39180 39181 static int 39182 test_xmlUCSIsCatS(void) { 39183 int test_ret = 0; 39184 39185 #if defined(LIBXML_UNICODE_ENABLED) 39186 int mem_base; 39187 int ret_val; 39188 int code; /* UCS code point */ 39189 int n_code; 39190 39191 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39192 mem_base = xmlMemBlocks(); 39193 code = gen_int(n_code, 0); 39194 39195 ret_val = xmlUCSIsCatS(code); 39196 desret_int(ret_val); 39197 call_tests++; 39198 des_int(n_code, code, 0); 39199 xmlResetLastError(); 39200 if (mem_base != xmlMemBlocks()) { 39201 printf("Leak of %d blocks found in xmlUCSIsCatS", 39202 xmlMemBlocks() - mem_base); 39203 test_ret++; 39204 printf(" %d", n_code); 39205 printf("\n"); 39206 } 39207 } 39208 function_tests++; 39209 #endif 39210 39211 return(test_ret); 39212 } 39213 39214 39215 static int 39216 test_xmlUCSIsCatSc(void) { 39217 int test_ret = 0; 39218 39219 #if defined(LIBXML_UNICODE_ENABLED) 39220 int mem_base; 39221 int ret_val; 39222 int code; /* UCS code point */ 39223 int n_code; 39224 39225 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39226 mem_base = xmlMemBlocks(); 39227 code = gen_int(n_code, 0); 39228 39229 ret_val = xmlUCSIsCatSc(code); 39230 desret_int(ret_val); 39231 call_tests++; 39232 des_int(n_code, code, 0); 39233 xmlResetLastError(); 39234 if (mem_base != xmlMemBlocks()) { 39235 printf("Leak of %d blocks found in xmlUCSIsCatSc", 39236 xmlMemBlocks() - mem_base); 39237 test_ret++; 39238 printf(" %d", n_code); 39239 printf("\n"); 39240 } 39241 } 39242 function_tests++; 39243 #endif 39244 39245 return(test_ret); 39246 } 39247 39248 39249 static int 39250 test_xmlUCSIsCatSk(void) { 39251 int test_ret = 0; 39252 39253 #if defined(LIBXML_UNICODE_ENABLED) 39254 int mem_base; 39255 int ret_val; 39256 int code; /* UCS code point */ 39257 int n_code; 39258 39259 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39260 mem_base = xmlMemBlocks(); 39261 code = gen_int(n_code, 0); 39262 39263 ret_val = xmlUCSIsCatSk(code); 39264 desret_int(ret_val); 39265 call_tests++; 39266 des_int(n_code, code, 0); 39267 xmlResetLastError(); 39268 if (mem_base != xmlMemBlocks()) { 39269 printf("Leak of %d blocks found in xmlUCSIsCatSk", 39270 xmlMemBlocks() - mem_base); 39271 test_ret++; 39272 printf(" %d", n_code); 39273 printf("\n"); 39274 } 39275 } 39276 function_tests++; 39277 #endif 39278 39279 return(test_ret); 39280 } 39281 39282 39283 static int 39284 test_xmlUCSIsCatSm(void) { 39285 int test_ret = 0; 39286 39287 #if defined(LIBXML_UNICODE_ENABLED) 39288 int mem_base; 39289 int ret_val; 39290 int code; /* UCS code point */ 39291 int n_code; 39292 39293 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39294 mem_base = xmlMemBlocks(); 39295 code = gen_int(n_code, 0); 39296 39297 ret_val = xmlUCSIsCatSm(code); 39298 desret_int(ret_val); 39299 call_tests++; 39300 des_int(n_code, code, 0); 39301 xmlResetLastError(); 39302 if (mem_base != xmlMemBlocks()) { 39303 printf("Leak of %d blocks found in xmlUCSIsCatSm", 39304 xmlMemBlocks() - mem_base); 39305 test_ret++; 39306 printf(" %d", n_code); 39307 printf("\n"); 39308 } 39309 } 39310 function_tests++; 39311 #endif 39312 39313 return(test_ret); 39314 } 39315 39316 39317 static int 39318 test_xmlUCSIsCatSo(void) { 39319 int test_ret = 0; 39320 39321 #if defined(LIBXML_UNICODE_ENABLED) 39322 int mem_base; 39323 int ret_val; 39324 int code; /* UCS code point */ 39325 int n_code; 39326 39327 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39328 mem_base = xmlMemBlocks(); 39329 code = gen_int(n_code, 0); 39330 39331 ret_val = xmlUCSIsCatSo(code); 39332 desret_int(ret_val); 39333 call_tests++; 39334 des_int(n_code, code, 0); 39335 xmlResetLastError(); 39336 if (mem_base != xmlMemBlocks()) { 39337 printf("Leak of %d blocks found in xmlUCSIsCatSo", 39338 xmlMemBlocks() - mem_base); 39339 test_ret++; 39340 printf(" %d", n_code); 39341 printf("\n"); 39342 } 39343 } 39344 function_tests++; 39345 #endif 39346 39347 return(test_ret); 39348 } 39349 39350 39351 static int 39352 test_xmlUCSIsCatZ(void) { 39353 int test_ret = 0; 39354 39355 #if defined(LIBXML_UNICODE_ENABLED) 39356 int mem_base; 39357 int ret_val; 39358 int code; /* UCS code point */ 39359 int n_code; 39360 39361 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39362 mem_base = xmlMemBlocks(); 39363 code = gen_int(n_code, 0); 39364 39365 ret_val = xmlUCSIsCatZ(code); 39366 desret_int(ret_val); 39367 call_tests++; 39368 des_int(n_code, code, 0); 39369 xmlResetLastError(); 39370 if (mem_base != xmlMemBlocks()) { 39371 printf("Leak of %d blocks found in xmlUCSIsCatZ", 39372 xmlMemBlocks() - mem_base); 39373 test_ret++; 39374 printf(" %d", n_code); 39375 printf("\n"); 39376 } 39377 } 39378 function_tests++; 39379 #endif 39380 39381 return(test_ret); 39382 } 39383 39384 39385 static int 39386 test_xmlUCSIsCatZl(void) { 39387 int test_ret = 0; 39388 39389 #if defined(LIBXML_UNICODE_ENABLED) 39390 int mem_base; 39391 int ret_val; 39392 int code; /* UCS code point */ 39393 int n_code; 39394 39395 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39396 mem_base = xmlMemBlocks(); 39397 code = gen_int(n_code, 0); 39398 39399 ret_val = xmlUCSIsCatZl(code); 39400 desret_int(ret_val); 39401 call_tests++; 39402 des_int(n_code, code, 0); 39403 xmlResetLastError(); 39404 if (mem_base != xmlMemBlocks()) { 39405 printf("Leak of %d blocks found in xmlUCSIsCatZl", 39406 xmlMemBlocks() - mem_base); 39407 test_ret++; 39408 printf(" %d", n_code); 39409 printf("\n"); 39410 } 39411 } 39412 function_tests++; 39413 #endif 39414 39415 return(test_ret); 39416 } 39417 39418 39419 static int 39420 test_xmlUCSIsCatZp(void) { 39421 int test_ret = 0; 39422 39423 #if defined(LIBXML_UNICODE_ENABLED) 39424 int mem_base; 39425 int ret_val; 39426 int code; /* UCS code point */ 39427 int n_code; 39428 39429 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39430 mem_base = xmlMemBlocks(); 39431 code = gen_int(n_code, 0); 39432 39433 ret_val = xmlUCSIsCatZp(code); 39434 desret_int(ret_val); 39435 call_tests++; 39436 des_int(n_code, code, 0); 39437 xmlResetLastError(); 39438 if (mem_base != xmlMemBlocks()) { 39439 printf("Leak of %d blocks found in xmlUCSIsCatZp", 39440 xmlMemBlocks() - mem_base); 39441 test_ret++; 39442 printf(" %d", n_code); 39443 printf("\n"); 39444 } 39445 } 39446 function_tests++; 39447 #endif 39448 39449 return(test_ret); 39450 } 39451 39452 39453 static int 39454 test_xmlUCSIsCatZs(void) { 39455 int test_ret = 0; 39456 39457 #if defined(LIBXML_UNICODE_ENABLED) 39458 int mem_base; 39459 int ret_val; 39460 int code; /* UCS code point */ 39461 int n_code; 39462 39463 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39464 mem_base = xmlMemBlocks(); 39465 code = gen_int(n_code, 0); 39466 39467 ret_val = xmlUCSIsCatZs(code); 39468 desret_int(ret_val); 39469 call_tests++; 39470 des_int(n_code, code, 0); 39471 xmlResetLastError(); 39472 if (mem_base != xmlMemBlocks()) { 39473 printf("Leak of %d blocks found in xmlUCSIsCatZs", 39474 xmlMemBlocks() - mem_base); 39475 test_ret++; 39476 printf(" %d", n_code); 39477 printf("\n"); 39478 } 39479 } 39480 function_tests++; 39481 #endif 39482 39483 return(test_ret); 39484 } 39485 39486 39487 static int 39488 test_xmlUCSIsCherokee(void) { 39489 int test_ret = 0; 39490 39491 #if defined(LIBXML_UNICODE_ENABLED) 39492 int mem_base; 39493 int ret_val; 39494 int code; /* UCS code point */ 39495 int n_code; 39496 39497 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39498 mem_base = xmlMemBlocks(); 39499 code = gen_int(n_code, 0); 39500 39501 ret_val = xmlUCSIsCherokee(code); 39502 desret_int(ret_val); 39503 call_tests++; 39504 des_int(n_code, code, 0); 39505 xmlResetLastError(); 39506 if (mem_base != xmlMemBlocks()) { 39507 printf("Leak of %d blocks found in xmlUCSIsCherokee", 39508 xmlMemBlocks() - mem_base); 39509 test_ret++; 39510 printf(" %d", n_code); 39511 printf("\n"); 39512 } 39513 } 39514 function_tests++; 39515 #endif 39516 39517 return(test_ret); 39518 } 39519 39520 39521 static int 39522 test_xmlUCSIsCombiningDiacriticalMarks(void) { 39523 int test_ret = 0; 39524 39525 #if defined(LIBXML_UNICODE_ENABLED) 39526 int mem_base; 39527 int ret_val; 39528 int code; /* UCS code point */ 39529 int n_code; 39530 39531 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39532 mem_base = xmlMemBlocks(); 39533 code = gen_int(n_code, 0); 39534 39535 ret_val = xmlUCSIsCombiningDiacriticalMarks(code); 39536 desret_int(ret_val); 39537 call_tests++; 39538 des_int(n_code, code, 0); 39539 xmlResetLastError(); 39540 if (mem_base != xmlMemBlocks()) { 39541 printf("Leak of %d blocks found in xmlUCSIsCombiningDiacriticalMarks", 39542 xmlMemBlocks() - mem_base); 39543 test_ret++; 39544 printf(" %d", n_code); 39545 printf("\n"); 39546 } 39547 } 39548 function_tests++; 39549 #endif 39550 39551 return(test_ret); 39552 } 39553 39554 39555 static int 39556 test_xmlUCSIsCombiningDiacriticalMarksforSymbols(void) { 39557 int test_ret = 0; 39558 39559 #if defined(LIBXML_UNICODE_ENABLED) 39560 int mem_base; 39561 int ret_val; 39562 int code; /* UCS code point */ 39563 int n_code; 39564 39565 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39566 mem_base = xmlMemBlocks(); 39567 code = gen_int(n_code, 0); 39568 39569 ret_val = xmlUCSIsCombiningDiacriticalMarksforSymbols(code); 39570 desret_int(ret_val); 39571 call_tests++; 39572 des_int(n_code, code, 0); 39573 xmlResetLastError(); 39574 if (mem_base != xmlMemBlocks()) { 39575 printf("Leak of %d blocks found in xmlUCSIsCombiningDiacriticalMarksforSymbols", 39576 xmlMemBlocks() - mem_base); 39577 test_ret++; 39578 printf(" %d", n_code); 39579 printf("\n"); 39580 } 39581 } 39582 function_tests++; 39583 #endif 39584 39585 return(test_ret); 39586 } 39587 39588 39589 static int 39590 test_xmlUCSIsCombiningHalfMarks(void) { 39591 int test_ret = 0; 39592 39593 #if defined(LIBXML_UNICODE_ENABLED) 39594 int mem_base; 39595 int ret_val; 39596 int code; /* UCS code point */ 39597 int n_code; 39598 39599 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39600 mem_base = xmlMemBlocks(); 39601 code = gen_int(n_code, 0); 39602 39603 ret_val = xmlUCSIsCombiningHalfMarks(code); 39604 desret_int(ret_val); 39605 call_tests++; 39606 des_int(n_code, code, 0); 39607 xmlResetLastError(); 39608 if (mem_base != xmlMemBlocks()) { 39609 printf("Leak of %d blocks found in xmlUCSIsCombiningHalfMarks", 39610 xmlMemBlocks() - mem_base); 39611 test_ret++; 39612 printf(" %d", n_code); 39613 printf("\n"); 39614 } 39615 } 39616 function_tests++; 39617 #endif 39618 39619 return(test_ret); 39620 } 39621 39622 39623 static int 39624 test_xmlUCSIsCombiningMarksforSymbols(void) { 39625 int test_ret = 0; 39626 39627 #if defined(LIBXML_UNICODE_ENABLED) 39628 int mem_base; 39629 int ret_val; 39630 int code; /* UCS code point */ 39631 int n_code; 39632 39633 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39634 mem_base = xmlMemBlocks(); 39635 code = gen_int(n_code, 0); 39636 39637 ret_val = xmlUCSIsCombiningMarksforSymbols(code); 39638 desret_int(ret_val); 39639 call_tests++; 39640 des_int(n_code, code, 0); 39641 xmlResetLastError(); 39642 if (mem_base != xmlMemBlocks()) { 39643 printf("Leak of %d blocks found in xmlUCSIsCombiningMarksforSymbols", 39644 xmlMemBlocks() - mem_base); 39645 test_ret++; 39646 printf(" %d", n_code); 39647 printf("\n"); 39648 } 39649 } 39650 function_tests++; 39651 #endif 39652 39653 return(test_ret); 39654 } 39655 39656 39657 static int 39658 test_xmlUCSIsControlPictures(void) { 39659 int test_ret = 0; 39660 39661 #if defined(LIBXML_UNICODE_ENABLED) 39662 int mem_base; 39663 int ret_val; 39664 int code; /* UCS code point */ 39665 int n_code; 39666 39667 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39668 mem_base = xmlMemBlocks(); 39669 code = gen_int(n_code, 0); 39670 39671 ret_val = xmlUCSIsControlPictures(code); 39672 desret_int(ret_val); 39673 call_tests++; 39674 des_int(n_code, code, 0); 39675 xmlResetLastError(); 39676 if (mem_base != xmlMemBlocks()) { 39677 printf("Leak of %d blocks found in xmlUCSIsControlPictures", 39678 xmlMemBlocks() - mem_base); 39679 test_ret++; 39680 printf(" %d", n_code); 39681 printf("\n"); 39682 } 39683 } 39684 function_tests++; 39685 #endif 39686 39687 return(test_ret); 39688 } 39689 39690 39691 static int 39692 test_xmlUCSIsCurrencySymbols(void) { 39693 int test_ret = 0; 39694 39695 #if defined(LIBXML_UNICODE_ENABLED) 39696 int mem_base; 39697 int ret_val; 39698 int code; /* UCS code point */ 39699 int n_code; 39700 39701 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39702 mem_base = xmlMemBlocks(); 39703 code = gen_int(n_code, 0); 39704 39705 ret_val = xmlUCSIsCurrencySymbols(code); 39706 desret_int(ret_val); 39707 call_tests++; 39708 des_int(n_code, code, 0); 39709 xmlResetLastError(); 39710 if (mem_base != xmlMemBlocks()) { 39711 printf("Leak of %d blocks found in xmlUCSIsCurrencySymbols", 39712 xmlMemBlocks() - mem_base); 39713 test_ret++; 39714 printf(" %d", n_code); 39715 printf("\n"); 39716 } 39717 } 39718 function_tests++; 39719 #endif 39720 39721 return(test_ret); 39722 } 39723 39724 39725 static int 39726 test_xmlUCSIsCypriotSyllabary(void) { 39727 int test_ret = 0; 39728 39729 #if defined(LIBXML_UNICODE_ENABLED) 39730 int mem_base; 39731 int ret_val; 39732 int code; /* UCS code point */ 39733 int n_code; 39734 39735 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39736 mem_base = xmlMemBlocks(); 39737 code = gen_int(n_code, 0); 39738 39739 ret_val = xmlUCSIsCypriotSyllabary(code); 39740 desret_int(ret_val); 39741 call_tests++; 39742 des_int(n_code, code, 0); 39743 xmlResetLastError(); 39744 if (mem_base != xmlMemBlocks()) { 39745 printf("Leak of %d blocks found in xmlUCSIsCypriotSyllabary", 39746 xmlMemBlocks() - mem_base); 39747 test_ret++; 39748 printf(" %d", n_code); 39749 printf("\n"); 39750 } 39751 } 39752 function_tests++; 39753 #endif 39754 39755 return(test_ret); 39756 } 39757 39758 39759 static int 39760 test_xmlUCSIsCyrillic(void) { 39761 int test_ret = 0; 39762 39763 #if defined(LIBXML_UNICODE_ENABLED) 39764 int mem_base; 39765 int ret_val; 39766 int code; /* UCS code point */ 39767 int n_code; 39768 39769 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39770 mem_base = xmlMemBlocks(); 39771 code = gen_int(n_code, 0); 39772 39773 ret_val = xmlUCSIsCyrillic(code); 39774 desret_int(ret_val); 39775 call_tests++; 39776 des_int(n_code, code, 0); 39777 xmlResetLastError(); 39778 if (mem_base != xmlMemBlocks()) { 39779 printf("Leak of %d blocks found in xmlUCSIsCyrillic", 39780 xmlMemBlocks() - mem_base); 39781 test_ret++; 39782 printf(" %d", n_code); 39783 printf("\n"); 39784 } 39785 } 39786 function_tests++; 39787 #endif 39788 39789 return(test_ret); 39790 } 39791 39792 39793 static int 39794 test_xmlUCSIsCyrillicSupplement(void) { 39795 int test_ret = 0; 39796 39797 #if defined(LIBXML_UNICODE_ENABLED) 39798 int mem_base; 39799 int ret_val; 39800 int code; /* UCS code point */ 39801 int n_code; 39802 39803 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39804 mem_base = xmlMemBlocks(); 39805 code = gen_int(n_code, 0); 39806 39807 ret_val = xmlUCSIsCyrillicSupplement(code); 39808 desret_int(ret_val); 39809 call_tests++; 39810 des_int(n_code, code, 0); 39811 xmlResetLastError(); 39812 if (mem_base != xmlMemBlocks()) { 39813 printf("Leak of %d blocks found in xmlUCSIsCyrillicSupplement", 39814 xmlMemBlocks() - mem_base); 39815 test_ret++; 39816 printf(" %d", n_code); 39817 printf("\n"); 39818 } 39819 } 39820 function_tests++; 39821 #endif 39822 39823 return(test_ret); 39824 } 39825 39826 39827 static int 39828 test_xmlUCSIsDeseret(void) { 39829 int test_ret = 0; 39830 39831 #if defined(LIBXML_UNICODE_ENABLED) 39832 int mem_base; 39833 int ret_val; 39834 int code; /* UCS code point */ 39835 int n_code; 39836 39837 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39838 mem_base = xmlMemBlocks(); 39839 code = gen_int(n_code, 0); 39840 39841 ret_val = xmlUCSIsDeseret(code); 39842 desret_int(ret_val); 39843 call_tests++; 39844 des_int(n_code, code, 0); 39845 xmlResetLastError(); 39846 if (mem_base != xmlMemBlocks()) { 39847 printf("Leak of %d blocks found in xmlUCSIsDeseret", 39848 xmlMemBlocks() - mem_base); 39849 test_ret++; 39850 printf(" %d", n_code); 39851 printf("\n"); 39852 } 39853 } 39854 function_tests++; 39855 #endif 39856 39857 return(test_ret); 39858 } 39859 39860 39861 static int 39862 test_xmlUCSIsDevanagari(void) { 39863 int test_ret = 0; 39864 39865 #if defined(LIBXML_UNICODE_ENABLED) 39866 int mem_base; 39867 int ret_val; 39868 int code; /* UCS code point */ 39869 int n_code; 39870 39871 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39872 mem_base = xmlMemBlocks(); 39873 code = gen_int(n_code, 0); 39874 39875 ret_val = xmlUCSIsDevanagari(code); 39876 desret_int(ret_val); 39877 call_tests++; 39878 des_int(n_code, code, 0); 39879 xmlResetLastError(); 39880 if (mem_base != xmlMemBlocks()) { 39881 printf("Leak of %d blocks found in xmlUCSIsDevanagari", 39882 xmlMemBlocks() - mem_base); 39883 test_ret++; 39884 printf(" %d", n_code); 39885 printf("\n"); 39886 } 39887 } 39888 function_tests++; 39889 #endif 39890 39891 return(test_ret); 39892 } 39893 39894 39895 static int 39896 test_xmlUCSIsDingbats(void) { 39897 int test_ret = 0; 39898 39899 #if defined(LIBXML_UNICODE_ENABLED) 39900 int mem_base; 39901 int ret_val; 39902 int code; /* UCS code point */ 39903 int n_code; 39904 39905 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39906 mem_base = xmlMemBlocks(); 39907 code = gen_int(n_code, 0); 39908 39909 ret_val = xmlUCSIsDingbats(code); 39910 desret_int(ret_val); 39911 call_tests++; 39912 des_int(n_code, code, 0); 39913 xmlResetLastError(); 39914 if (mem_base != xmlMemBlocks()) { 39915 printf("Leak of %d blocks found in xmlUCSIsDingbats", 39916 xmlMemBlocks() - mem_base); 39917 test_ret++; 39918 printf(" %d", n_code); 39919 printf("\n"); 39920 } 39921 } 39922 function_tests++; 39923 #endif 39924 39925 return(test_ret); 39926 } 39927 39928 39929 static int 39930 test_xmlUCSIsEnclosedAlphanumerics(void) { 39931 int test_ret = 0; 39932 39933 #if defined(LIBXML_UNICODE_ENABLED) 39934 int mem_base; 39935 int ret_val; 39936 int code; /* UCS code point */ 39937 int n_code; 39938 39939 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39940 mem_base = xmlMemBlocks(); 39941 code = gen_int(n_code, 0); 39942 39943 ret_val = xmlUCSIsEnclosedAlphanumerics(code); 39944 desret_int(ret_val); 39945 call_tests++; 39946 des_int(n_code, code, 0); 39947 xmlResetLastError(); 39948 if (mem_base != xmlMemBlocks()) { 39949 printf("Leak of %d blocks found in xmlUCSIsEnclosedAlphanumerics", 39950 xmlMemBlocks() - mem_base); 39951 test_ret++; 39952 printf(" %d", n_code); 39953 printf("\n"); 39954 } 39955 } 39956 function_tests++; 39957 #endif 39958 39959 return(test_ret); 39960 } 39961 39962 39963 static int 39964 test_xmlUCSIsEnclosedCJKLettersandMonths(void) { 39965 int test_ret = 0; 39966 39967 #if defined(LIBXML_UNICODE_ENABLED) 39968 int mem_base; 39969 int ret_val; 39970 int code; /* UCS code point */ 39971 int n_code; 39972 39973 for (n_code = 0;n_code < gen_nb_int;n_code++) { 39974 mem_base = xmlMemBlocks(); 39975 code = gen_int(n_code, 0); 39976 39977 ret_val = xmlUCSIsEnclosedCJKLettersandMonths(code); 39978 desret_int(ret_val); 39979 call_tests++; 39980 des_int(n_code, code, 0); 39981 xmlResetLastError(); 39982 if (mem_base != xmlMemBlocks()) { 39983 printf("Leak of %d blocks found in xmlUCSIsEnclosedCJKLettersandMonths", 39984 xmlMemBlocks() - mem_base); 39985 test_ret++; 39986 printf(" %d", n_code); 39987 printf("\n"); 39988 } 39989 } 39990 function_tests++; 39991 #endif 39992 39993 return(test_ret); 39994 } 39995 39996 39997 static int 39998 test_xmlUCSIsEthiopic(void) { 39999 int test_ret = 0; 40000 40001 #if defined(LIBXML_UNICODE_ENABLED) 40002 int mem_base; 40003 int ret_val; 40004 int code; /* UCS code point */ 40005 int n_code; 40006 40007 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40008 mem_base = xmlMemBlocks(); 40009 code = gen_int(n_code, 0); 40010 40011 ret_val = xmlUCSIsEthiopic(code); 40012 desret_int(ret_val); 40013 call_tests++; 40014 des_int(n_code, code, 0); 40015 xmlResetLastError(); 40016 if (mem_base != xmlMemBlocks()) { 40017 printf("Leak of %d blocks found in xmlUCSIsEthiopic", 40018 xmlMemBlocks() - mem_base); 40019 test_ret++; 40020 printf(" %d", n_code); 40021 printf("\n"); 40022 } 40023 } 40024 function_tests++; 40025 #endif 40026 40027 return(test_ret); 40028 } 40029 40030 40031 static int 40032 test_xmlUCSIsGeneralPunctuation(void) { 40033 int test_ret = 0; 40034 40035 #if defined(LIBXML_UNICODE_ENABLED) 40036 int mem_base; 40037 int ret_val; 40038 int code; /* UCS code point */ 40039 int n_code; 40040 40041 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40042 mem_base = xmlMemBlocks(); 40043 code = gen_int(n_code, 0); 40044 40045 ret_val = xmlUCSIsGeneralPunctuation(code); 40046 desret_int(ret_val); 40047 call_tests++; 40048 des_int(n_code, code, 0); 40049 xmlResetLastError(); 40050 if (mem_base != xmlMemBlocks()) { 40051 printf("Leak of %d blocks found in xmlUCSIsGeneralPunctuation", 40052 xmlMemBlocks() - mem_base); 40053 test_ret++; 40054 printf(" %d", n_code); 40055 printf("\n"); 40056 } 40057 } 40058 function_tests++; 40059 #endif 40060 40061 return(test_ret); 40062 } 40063 40064 40065 static int 40066 test_xmlUCSIsGeometricShapes(void) { 40067 int test_ret = 0; 40068 40069 #if defined(LIBXML_UNICODE_ENABLED) 40070 int mem_base; 40071 int ret_val; 40072 int code; /* UCS code point */ 40073 int n_code; 40074 40075 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40076 mem_base = xmlMemBlocks(); 40077 code = gen_int(n_code, 0); 40078 40079 ret_val = xmlUCSIsGeometricShapes(code); 40080 desret_int(ret_val); 40081 call_tests++; 40082 des_int(n_code, code, 0); 40083 xmlResetLastError(); 40084 if (mem_base != xmlMemBlocks()) { 40085 printf("Leak of %d blocks found in xmlUCSIsGeometricShapes", 40086 xmlMemBlocks() - mem_base); 40087 test_ret++; 40088 printf(" %d", n_code); 40089 printf("\n"); 40090 } 40091 } 40092 function_tests++; 40093 #endif 40094 40095 return(test_ret); 40096 } 40097 40098 40099 static int 40100 test_xmlUCSIsGeorgian(void) { 40101 int test_ret = 0; 40102 40103 #if defined(LIBXML_UNICODE_ENABLED) 40104 int mem_base; 40105 int ret_val; 40106 int code; /* UCS code point */ 40107 int n_code; 40108 40109 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40110 mem_base = xmlMemBlocks(); 40111 code = gen_int(n_code, 0); 40112 40113 ret_val = xmlUCSIsGeorgian(code); 40114 desret_int(ret_val); 40115 call_tests++; 40116 des_int(n_code, code, 0); 40117 xmlResetLastError(); 40118 if (mem_base != xmlMemBlocks()) { 40119 printf("Leak of %d blocks found in xmlUCSIsGeorgian", 40120 xmlMemBlocks() - mem_base); 40121 test_ret++; 40122 printf(" %d", n_code); 40123 printf("\n"); 40124 } 40125 } 40126 function_tests++; 40127 #endif 40128 40129 return(test_ret); 40130 } 40131 40132 40133 static int 40134 test_xmlUCSIsGothic(void) { 40135 int test_ret = 0; 40136 40137 #if defined(LIBXML_UNICODE_ENABLED) 40138 int mem_base; 40139 int ret_val; 40140 int code; /* UCS code point */ 40141 int n_code; 40142 40143 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40144 mem_base = xmlMemBlocks(); 40145 code = gen_int(n_code, 0); 40146 40147 ret_val = xmlUCSIsGothic(code); 40148 desret_int(ret_val); 40149 call_tests++; 40150 des_int(n_code, code, 0); 40151 xmlResetLastError(); 40152 if (mem_base != xmlMemBlocks()) { 40153 printf("Leak of %d blocks found in xmlUCSIsGothic", 40154 xmlMemBlocks() - mem_base); 40155 test_ret++; 40156 printf(" %d", n_code); 40157 printf("\n"); 40158 } 40159 } 40160 function_tests++; 40161 #endif 40162 40163 return(test_ret); 40164 } 40165 40166 40167 static int 40168 test_xmlUCSIsGreek(void) { 40169 int test_ret = 0; 40170 40171 #if defined(LIBXML_UNICODE_ENABLED) 40172 int mem_base; 40173 int ret_val; 40174 int code; /* UCS code point */ 40175 int n_code; 40176 40177 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40178 mem_base = xmlMemBlocks(); 40179 code = gen_int(n_code, 0); 40180 40181 ret_val = xmlUCSIsGreek(code); 40182 desret_int(ret_val); 40183 call_tests++; 40184 des_int(n_code, code, 0); 40185 xmlResetLastError(); 40186 if (mem_base != xmlMemBlocks()) { 40187 printf("Leak of %d blocks found in xmlUCSIsGreek", 40188 xmlMemBlocks() - mem_base); 40189 test_ret++; 40190 printf(" %d", n_code); 40191 printf("\n"); 40192 } 40193 } 40194 function_tests++; 40195 #endif 40196 40197 return(test_ret); 40198 } 40199 40200 40201 static int 40202 test_xmlUCSIsGreekExtended(void) { 40203 int test_ret = 0; 40204 40205 #if defined(LIBXML_UNICODE_ENABLED) 40206 int mem_base; 40207 int ret_val; 40208 int code; /* UCS code point */ 40209 int n_code; 40210 40211 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40212 mem_base = xmlMemBlocks(); 40213 code = gen_int(n_code, 0); 40214 40215 ret_val = xmlUCSIsGreekExtended(code); 40216 desret_int(ret_val); 40217 call_tests++; 40218 des_int(n_code, code, 0); 40219 xmlResetLastError(); 40220 if (mem_base != xmlMemBlocks()) { 40221 printf("Leak of %d blocks found in xmlUCSIsGreekExtended", 40222 xmlMemBlocks() - mem_base); 40223 test_ret++; 40224 printf(" %d", n_code); 40225 printf("\n"); 40226 } 40227 } 40228 function_tests++; 40229 #endif 40230 40231 return(test_ret); 40232 } 40233 40234 40235 static int 40236 test_xmlUCSIsGreekandCoptic(void) { 40237 int test_ret = 0; 40238 40239 #if defined(LIBXML_UNICODE_ENABLED) 40240 int mem_base; 40241 int ret_val; 40242 int code; /* UCS code point */ 40243 int n_code; 40244 40245 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40246 mem_base = xmlMemBlocks(); 40247 code = gen_int(n_code, 0); 40248 40249 ret_val = xmlUCSIsGreekandCoptic(code); 40250 desret_int(ret_val); 40251 call_tests++; 40252 des_int(n_code, code, 0); 40253 xmlResetLastError(); 40254 if (mem_base != xmlMemBlocks()) { 40255 printf("Leak of %d blocks found in xmlUCSIsGreekandCoptic", 40256 xmlMemBlocks() - mem_base); 40257 test_ret++; 40258 printf(" %d", n_code); 40259 printf("\n"); 40260 } 40261 } 40262 function_tests++; 40263 #endif 40264 40265 return(test_ret); 40266 } 40267 40268 40269 static int 40270 test_xmlUCSIsGujarati(void) { 40271 int test_ret = 0; 40272 40273 #if defined(LIBXML_UNICODE_ENABLED) 40274 int mem_base; 40275 int ret_val; 40276 int code; /* UCS code point */ 40277 int n_code; 40278 40279 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40280 mem_base = xmlMemBlocks(); 40281 code = gen_int(n_code, 0); 40282 40283 ret_val = xmlUCSIsGujarati(code); 40284 desret_int(ret_val); 40285 call_tests++; 40286 des_int(n_code, code, 0); 40287 xmlResetLastError(); 40288 if (mem_base != xmlMemBlocks()) { 40289 printf("Leak of %d blocks found in xmlUCSIsGujarati", 40290 xmlMemBlocks() - mem_base); 40291 test_ret++; 40292 printf(" %d", n_code); 40293 printf("\n"); 40294 } 40295 } 40296 function_tests++; 40297 #endif 40298 40299 return(test_ret); 40300 } 40301 40302 40303 static int 40304 test_xmlUCSIsGurmukhi(void) { 40305 int test_ret = 0; 40306 40307 #if defined(LIBXML_UNICODE_ENABLED) 40308 int mem_base; 40309 int ret_val; 40310 int code; /* UCS code point */ 40311 int n_code; 40312 40313 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40314 mem_base = xmlMemBlocks(); 40315 code = gen_int(n_code, 0); 40316 40317 ret_val = xmlUCSIsGurmukhi(code); 40318 desret_int(ret_val); 40319 call_tests++; 40320 des_int(n_code, code, 0); 40321 xmlResetLastError(); 40322 if (mem_base != xmlMemBlocks()) { 40323 printf("Leak of %d blocks found in xmlUCSIsGurmukhi", 40324 xmlMemBlocks() - mem_base); 40325 test_ret++; 40326 printf(" %d", n_code); 40327 printf("\n"); 40328 } 40329 } 40330 function_tests++; 40331 #endif 40332 40333 return(test_ret); 40334 } 40335 40336 40337 static int 40338 test_xmlUCSIsHalfwidthandFullwidthForms(void) { 40339 int test_ret = 0; 40340 40341 #if defined(LIBXML_UNICODE_ENABLED) 40342 int mem_base; 40343 int ret_val; 40344 int code; /* UCS code point */ 40345 int n_code; 40346 40347 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40348 mem_base = xmlMemBlocks(); 40349 code = gen_int(n_code, 0); 40350 40351 ret_val = xmlUCSIsHalfwidthandFullwidthForms(code); 40352 desret_int(ret_val); 40353 call_tests++; 40354 des_int(n_code, code, 0); 40355 xmlResetLastError(); 40356 if (mem_base != xmlMemBlocks()) { 40357 printf("Leak of %d blocks found in xmlUCSIsHalfwidthandFullwidthForms", 40358 xmlMemBlocks() - mem_base); 40359 test_ret++; 40360 printf(" %d", n_code); 40361 printf("\n"); 40362 } 40363 } 40364 function_tests++; 40365 #endif 40366 40367 return(test_ret); 40368 } 40369 40370 40371 static int 40372 test_xmlUCSIsHangulCompatibilityJamo(void) { 40373 int test_ret = 0; 40374 40375 #if defined(LIBXML_UNICODE_ENABLED) 40376 int mem_base; 40377 int ret_val; 40378 int code; /* UCS code point */ 40379 int n_code; 40380 40381 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40382 mem_base = xmlMemBlocks(); 40383 code = gen_int(n_code, 0); 40384 40385 ret_val = xmlUCSIsHangulCompatibilityJamo(code); 40386 desret_int(ret_val); 40387 call_tests++; 40388 des_int(n_code, code, 0); 40389 xmlResetLastError(); 40390 if (mem_base != xmlMemBlocks()) { 40391 printf("Leak of %d blocks found in xmlUCSIsHangulCompatibilityJamo", 40392 xmlMemBlocks() - mem_base); 40393 test_ret++; 40394 printf(" %d", n_code); 40395 printf("\n"); 40396 } 40397 } 40398 function_tests++; 40399 #endif 40400 40401 return(test_ret); 40402 } 40403 40404 40405 static int 40406 test_xmlUCSIsHangulJamo(void) { 40407 int test_ret = 0; 40408 40409 #if defined(LIBXML_UNICODE_ENABLED) 40410 int mem_base; 40411 int ret_val; 40412 int code; /* UCS code point */ 40413 int n_code; 40414 40415 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40416 mem_base = xmlMemBlocks(); 40417 code = gen_int(n_code, 0); 40418 40419 ret_val = xmlUCSIsHangulJamo(code); 40420 desret_int(ret_val); 40421 call_tests++; 40422 des_int(n_code, code, 0); 40423 xmlResetLastError(); 40424 if (mem_base != xmlMemBlocks()) { 40425 printf("Leak of %d blocks found in xmlUCSIsHangulJamo", 40426 xmlMemBlocks() - mem_base); 40427 test_ret++; 40428 printf(" %d", n_code); 40429 printf("\n"); 40430 } 40431 } 40432 function_tests++; 40433 #endif 40434 40435 return(test_ret); 40436 } 40437 40438 40439 static int 40440 test_xmlUCSIsHangulSyllables(void) { 40441 int test_ret = 0; 40442 40443 #if defined(LIBXML_UNICODE_ENABLED) 40444 int mem_base; 40445 int ret_val; 40446 int code; /* UCS code point */ 40447 int n_code; 40448 40449 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40450 mem_base = xmlMemBlocks(); 40451 code = gen_int(n_code, 0); 40452 40453 ret_val = xmlUCSIsHangulSyllables(code); 40454 desret_int(ret_val); 40455 call_tests++; 40456 des_int(n_code, code, 0); 40457 xmlResetLastError(); 40458 if (mem_base != xmlMemBlocks()) { 40459 printf("Leak of %d blocks found in xmlUCSIsHangulSyllables", 40460 xmlMemBlocks() - mem_base); 40461 test_ret++; 40462 printf(" %d", n_code); 40463 printf("\n"); 40464 } 40465 } 40466 function_tests++; 40467 #endif 40468 40469 return(test_ret); 40470 } 40471 40472 40473 static int 40474 test_xmlUCSIsHanunoo(void) { 40475 int test_ret = 0; 40476 40477 #if defined(LIBXML_UNICODE_ENABLED) 40478 int mem_base; 40479 int ret_val; 40480 int code; /* UCS code point */ 40481 int n_code; 40482 40483 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40484 mem_base = xmlMemBlocks(); 40485 code = gen_int(n_code, 0); 40486 40487 ret_val = xmlUCSIsHanunoo(code); 40488 desret_int(ret_val); 40489 call_tests++; 40490 des_int(n_code, code, 0); 40491 xmlResetLastError(); 40492 if (mem_base != xmlMemBlocks()) { 40493 printf("Leak of %d blocks found in xmlUCSIsHanunoo", 40494 xmlMemBlocks() - mem_base); 40495 test_ret++; 40496 printf(" %d", n_code); 40497 printf("\n"); 40498 } 40499 } 40500 function_tests++; 40501 #endif 40502 40503 return(test_ret); 40504 } 40505 40506 40507 static int 40508 test_xmlUCSIsHebrew(void) { 40509 int test_ret = 0; 40510 40511 #if defined(LIBXML_UNICODE_ENABLED) 40512 int mem_base; 40513 int ret_val; 40514 int code; /* UCS code point */ 40515 int n_code; 40516 40517 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40518 mem_base = xmlMemBlocks(); 40519 code = gen_int(n_code, 0); 40520 40521 ret_val = xmlUCSIsHebrew(code); 40522 desret_int(ret_val); 40523 call_tests++; 40524 des_int(n_code, code, 0); 40525 xmlResetLastError(); 40526 if (mem_base != xmlMemBlocks()) { 40527 printf("Leak of %d blocks found in xmlUCSIsHebrew", 40528 xmlMemBlocks() - mem_base); 40529 test_ret++; 40530 printf(" %d", n_code); 40531 printf("\n"); 40532 } 40533 } 40534 function_tests++; 40535 #endif 40536 40537 return(test_ret); 40538 } 40539 40540 40541 static int 40542 test_xmlUCSIsHighPrivateUseSurrogates(void) { 40543 int test_ret = 0; 40544 40545 #if defined(LIBXML_UNICODE_ENABLED) 40546 int mem_base; 40547 int ret_val; 40548 int code; /* UCS code point */ 40549 int n_code; 40550 40551 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40552 mem_base = xmlMemBlocks(); 40553 code = gen_int(n_code, 0); 40554 40555 ret_val = xmlUCSIsHighPrivateUseSurrogates(code); 40556 desret_int(ret_val); 40557 call_tests++; 40558 des_int(n_code, code, 0); 40559 xmlResetLastError(); 40560 if (mem_base != xmlMemBlocks()) { 40561 printf("Leak of %d blocks found in xmlUCSIsHighPrivateUseSurrogates", 40562 xmlMemBlocks() - mem_base); 40563 test_ret++; 40564 printf(" %d", n_code); 40565 printf("\n"); 40566 } 40567 } 40568 function_tests++; 40569 #endif 40570 40571 return(test_ret); 40572 } 40573 40574 40575 static int 40576 test_xmlUCSIsHighSurrogates(void) { 40577 int test_ret = 0; 40578 40579 #if defined(LIBXML_UNICODE_ENABLED) 40580 int mem_base; 40581 int ret_val; 40582 int code; /* UCS code point */ 40583 int n_code; 40584 40585 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40586 mem_base = xmlMemBlocks(); 40587 code = gen_int(n_code, 0); 40588 40589 ret_val = xmlUCSIsHighSurrogates(code); 40590 desret_int(ret_val); 40591 call_tests++; 40592 des_int(n_code, code, 0); 40593 xmlResetLastError(); 40594 if (mem_base != xmlMemBlocks()) { 40595 printf("Leak of %d blocks found in xmlUCSIsHighSurrogates", 40596 xmlMemBlocks() - mem_base); 40597 test_ret++; 40598 printf(" %d", n_code); 40599 printf("\n"); 40600 } 40601 } 40602 function_tests++; 40603 #endif 40604 40605 return(test_ret); 40606 } 40607 40608 40609 static int 40610 test_xmlUCSIsHiragana(void) { 40611 int test_ret = 0; 40612 40613 #if defined(LIBXML_UNICODE_ENABLED) 40614 int mem_base; 40615 int ret_val; 40616 int code; /* UCS code point */ 40617 int n_code; 40618 40619 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40620 mem_base = xmlMemBlocks(); 40621 code = gen_int(n_code, 0); 40622 40623 ret_val = xmlUCSIsHiragana(code); 40624 desret_int(ret_val); 40625 call_tests++; 40626 des_int(n_code, code, 0); 40627 xmlResetLastError(); 40628 if (mem_base != xmlMemBlocks()) { 40629 printf("Leak of %d blocks found in xmlUCSIsHiragana", 40630 xmlMemBlocks() - mem_base); 40631 test_ret++; 40632 printf(" %d", n_code); 40633 printf("\n"); 40634 } 40635 } 40636 function_tests++; 40637 #endif 40638 40639 return(test_ret); 40640 } 40641 40642 40643 static int 40644 test_xmlUCSIsIPAExtensions(void) { 40645 int test_ret = 0; 40646 40647 #if defined(LIBXML_UNICODE_ENABLED) 40648 int mem_base; 40649 int ret_val; 40650 int code; /* UCS code point */ 40651 int n_code; 40652 40653 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40654 mem_base = xmlMemBlocks(); 40655 code = gen_int(n_code, 0); 40656 40657 ret_val = xmlUCSIsIPAExtensions(code); 40658 desret_int(ret_val); 40659 call_tests++; 40660 des_int(n_code, code, 0); 40661 xmlResetLastError(); 40662 if (mem_base != xmlMemBlocks()) { 40663 printf("Leak of %d blocks found in xmlUCSIsIPAExtensions", 40664 xmlMemBlocks() - mem_base); 40665 test_ret++; 40666 printf(" %d", n_code); 40667 printf("\n"); 40668 } 40669 } 40670 function_tests++; 40671 #endif 40672 40673 return(test_ret); 40674 } 40675 40676 40677 static int 40678 test_xmlUCSIsIdeographicDescriptionCharacters(void) { 40679 int test_ret = 0; 40680 40681 #if defined(LIBXML_UNICODE_ENABLED) 40682 int mem_base; 40683 int ret_val; 40684 int code; /* UCS code point */ 40685 int n_code; 40686 40687 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40688 mem_base = xmlMemBlocks(); 40689 code = gen_int(n_code, 0); 40690 40691 ret_val = xmlUCSIsIdeographicDescriptionCharacters(code); 40692 desret_int(ret_val); 40693 call_tests++; 40694 des_int(n_code, code, 0); 40695 xmlResetLastError(); 40696 if (mem_base != xmlMemBlocks()) { 40697 printf("Leak of %d blocks found in xmlUCSIsIdeographicDescriptionCharacters", 40698 xmlMemBlocks() - mem_base); 40699 test_ret++; 40700 printf(" %d", n_code); 40701 printf("\n"); 40702 } 40703 } 40704 function_tests++; 40705 #endif 40706 40707 return(test_ret); 40708 } 40709 40710 40711 static int 40712 test_xmlUCSIsKanbun(void) { 40713 int test_ret = 0; 40714 40715 #if defined(LIBXML_UNICODE_ENABLED) 40716 int mem_base; 40717 int ret_val; 40718 int code; /* UCS code point */ 40719 int n_code; 40720 40721 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40722 mem_base = xmlMemBlocks(); 40723 code = gen_int(n_code, 0); 40724 40725 ret_val = xmlUCSIsKanbun(code); 40726 desret_int(ret_val); 40727 call_tests++; 40728 des_int(n_code, code, 0); 40729 xmlResetLastError(); 40730 if (mem_base != xmlMemBlocks()) { 40731 printf("Leak of %d blocks found in xmlUCSIsKanbun", 40732 xmlMemBlocks() - mem_base); 40733 test_ret++; 40734 printf(" %d", n_code); 40735 printf("\n"); 40736 } 40737 } 40738 function_tests++; 40739 #endif 40740 40741 return(test_ret); 40742 } 40743 40744 40745 static int 40746 test_xmlUCSIsKangxiRadicals(void) { 40747 int test_ret = 0; 40748 40749 #if defined(LIBXML_UNICODE_ENABLED) 40750 int mem_base; 40751 int ret_val; 40752 int code; /* UCS code point */ 40753 int n_code; 40754 40755 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40756 mem_base = xmlMemBlocks(); 40757 code = gen_int(n_code, 0); 40758 40759 ret_val = xmlUCSIsKangxiRadicals(code); 40760 desret_int(ret_val); 40761 call_tests++; 40762 des_int(n_code, code, 0); 40763 xmlResetLastError(); 40764 if (mem_base != xmlMemBlocks()) { 40765 printf("Leak of %d blocks found in xmlUCSIsKangxiRadicals", 40766 xmlMemBlocks() - mem_base); 40767 test_ret++; 40768 printf(" %d", n_code); 40769 printf("\n"); 40770 } 40771 } 40772 function_tests++; 40773 #endif 40774 40775 return(test_ret); 40776 } 40777 40778 40779 static int 40780 test_xmlUCSIsKannada(void) { 40781 int test_ret = 0; 40782 40783 #if defined(LIBXML_UNICODE_ENABLED) 40784 int mem_base; 40785 int ret_val; 40786 int code; /* UCS code point */ 40787 int n_code; 40788 40789 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40790 mem_base = xmlMemBlocks(); 40791 code = gen_int(n_code, 0); 40792 40793 ret_val = xmlUCSIsKannada(code); 40794 desret_int(ret_val); 40795 call_tests++; 40796 des_int(n_code, code, 0); 40797 xmlResetLastError(); 40798 if (mem_base != xmlMemBlocks()) { 40799 printf("Leak of %d blocks found in xmlUCSIsKannada", 40800 xmlMemBlocks() - mem_base); 40801 test_ret++; 40802 printf(" %d", n_code); 40803 printf("\n"); 40804 } 40805 } 40806 function_tests++; 40807 #endif 40808 40809 return(test_ret); 40810 } 40811 40812 40813 static int 40814 test_xmlUCSIsKatakana(void) { 40815 int test_ret = 0; 40816 40817 #if defined(LIBXML_UNICODE_ENABLED) 40818 int mem_base; 40819 int ret_val; 40820 int code; /* UCS code point */ 40821 int n_code; 40822 40823 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40824 mem_base = xmlMemBlocks(); 40825 code = gen_int(n_code, 0); 40826 40827 ret_val = xmlUCSIsKatakana(code); 40828 desret_int(ret_val); 40829 call_tests++; 40830 des_int(n_code, code, 0); 40831 xmlResetLastError(); 40832 if (mem_base != xmlMemBlocks()) { 40833 printf("Leak of %d blocks found in xmlUCSIsKatakana", 40834 xmlMemBlocks() - mem_base); 40835 test_ret++; 40836 printf(" %d", n_code); 40837 printf("\n"); 40838 } 40839 } 40840 function_tests++; 40841 #endif 40842 40843 return(test_ret); 40844 } 40845 40846 40847 static int 40848 test_xmlUCSIsKatakanaPhoneticExtensions(void) { 40849 int test_ret = 0; 40850 40851 #if defined(LIBXML_UNICODE_ENABLED) 40852 int mem_base; 40853 int ret_val; 40854 int code; /* UCS code point */ 40855 int n_code; 40856 40857 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40858 mem_base = xmlMemBlocks(); 40859 code = gen_int(n_code, 0); 40860 40861 ret_val = xmlUCSIsKatakanaPhoneticExtensions(code); 40862 desret_int(ret_val); 40863 call_tests++; 40864 des_int(n_code, code, 0); 40865 xmlResetLastError(); 40866 if (mem_base != xmlMemBlocks()) { 40867 printf("Leak of %d blocks found in xmlUCSIsKatakanaPhoneticExtensions", 40868 xmlMemBlocks() - mem_base); 40869 test_ret++; 40870 printf(" %d", n_code); 40871 printf("\n"); 40872 } 40873 } 40874 function_tests++; 40875 #endif 40876 40877 return(test_ret); 40878 } 40879 40880 40881 static int 40882 test_xmlUCSIsKhmer(void) { 40883 int test_ret = 0; 40884 40885 #if defined(LIBXML_UNICODE_ENABLED) 40886 int mem_base; 40887 int ret_val; 40888 int code; /* UCS code point */ 40889 int n_code; 40890 40891 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40892 mem_base = xmlMemBlocks(); 40893 code = gen_int(n_code, 0); 40894 40895 ret_val = xmlUCSIsKhmer(code); 40896 desret_int(ret_val); 40897 call_tests++; 40898 des_int(n_code, code, 0); 40899 xmlResetLastError(); 40900 if (mem_base != xmlMemBlocks()) { 40901 printf("Leak of %d blocks found in xmlUCSIsKhmer", 40902 xmlMemBlocks() - mem_base); 40903 test_ret++; 40904 printf(" %d", n_code); 40905 printf("\n"); 40906 } 40907 } 40908 function_tests++; 40909 #endif 40910 40911 return(test_ret); 40912 } 40913 40914 40915 static int 40916 test_xmlUCSIsKhmerSymbols(void) { 40917 int test_ret = 0; 40918 40919 #if defined(LIBXML_UNICODE_ENABLED) 40920 int mem_base; 40921 int ret_val; 40922 int code; /* UCS code point */ 40923 int n_code; 40924 40925 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40926 mem_base = xmlMemBlocks(); 40927 code = gen_int(n_code, 0); 40928 40929 ret_val = xmlUCSIsKhmerSymbols(code); 40930 desret_int(ret_val); 40931 call_tests++; 40932 des_int(n_code, code, 0); 40933 xmlResetLastError(); 40934 if (mem_base != xmlMemBlocks()) { 40935 printf("Leak of %d blocks found in xmlUCSIsKhmerSymbols", 40936 xmlMemBlocks() - mem_base); 40937 test_ret++; 40938 printf(" %d", n_code); 40939 printf("\n"); 40940 } 40941 } 40942 function_tests++; 40943 #endif 40944 40945 return(test_ret); 40946 } 40947 40948 40949 static int 40950 test_xmlUCSIsLao(void) { 40951 int test_ret = 0; 40952 40953 #if defined(LIBXML_UNICODE_ENABLED) 40954 int mem_base; 40955 int ret_val; 40956 int code; /* UCS code point */ 40957 int n_code; 40958 40959 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40960 mem_base = xmlMemBlocks(); 40961 code = gen_int(n_code, 0); 40962 40963 ret_val = xmlUCSIsLao(code); 40964 desret_int(ret_val); 40965 call_tests++; 40966 des_int(n_code, code, 0); 40967 xmlResetLastError(); 40968 if (mem_base != xmlMemBlocks()) { 40969 printf("Leak of %d blocks found in xmlUCSIsLao", 40970 xmlMemBlocks() - mem_base); 40971 test_ret++; 40972 printf(" %d", n_code); 40973 printf("\n"); 40974 } 40975 } 40976 function_tests++; 40977 #endif 40978 40979 return(test_ret); 40980 } 40981 40982 40983 static int 40984 test_xmlUCSIsLatin1Supplement(void) { 40985 int test_ret = 0; 40986 40987 #if defined(LIBXML_UNICODE_ENABLED) 40988 int mem_base; 40989 int ret_val; 40990 int code; /* UCS code point */ 40991 int n_code; 40992 40993 for (n_code = 0;n_code < gen_nb_int;n_code++) { 40994 mem_base = xmlMemBlocks(); 40995 code = gen_int(n_code, 0); 40996 40997 ret_val = xmlUCSIsLatin1Supplement(code); 40998 desret_int(ret_val); 40999 call_tests++; 41000 des_int(n_code, code, 0); 41001 xmlResetLastError(); 41002 if (mem_base != xmlMemBlocks()) { 41003 printf("Leak of %d blocks found in xmlUCSIsLatin1Supplement", 41004 xmlMemBlocks() - mem_base); 41005 test_ret++; 41006 printf(" %d", n_code); 41007 printf("\n"); 41008 } 41009 } 41010 function_tests++; 41011 #endif 41012 41013 return(test_ret); 41014 } 41015 41016 41017 static int 41018 test_xmlUCSIsLatinExtendedA(void) { 41019 int test_ret = 0; 41020 41021 #if defined(LIBXML_UNICODE_ENABLED) 41022 int mem_base; 41023 int ret_val; 41024 int code; /* UCS code point */ 41025 int n_code; 41026 41027 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41028 mem_base = xmlMemBlocks(); 41029 code = gen_int(n_code, 0); 41030 41031 ret_val = xmlUCSIsLatinExtendedA(code); 41032 desret_int(ret_val); 41033 call_tests++; 41034 des_int(n_code, code, 0); 41035 xmlResetLastError(); 41036 if (mem_base != xmlMemBlocks()) { 41037 printf("Leak of %d blocks found in xmlUCSIsLatinExtendedA", 41038 xmlMemBlocks() - mem_base); 41039 test_ret++; 41040 printf(" %d", n_code); 41041 printf("\n"); 41042 } 41043 } 41044 function_tests++; 41045 #endif 41046 41047 return(test_ret); 41048 } 41049 41050 41051 static int 41052 test_xmlUCSIsLatinExtendedAdditional(void) { 41053 int test_ret = 0; 41054 41055 #if defined(LIBXML_UNICODE_ENABLED) 41056 int mem_base; 41057 int ret_val; 41058 int code; /* UCS code point */ 41059 int n_code; 41060 41061 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41062 mem_base = xmlMemBlocks(); 41063 code = gen_int(n_code, 0); 41064 41065 ret_val = xmlUCSIsLatinExtendedAdditional(code); 41066 desret_int(ret_val); 41067 call_tests++; 41068 des_int(n_code, code, 0); 41069 xmlResetLastError(); 41070 if (mem_base != xmlMemBlocks()) { 41071 printf("Leak of %d blocks found in xmlUCSIsLatinExtendedAdditional", 41072 xmlMemBlocks() - mem_base); 41073 test_ret++; 41074 printf(" %d", n_code); 41075 printf("\n"); 41076 } 41077 } 41078 function_tests++; 41079 #endif 41080 41081 return(test_ret); 41082 } 41083 41084 41085 static int 41086 test_xmlUCSIsLatinExtendedB(void) { 41087 int test_ret = 0; 41088 41089 #if defined(LIBXML_UNICODE_ENABLED) 41090 int mem_base; 41091 int ret_val; 41092 int code; /* UCS code point */ 41093 int n_code; 41094 41095 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41096 mem_base = xmlMemBlocks(); 41097 code = gen_int(n_code, 0); 41098 41099 ret_val = xmlUCSIsLatinExtendedB(code); 41100 desret_int(ret_val); 41101 call_tests++; 41102 des_int(n_code, code, 0); 41103 xmlResetLastError(); 41104 if (mem_base != xmlMemBlocks()) { 41105 printf("Leak of %d blocks found in xmlUCSIsLatinExtendedB", 41106 xmlMemBlocks() - mem_base); 41107 test_ret++; 41108 printf(" %d", n_code); 41109 printf("\n"); 41110 } 41111 } 41112 function_tests++; 41113 #endif 41114 41115 return(test_ret); 41116 } 41117 41118 41119 static int 41120 test_xmlUCSIsLetterlikeSymbols(void) { 41121 int test_ret = 0; 41122 41123 #if defined(LIBXML_UNICODE_ENABLED) 41124 int mem_base; 41125 int ret_val; 41126 int code; /* UCS code point */ 41127 int n_code; 41128 41129 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41130 mem_base = xmlMemBlocks(); 41131 code = gen_int(n_code, 0); 41132 41133 ret_val = xmlUCSIsLetterlikeSymbols(code); 41134 desret_int(ret_val); 41135 call_tests++; 41136 des_int(n_code, code, 0); 41137 xmlResetLastError(); 41138 if (mem_base != xmlMemBlocks()) { 41139 printf("Leak of %d blocks found in xmlUCSIsLetterlikeSymbols", 41140 xmlMemBlocks() - mem_base); 41141 test_ret++; 41142 printf(" %d", n_code); 41143 printf("\n"); 41144 } 41145 } 41146 function_tests++; 41147 #endif 41148 41149 return(test_ret); 41150 } 41151 41152 41153 static int 41154 test_xmlUCSIsLimbu(void) { 41155 int test_ret = 0; 41156 41157 #if defined(LIBXML_UNICODE_ENABLED) 41158 int mem_base; 41159 int ret_val; 41160 int code; /* UCS code point */ 41161 int n_code; 41162 41163 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41164 mem_base = xmlMemBlocks(); 41165 code = gen_int(n_code, 0); 41166 41167 ret_val = xmlUCSIsLimbu(code); 41168 desret_int(ret_val); 41169 call_tests++; 41170 des_int(n_code, code, 0); 41171 xmlResetLastError(); 41172 if (mem_base != xmlMemBlocks()) { 41173 printf("Leak of %d blocks found in xmlUCSIsLimbu", 41174 xmlMemBlocks() - mem_base); 41175 test_ret++; 41176 printf(" %d", n_code); 41177 printf("\n"); 41178 } 41179 } 41180 function_tests++; 41181 #endif 41182 41183 return(test_ret); 41184 } 41185 41186 41187 static int 41188 test_xmlUCSIsLinearBIdeograms(void) { 41189 int test_ret = 0; 41190 41191 #if defined(LIBXML_UNICODE_ENABLED) 41192 int mem_base; 41193 int ret_val; 41194 int code; /* UCS code point */ 41195 int n_code; 41196 41197 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41198 mem_base = xmlMemBlocks(); 41199 code = gen_int(n_code, 0); 41200 41201 ret_val = xmlUCSIsLinearBIdeograms(code); 41202 desret_int(ret_val); 41203 call_tests++; 41204 des_int(n_code, code, 0); 41205 xmlResetLastError(); 41206 if (mem_base != xmlMemBlocks()) { 41207 printf("Leak of %d blocks found in xmlUCSIsLinearBIdeograms", 41208 xmlMemBlocks() - mem_base); 41209 test_ret++; 41210 printf(" %d", n_code); 41211 printf("\n"); 41212 } 41213 } 41214 function_tests++; 41215 #endif 41216 41217 return(test_ret); 41218 } 41219 41220 41221 static int 41222 test_xmlUCSIsLinearBSyllabary(void) { 41223 int test_ret = 0; 41224 41225 #if defined(LIBXML_UNICODE_ENABLED) 41226 int mem_base; 41227 int ret_val; 41228 int code; /* UCS code point */ 41229 int n_code; 41230 41231 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41232 mem_base = xmlMemBlocks(); 41233 code = gen_int(n_code, 0); 41234 41235 ret_val = xmlUCSIsLinearBSyllabary(code); 41236 desret_int(ret_val); 41237 call_tests++; 41238 des_int(n_code, code, 0); 41239 xmlResetLastError(); 41240 if (mem_base != xmlMemBlocks()) { 41241 printf("Leak of %d blocks found in xmlUCSIsLinearBSyllabary", 41242 xmlMemBlocks() - mem_base); 41243 test_ret++; 41244 printf(" %d", n_code); 41245 printf("\n"); 41246 } 41247 } 41248 function_tests++; 41249 #endif 41250 41251 return(test_ret); 41252 } 41253 41254 41255 static int 41256 test_xmlUCSIsLowSurrogates(void) { 41257 int test_ret = 0; 41258 41259 #if defined(LIBXML_UNICODE_ENABLED) 41260 int mem_base; 41261 int ret_val; 41262 int code; /* UCS code point */ 41263 int n_code; 41264 41265 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41266 mem_base = xmlMemBlocks(); 41267 code = gen_int(n_code, 0); 41268 41269 ret_val = xmlUCSIsLowSurrogates(code); 41270 desret_int(ret_val); 41271 call_tests++; 41272 des_int(n_code, code, 0); 41273 xmlResetLastError(); 41274 if (mem_base != xmlMemBlocks()) { 41275 printf("Leak of %d blocks found in xmlUCSIsLowSurrogates", 41276 xmlMemBlocks() - mem_base); 41277 test_ret++; 41278 printf(" %d", n_code); 41279 printf("\n"); 41280 } 41281 } 41282 function_tests++; 41283 #endif 41284 41285 return(test_ret); 41286 } 41287 41288 41289 static int 41290 test_xmlUCSIsMalayalam(void) { 41291 int test_ret = 0; 41292 41293 #if defined(LIBXML_UNICODE_ENABLED) 41294 int mem_base; 41295 int ret_val; 41296 int code; /* UCS code point */ 41297 int n_code; 41298 41299 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41300 mem_base = xmlMemBlocks(); 41301 code = gen_int(n_code, 0); 41302 41303 ret_val = xmlUCSIsMalayalam(code); 41304 desret_int(ret_val); 41305 call_tests++; 41306 des_int(n_code, code, 0); 41307 xmlResetLastError(); 41308 if (mem_base != xmlMemBlocks()) { 41309 printf("Leak of %d blocks found in xmlUCSIsMalayalam", 41310 xmlMemBlocks() - mem_base); 41311 test_ret++; 41312 printf(" %d", n_code); 41313 printf("\n"); 41314 } 41315 } 41316 function_tests++; 41317 #endif 41318 41319 return(test_ret); 41320 } 41321 41322 41323 static int 41324 test_xmlUCSIsMathematicalAlphanumericSymbols(void) { 41325 int test_ret = 0; 41326 41327 #if defined(LIBXML_UNICODE_ENABLED) 41328 int mem_base; 41329 int ret_val; 41330 int code; /* UCS code point */ 41331 int n_code; 41332 41333 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41334 mem_base = xmlMemBlocks(); 41335 code = gen_int(n_code, 0); 41336 41337 ret_val = xmlUCSIsMathematicalAlphanumericSymbols(code); 41338 desret_int(ret_val); 41339 call_tests++; 41340 des_int(n_code, code, 0); 41341 xmlResetLastError(); 41342 if (mem_base != xmlMemBlocks()) { 41343 printf("Leak of %d blocks found in xmlUCSIsMathematicalAlphanumericSymbols", 41344 xmlMemBlocks() - mem_base); 41345 test_ret++; 41346 printf(" %d", n_code); 41347 printf("\n"); 41348 } 41349 } 41350 function_tests++; 41351 #endif 41352 41353 return(test_ret); 41354 } 41355 41356 41357 static int 41358 test_xmlUCSIsMathematicalOperators(void) { 41359 int test_ret = 0; 41360 41361 #if defined(LIBXML_UNICODE_ENABLED) 41362 int mem_base; 41363 int ret_val; 41364 int code; /* UCS code point */ 41365 int n_code; 41366 41367 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41368 mem_base = xmlMemBlocks(); 41369 code = gen_int(n_code, 0); 41370 41371 ret_val = xmlUCSIsMathematicalOperators(code); 41372 desret_int(ret_val); 41373 call_tests++; 41374 des_int(n_code, code, 0); 41375 xmlResetLastError(); 41376 if (mem_base != xmlMemBlocks()) { 41377 printf("Leak of %d blocks found in xmlUCSIsMathematicalOperators", 41378 xmlMemBlocks() - mem_base); 41379 test_ret++; 41380 printf(" %d", n_code); 41381 printf("\n"); 41382 } 41383 } 41384 function_tests++; 41385 #endif 41386 41387 return(test_ret); 41388 } 41389 41390 41391 static int 41392 test_xmlUCSIsMiscellaneousMathematicalSymbolsA(void) { 41393 int test_ret = 0; 41394 41395 #if defined(LIBXML_UNICODE_ENABLED) 41396 int mem_base; 41397 int ret_val; 41398 int code; /* UCS code point */ 41399 int n_code; 41400 41401 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41402 mem_base = xmlMemBlocks(); 41403 code = gen_int(n_code, 0); 41404 41405 ret_val = xmlUCSIsMiscellaneousMathematicalSymbolsA(code); 41406 desret_int(ret_val); 41407 call_tests++; 41408 des_int(n_code, code, 0); 41409 xmlResetLastError(); 41410 if (mem_base != xmlMemBlocks()) { 41411 printf("Leak of %d blocks found in xmlUCSIsMiscellaneousMathematicalSymbolsA", 41412 xmlMemBlocks() - mem_base); 41413 test_ret++; 41414 printf(" %d", n_code); 41415 printf("\n"); 41416 } 41417 } 41418 function_tests++; 41419 #endif 41420 41421 return(test_ret); 41422 } 41423 41424 41425 static int 41426 test_xmlUCSIsMiscellaneousMathematicalSymbolsB(void) { 41427 int test_ret = 0; 41428 41429 #if defined(LIBXML_UNICODE_ENABLED) 41430 int mem_base; 41431 int ret_val; 41432 int code; /* UCS code point */ 41433 int n_code; 41434 41435 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41436 mem_base = xmlMemBlocks(); 41437 code = gen_int(n_code, 0); 41438 41439 ret_val = xmlUCSIsMiscellaneousMathematicalSymbolsB(code); 41440 desret_int(ret_val); 41441 call_tests++; 41442 des_int(n_code, code, 0); 41443 xmlResetLastError(); 41444 if (mem_base != xmlMemBlocks()) { 41445 printf("Leak of %d blocks found in xmlUCSIsMiscellaneousMathematicalSymbolsB", 41446 xmlMemBlocks() - mem_base); 41447 test_ret++; 41448 printf(" %d", n_code); 41449 printf("\n"); 41450 } 41451 } 41452 function_tests++; 41453 #endif 41454 41455 return(test_ret); 41456 } 41457 41458 41459 static int 41460 test_xmlUCSIsMiscellaneousSymbols(void) { 41461 int test_ret = 0; 41462 41463 #if defined(LIBXML_UNICODE_ENABLED) 41464 int mem_base; 41465 int ret_val; 41466 int code; /* UCS code point */ 41467 int n_code; 41468 41469 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41470 mem_base = xmlMemBlocks(); 41471 code = gen_int(n_code, 0); 41472 41473 ret_val = xmlUCSIsMiscellaneousSymbols(code); 41474 desret_int(ret_val); 41475 call_tests++; 41476 des_int(n_code, code, 0); 41477 xmlResetLastError(); 41478 if (mem_base != xmlMemBlocks()) { 41479 printf("Leak of %d blocks found in xmlUCSIsMiscellaneousSymbols", 41480 xmlMemBlocks() - mem_base); 41481 test_ret++; 41482 printf(" %d", n_code); 41483 printf("\n"); 41484 } 41485 } 41486 function_tests++; 41487 #endif 41488 41489 return(test_ret); 41490 } 41491 41492 41493 static int 41494 test_xmlUCSIsMiscellaneousSymbolsandArrows(void) { 41495 int test_ret = 0; 41496 41497 #if defined(LIBXML_UNICODE_ENABLED) 41498 int mem_base; 41499 int ret_val; 41500 int code; /* UCS code point */ 41501 int n_code; 41502 41503 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41504 mem_base = xmlMemBlocks(); 41505 code = gen_int(n_code, 0); 41506 41507 ret_val = xmlUCSIsMiscellaneousSymbolsandArrows(code); 41508 desret_int(ret_val); 41509 call_tests++; 41510 des_int(n_code, code, 0); 41511 xmlResetLastError(); 41512 if (mem_base != xmlMemBlocks()) { 41513 printf("Leak of %d blocks found in xmlUCSIsMiscellaneousSymbolsandArrows", 41514 xmlMemBlocks() - mem_base); 41515 test_ret++; 41516 printf(" %d", n_code); 41517 printf("\n"); 41518 } 41519 } 41520 function_tests++; 41521 #endif 41522 41523 return(test_ret); 41524 } 41525 41526 41527 static int 41528 test_xmlUCSIsMiscellaneousTechnical(void) { 41529 int test_ret = 0; 41530 41531 #if defined(LIBXML_UNICODE_ENABLED) 41532 int mem_base; 41533 int ret_val; 41534 int code; /* UCS code point */ 41535 int n_code; 41536 41537 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41538 mem_base = xmlMemBlocks(); 41539 code = gen_int(n_code, 0); 41540 41541 ret_val = xmlUCSIsMiscellaneousTechnical(code); 41542 desret_int(ret_val); 41543 call_tests++; 41544 des_int(n_code, code, 0); 41545 xmlResetLastError(); 41546 if (mem_base != xmlMemBlocks()) { 41547 printf("Leak of %d blocks found in xmlUCSIsMiscellaneousTechnical", 41548 xmlMemBlocks() - mem_base); 41549 test_ret++; 41550 printf(" %d", n_code); 41551 printf("\n"); 41552 } 41553 } 41554 function_tests++; 41555 #endif 41556 41557 return(test_ret); 41558 } 41559 41560 41561 static int 41562 test_xmlUCSIsMongolian(void) { 41563 int test_ret = 0; 41564 41565 #if defined(LIBXML_UNICODE_ENABLED) 41566 int mem_base; 41567 int ret_val; 41568 int code; /* UCS code point */ 41569 int n_code; 41570 41571 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41572 mem_base = xmlMemBlocks(); 41573 code = gen_int(n_code, 0); 41574 41575 ret_val = xmlUCSIsMongolian(code); 41576 desret_int(ret_val); 41577 call_tests++; 41578 des_int(n_code, code, 0); 41579 xmlResetLastError(); 41580 if (mem_base != xmlMemBlocks()) { 41581 printf("Leak of %d blocks found in xmlUCSIsMongolian", 41582 xmlMemBlocks() - mem_base); 41583 test_ret++; 41584 printf(" %d", n_code); 41585 printf("\n"); 41586 } 41587 } 41588 function_tests++; 41589 #endif 41590 41591 return(test_ret); 41592 } 41593 41594 41595 static int 41596 test_xmlUCSIsMusicalSymbols(void) { 41597 int test_ret = 0; 41598 41599 #if defined(LIBXML_UNICODE_ENABLED) 41600 int mem_base; 41601 int ret_val; 41602 int code; /* UCS code point */ 41603 int n_code; 41604 41605 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41606 mem_base = xmlMemBlocks(); 41607 code = gen_int(n_code, 0); 41608 41609 ret_val = xmlUCSIsMusicalSymbols(code); 41610 desret_int(ret_val); 41611 call_tests++; 41612 des_int(n_code, code, 0); 41613 xmlResetLastError(); 41614 if (mem_base != xmlMemBlocks()) { 41615 printf("Leak of %d blocks found in xmlUCSIsMusicalSymbols", 41616 xmlMemBlocks() - mem_base); 41617 test_ret++; 41618 printf(" %d", n_code); 41619 printf("\n"); 41620 } 41621 } 41622 function_tests++; 41623 #endif 41624 41625 return(test_ret); 41626 } 41627 41628 41629 static int 41630 test_xmlUCSIsMyanmar(void) { 41631 int test_ret = 0; 41632 41633 #if defined(LIBXML_UNICODE_ENABLED) 41634 int mem_base; 41635 int ret_val; 41636 int code; /* UCS code point */ 41637 int n_code; 41638 41639 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41640 mem_base = xmlMemBlocks(); 41641 code = gen_int(n_code, 0); 41642 41643 ret_val = xmlUCSIsMyanmar(code); 41644 desret_int(ret_val); 41645 call_tests++; 41646 des_int(n_code, code, 0); 41647 xmlResetLastError(); 41648 if (mem_base != xmlMemBlocks()) { 41649 printf("Leak of %d blocks found in xmlUCSIsMyanmar", 41650 xmlMemBlocks() - mem_base); 41651 test_ret++; 41652 printf(" %d", n_code); 41653 printf("\n"); 41654 } 41655 } 41656 function_tests++; 41657 #endif 41658 41659 return(test_ret); 41660 } 41661 41662 41663 static int 41664 test_xmlUCSIsNumberForms(void) { 41665 int test_ret = 0; 41666 41667 #if defined(LIBXML_UNICODE_ENABLED) 41668 int mem_base; 41669 int ret_val; 41670 int code; /* UCS code point */ 41671 int n_code; 41672 41673 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41674 mem_base = xmlMemBlocks(); 41675 code = gen_int(n_code, 0); 41676 41677 ret_val = xmlUCSIsNumberForms(code); 41678 desret_int(ret_val); 41679 call_tests++; 41680 des_int(n_code, code, 0); 41681 xmlResetLastError(); 41682 if (mem_base != xmlMemBlocks()) { 41683 printf("Leak of %d blocks found in xmlUCSIsNumberForms", 41684 xmlMemBlocks() - mem_base); 41685 test_ret++; 41686 printf(" %d", n_code); 41687 printf("\n"); 41688 } 41689 } 41690 function_tests++; 41691 #endif 41692 41693 return(test_ret); 41694 } 41695 41696 41697 static int 41698 test_xmlUCSIsOgham(void) { 41699 int test_ret = 0; 41700 41701 #if defined(LIBXML_UNICODE_ENABLED) 41702 int mem_base; 41703 int ret_val; 41704 int code; /* UCS code point */ 41705 int n_code; 41706 41707 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41708 mem_base = xmlMemBlocks(); 41709 code = gen_int(n_code, 0); 41710 41711 ret_val = xmlUCSIsOgham(code); 41712 desret_int(ret_val); 41713 call_tests++; 41714 des_int(n_code, code, 0); 41715 xmlResetLastError(); 41716 if (mem_base != xmlMemBlocks()) { 41717 printf("Leak of %d blocks found in xmlUCSIsOgham", 41718 xmlMemBlocks() - mem_base); 41719 test_ret++; 41720 printf(" %d", n_code); 41721 printf("\n"); 41722 } 41723 } 41724 function_tests++; 41725 #endif 41726 41727 return(test_ret); 41728 } 41729 41730 41731 static int 41732 test_xmlUCSIsOldItalic(void) { 41733 int test_ret = 0; 41734 41735 #if defined(LIBXML_UNICODE_ENABLED) 41736 int mem_base; 41737 int ret_val; 41738 int code; /* UCS code point */ 41739 int n_code; 41740 41741 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41742 mem_base = xmlMemBlocks(); 41743 code = gen_int(n_code, 0); 41744 41745 ret_val = xmlUCSIsOldItalic(code); 41746 desret_int(ret_val); 41747 call_tests++; 41748 des_int(n_code, code, 0); 41749 xmlResetLastError(); 41750 if (mem_base != xmlMemBlocks()) { 41751 printf("Leak of %d blocks found in xmlUCSIsOldItalic", 41752 xmlMemBlocks() - mem_base); 41753 test_ret++; 41754 printf(" %d", n_code); 41755 printf("\n"); 41756 } 41757 } 41758 function_tests++; 41759 #endif 41760 41761 return(test_ret); 41762 } 41763 41764 41765 static int 41766 test_xmlUCSIsOpticalCharacterRecognition(void) { 41767 int test_ret = 0; 41768 41769 #if defined(LIBXML_UNICODE_ENABLED) 41770 int mem_base; 41771 int ret_val; 41772 int code; /* UCS code point */ 41773 int n_code; 41774 41775 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41776 mem_base = xmlMemBlocks(); 41777 code = gen_int(n_code, 0); 41778 41779 ret_val = xmlUCSIsOpticalCharacterRecognition(code); 41780 desret_int(ret_val); 41781 call_tests++; 41782 des_int(n_code, code, 0); 41783 xmlResetLastError(); 41784 if (mem_base != xmlMemBlocks()) { 41785 printf("Leak of %d blocks found in xmlUCSIsOpticalCharacterRecognition", 41786 xmlMemBlocks() - mem_base); 41787 test_ret++; 41788 printf(" %d", n_code); 41789 printf("\n"); 41790 } 41791 } 41792 function_tests++; 41793 #endif 41794 41795 return(test_ret); 41796 } 41797 41798 41799 static int 41800 test_xmlUCSIsOriya(void) { 41801 int test_ret = 0; 41802 41803 #if defined(LIBXML_UNICODE_ENABLED) 41804 int mem_base; 41805 int ret_val; 41806 int code; /* UCS code point */ 41807 int n_code; 41808 41809 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41810 mem_base = xmlMemBlocks(); 41811 code = gen_int(n_code, 0); 41812 41813 ret_val = xmlUCSIsOriya(code); 41814 desret_int(ret_val); 41815 call_tests++; 41816 des_int(n_code, code, 0); 41817 xmlResetLastError(); 41818 if (mem_base != xmlMemBlocks()) { 41819 printf("Leak of %d blocks found in xmlUCSIsOriya", 41820 xmlMemBlocks() - mem_base); 41821 test_ret++; 41822 printf(" %d", n_code); 41823 printf("\n"); 41824 } 41825 } 41826 function_tests++; 41827 #endif 41828 41829 return(test_ret); 41830 } 41831 41832 41833 static int 41834 test_xmlUCSIsOsmanya(void) { 41835 int test_ret = 0; 41836 41837 #if defined(LIBXML_UNICODE_ENABLED) 41838 int mem_base; 41839 int ret_val; 41840 int code; /* UCS code point */ 41841 int n_code; 41842 41843 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41844 mem_base = xmlMemBlocks(); 41845 code = gen_int(n_code, 0); 41846 41847 ret_val = xmlUCSIsOsmanya(code); 41848 desret_int(ret_val); 41849 call_tests++; 41850 des_int(n_code, code, 0); 41851 xmlResetLastError(); 41852 if (mem_base != xmlMemBlocks()) { 41853 printf("Leak of %d blocks found in xmlUCSIsOsmanya", 41854 xmlMemBlocks() - mem_base); 41855 test_ret++; 41856 printf(" %d", n_code); 41857 printf("\n"); 41858 } 41859 } 41860 function_tests++; 41861 #endif 41862 41863 return(test_ret); 41864 } 41865 41866 41867 static int 41868 test_xmlUCSIsPhoneticExtensions(void) { 41869 int test_ret = 0; 41870 41871 #if defined(LIBXML_UNICODE_ENABLED) 41872 int mem_base; 41873 int ret_val; 41874 int code; /* UCS code point */ 41875 int n_code; 41876 41877 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41878 mem_base = xmlMemBlocks(); 41879 code = gen_int(n_code, 0); 41880 41881 ret_val = xmlUCSIsPhoneticExtensions(code); 41882 desret_int(ret_val); 41883 call_tests++; 41884 des_int(n_code, code, 0); 41885 xmlResetLastError(); 41886 if (mem_base != xmlMemBlocks()) { 41887 printf("Leak of %d blocks found in xmlUCSIsPhoneticExtensions", 41888 xmlMemBlocks() - mem_base); 41889 test_ret++; 41890 printf(" %d", n_code); 41891 printf("\n"); 41892 } 41893 } 41894 function_tests++; 41895 #endif 41896 41897 return(test_ret); 41898 } 41899 41900 41901 static int 41902 test_xmlUCSIsPrivateUse(void) { 41903 int test_ret = 0; 41904 41905 #if defined(LIBXML_UNICODE_ENABLED) 41906 int mem_base; 41907 int ret_val; 41908 int code; /* UCS code point */ 41909 int n_code; 41910 41911 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41912 mem_base = xmlMemBlocks(); 41913 code = gen_int(n_code, 0); 41914 41915 ret_val = xmlUCSIsPrivateUse(code); 41916 desret_int(ret_val); 41917 call_tests++; 41918 des_int(n_code, code, 0); 41919 xmlResetLastError(); 41920 if (mem_base != xmlMemBlocks()) { 41921 printf("Leak of %d blocks found in xmlUCSIsPrivateUse", 41922 xmlMemBlocks() - mem_base); 41923 test_ret++; 41924 printf(" %d", n_code); 41925 printf("\n"); 41926 } 41927 } 41928 function_tests++; 41929 #endif 41930 41931 return(test_ret); 41932 } 41933 41934 41935 static int 41936 test_xmlUCSIsPrivateUseArea(void) { 41937 int test_ret = 0; 41938 41939 #if defined(LIBXML_UNICODE_ENABLED) 41940 int mem_base; 41941 int ret_val; 41942 int code; /* UCS code point */ 41943 int n_code; 41944 41945 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41946 mem_base = xmlMemBlocks(); 41947 code = gen_int(n_code, 0); 41948 41949 ret_val = xmlUCSIsPrivateUseArea(code); 41950 desret_int(ret_val); 41951 call_tests++; 41952 des_int(n_code, code, 0); 41953 xmlResetLastError(); 41954 if (mem_base != xmlMemBlocks()) { 41955 printf("Leak of %d blocks found in xmlUCSIsPrivateUseArea", 41956 xmlMemBlocks() - mem_base); 41957 test_ret++; 41958 printf(" %d", n_code); 41959 printf("\n"); 41960 } 41961 } 41962 function_tests++; 41963 #endif 41964 41965 return(test_ret); 41966 } 41967 41968 41969 static int 41970 test_xmlUCSIsRunic(void) { 41971 int test_ret = 0; 41972 41973 #if defined(LIBXML_UNICODE_ENABLED) 41974 int mem_base; 41975 int ret_val; 41976 int code; /* UCS code point */ 41977 int n_code; 41978 41979 for (n_code = 0;n_code < gen_nb_int;n_code++) { 41980 mem_base = xmlMemBlocks(); 41981 code = gen_int(n_code, 0); 41982 41983 ret_val = xmlUCSIsRunic(code); 41984 desret_int(ret_val); 41985 call_tests++; 41986 des_int(n_code, code, 0); 41987 xmlResetLastError(); 41988 if (mem_base != xmlMemBlocks()) { 41989 printf("Leak of %d blocks found in xmlUCSIsRunic", 41990 xmlMemBlocks() - mem_base); 41991 test_ret++; 41992 printf(" %d", n_code); 41993 printf("\n"); 41994 } 41995 } 41996 function_tests++; 41997 #endif 41998 41999 return(test_ret); 42000 } 42001 42002 42003 static int 42004 test_xmlUCSIsShavian(void) { 42005 int test_ret = 0; 42006 42007 #if defined(LIBXML_UNICODE_ENABLED) 42008 int mem_base; 42009 int ret_val; 42010 int code; /* UCS code point */ 42011 int n_code; 42012 42013 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42014 mem_base = xmlMemBlocks(); 42015 code = gen_int(n_code, 0); 42016 42017 ret_val = xmlUCSIsShavian(code); 42018 desret_int(ret_val); 42019 call_tests++; 42020 des_int(n_code, code, 0); 42021 xmlResetLastError(); 42022 if (mem_base != xmlMemBlocks()) { 42023 printf("Leak of %d blocks found in xmlUCSIsShavian", 42024 xmlMemBlocks() - mem_base); 42025 test_ret++; 42026 printf(" %d", n_code); 42027 printf("\n"); 42028 } 42029 } 42030 function_tests++; 42031 #endif 42032 42033 return(test_ret); 42034 } 42035 42036 42037 static int 42038 test_xmlUCSIsSinhala(void) { 42039 int test_ret = 0; 42040 42041 #if defined(LIBXML_UNICODE_ENABLED) 42042 int mem_base; 42043 int ret_val; 42044 int code; /* UCS code point */ 42045 int n_code; 42046 42047 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42048 mem_base = xmlMemBlocks(); 42049 code = gen_int(n_code, 0); 42050 42051 ret_val = xmlUCSIsSinhala(code); 42052 desret_int(ret_val); 42053 call_tests++; 42054 des_int(n_code, code, 0); 42055 xmlResetLastError(); 42056 if (mem_base != xmlMemBlocks()) { 42057 printf("Leak of %d blocks found in xmlUCSIsSinhala", 42058 xmlMemBlocks() - mem_base); 42059 test_ret++; 42060 printf(" %d", n_code); 42061 printf("\n"); 42062 } 42063 } 42064 function_tests++; 42065 #endif 42066 42067 return(test_ret); 42068 } 42069 42070 42071 static int 42072 test_xmlUCSIsSmallFormVariants(void) { 42073 int test_ret = 0; 42074 42075 #if defined(LIBXML_UNICODE_ENABLED) 42076 int mem_base; 42077 int ret_val; 42078 int code; /* UCS code point */ 42079 int n_code; 42080 42081 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42082 mem_base = xmlMemBlocks(); 42083 code = gen_int(n_code, 0); 42084 42085 ret_val = xmlUCSIsSmallFormVariants(code); 42086 desret_int(ret_val); 42087 call_tests++; 42088 des_int(n_code, code, 0); 42089 xmlResetLastError(); 42090 if (mem_base != xmlMemBlocks()) { 42091 printf("Leak of %d blocks found in xmlUCSIsSmallFormVariants", 42092 xmlMemBlocks() - mem_base); 42093 test_ret++; 42094 printf(" %d", n_code); 42095 printf("\n"); 42096 } 42097 } 42098 function_tests++; 42099 #endif 42100 42101 return(test_ret); 42102 } 42103 42104 42105 static int 42106 test_xmlUCSIsSpacingModifierLetters(void) { 42107 int test_ret = 0; 42108 42109 #if defined(LIBXML_UNICODE_ENABLED) 42110 int mem_base; 42111 int ret_val; 42112 int code; /* UCS code point */ 42113 int n_code; 42114 42115 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42116 mem_base = xmlMemBlocks(); 42117 code = gen_int(n_code, 0); 42118 42119 ret_val = xmlUCSIsSpacingModifierLetters(code); 42120 desret_int(ret_val); 42121 call_tests++; 42122 des_int(n_code, code, 0); 42123 xmlResetLastError(); 42124 if (mem_base != xmlMemBlocks()) { 42125 printf("Leak of %d blocks found in xmlUCSIsSpacingModifierLetters", 42126 xmlMemBlocks() - mem_base); 42127 test_ret++; 42128 printf(" %d", n_code); 42129 printf("\n"); 42130 } 42131 } 42132 function_tests++; 42133 #endif 42134 42135 return(test_ret); 42136 } 42137 42138 42139 static int 42140 test_xmlUCSIsSpecials(void) { 42141 int test_ret = 0; 42142 42143 #if defined(LIBXML_UNICODE_ENABLED) 42144 int mem_base; 42145 int ret_val; 42146 int code; /* UCS code point */ 42147 int n_code; 42148 42149 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42150 mem_base = xmlMemBlocks(); 42151 code = gen_int(n_code, 0); 42152 42153 ret_val = xmlUCSIsSpecials(code); 42154 desret_int(ret_val); 42155 call_tests++; 42156 des_int(n_code, code, 0); 42157 xmlResetLastError(); 42158 if (mem_base != xmlMemBlocks()) { 42159 printf("Leak of %d blocks found in xmlUCSIsSpecials", 42160 xmlMemBlocks() - mem_base); 42161 test_ret++; 42162 printf(" %d", n_code); 42163 printf("\n"); 42164 } 42165 } 42166 function_tests++; 42167 #endif 42168 42169 return(test_ret); 42170 } 42171 42172 42173 static int 42174 test_xmlUCSIsSuperscriptsandSubscripts(void) { 42175 int test_ret = 0; 42176 42177 #if defined(LIBXML_UNICODE_ENABLED) 42178 int mem_base; 42179 int ret_val; 42180 int code; /* UCS code point */ 42181 int n_code; 42182 42183 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42184 mem_base = xmlMemBlocks(); 42185 code = gen_int(n_code, 0); 42186 42187 ret_val = xmlUCSIsSuperscriptsandSubscripts(code); 42188 desret_int(ret_val); 42189 call_tests++; 42190 des_int(n_code, code, 0); 42191 xmlResetLastError(); 42192 if (mem_base != xmlMemBlocks()) { 42193 printf("Leak of %d blocks found in xmlUCSIsSuperscriptsandSubscripts", 42194 xmlMemBlocks() - mem_base); 42195 test_ret++; 42196 printf(" %d", n_code); 42197 printf("\n"); 42198 } 42199 } 42200 function_tests++; 42201 #endif 42202 42203 return(test_ret); 42204 } 42205 42206 42207 static int 42208 test_xmlUCSIsSupplementalArrowsA(void) { 42209 int test_ret = 0; 42210 42211 #if defined(LIBXML_UNICODE_ENABLED) 42212 int mem_base; 42213 int ret_val; 42214 int code; /* UCS code point */ 42215 int n_code; 42216 42217 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42218 mem_base = xmlMemBlocks(); 42219 code = gen_int(n_code, 0); 42220 42221 ret_val = xmlUCSIsSupplementalArrowsA(code); 42222 desret_int(ret_val); 42223 call_tests++; 42224 des_int(n_code, code, 0); 42225 xmlResetLastError(); 42226 if (mem_base != xmlMemBlocks()) { 42227 printf("Leak of %d blocks found in xmlUCSIsSupplementalArrowsA", 42228 xmlMemBlocks() - mem_base); 42229 test_ret++; 42230 printf(" %d", n_code); 42231 printf("\n"); 42232 } 42233 } 42234 function_tests++; 42235 #endif 42236 42237 return(test_ret); 42238 } 42239 42240 42241 static int 42242 test_xmlUCSIsSupplementalArrowsB(void) { 42243 int test_ret = 0; 42244 42245 #if defined(LIBXML_UNICODE_ENABLED) 42246 int mem_base; 42247 int ret_val; 42248 int code; /* UCS code point */ 42249 int n_code; 42250 42251 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42252 mem_base = xmlMemBlocks(); 42253 code = gen_int(n_code, 0); 42254 42255 ret_val = xmlUCSIsSupplementalArrowsB(code); 42256 desret_int(ret_val); 42257 call_tests++; 42258 des_int(n_code, code, 0); 42259 xmlResetLastError(); 42260 if (mem_base != xmlMemBlocks()) { 42261 printf("Leak of %d blocks found in xmlUCSIsSupplementalArrowsB", 42262 xmlMemBlocks() - mem_base); 42263 test_ret++; 42264 printf(" %d", n_code); 42265 printf("\n"); 42266 } 42267 } 42268 function_tests++; 42269 #endif 42270 42271 return(test_ret); 42272 } 42273 42274 42275 static int 42276 test_xmlUCSIsSupplementalMathematicalOperators(void) { 42277 int test_ret = 0; 42278 42279 #if defined(LIBXML_UNICODE_ENABLED) 42280 int mem_base; 42281 int ret_val; 42282 int code; /* UCS code point */ 42283 int n_code; 42284 42285 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42286 mem_base = xmlMemBlocks(); 42287 code = gen_int(n_code, 0); 42288 42289 ret_val = xmlUCSIsSupplementalMathematicalOperators(code); 42290 desret_int(ret_val); 42291 call_tests++; 42292 des_int(n_code, code, 0); 42293 xmlResetLastError(); 42294 if (mem_base != xmlMemBlocks()) { 42295 printf("Leak of %d blocks found in xmlUCSIsSupplementalMathematicalOperators", 42296 xmlMemBlocks() - mem_base); 42297 test_ret++; 42298 printf(" %d", n_code); 42299 printf("\n"); 42300 } 42301 } 42302 function_tests++; 42303 #endif 42304 42305 return(test_ret); 42306 } 42307 42308 42309 static int 42310 test_xmlUCSIsSupplementaryPrivateUseAreaA(void) { 42311 int test_ret = 0; 42312 42313 #if defined(LIBXML_UNICODE_ENABLED) 42314 int mem_base; 42315 int ret_val; 42316 int code; /* UCS code point */ 42317 int n_code; 42318 42319 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42320 mem_base = xmlMemBlocks(); 42321 code = gen_int(n_code, 0); 42322 42323 ret_val = xmlUCSIsSupplementaryPrivateUseAreaA(code); 42324 desret_int(ret_val); 42325 call_tests++; 42326 des_int(n_code, code, 0); 42327 xmlResetLastError(); 42328 if (mem_base != xmlMemBlocks()) { 42329 printf("Leak of %d blocks found in xmlUCSIsSupplementaryPrivateUseAreaA", 42330 xmlMemBlocks() - mem_base); 42331 test_ret++; 42332 printf(" %d", n_code); 42333 printf("\n"); 42334 } 42335 } 42336 function_tests++; 42337 #endif 42338 42339 return(test_ret); 42340 } 42341 42342 42343 static int 42344 test_xmlUCSIsSupplementaryPrivateUseAreaB(void) { 42345 int test_ret = 0; 42346 42347 #if defined(LIBXML_UNICODE_ENABLED) 42348 int mem_base; 42349 int ret_val; 42350 int code; /* UCS code point */ 42351 int n_code; 42352 42353 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42354 mem_base = xmlMemBlocks(); 42355 code = gen_int(n_code, 0); 42356 42357 ret_val = xmlUCSIsSupplementaryPrivateUseAreaB(code); 42358 desret_int(ret_val); 42359 call_tests++; 42360 des_int(n_code, code, 0); 42361 xmlResetLastError(); 42362 if (mem_base != xmlMemBlocks()) { 42363 printf("Leak of %d blocks found in xmlUCSIsSupplementaryPrivateUseAreaB", 42364 xmlMemBlocks() - mem_base); 42365 test_ret++; 42366 printf(" %d", n_code); 42367 printf("\n"); 42368 } 42369 } 42370 function_tests++; 42371 #endif 42372 42373 return(test_ret); 42374 } 42375 42376 42377 static int 42378 test_xmlUCSIsSyriac(void) { 42379 int test_ret = 0; 42380 42381 #if defined(LIBXML_UNICODE_ENABLED) 42382 int mem_base; 42383 int ret_val; 42384 int code; /* UCS code point */ 42385 int n_code; 42386 42387 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42388 mem_base = xmlMemBlocks(); 42389 code = gen_int(n_code, 0); 42390 42391 ret_val = xmlUCSIsSyriac(code); 42392 desret_int(ret_val); 42393 call_tests++; 42394 des_int(n_code, code, 0); 42395 xmlResetLastError(); 42396 if (mem_base != xmlMemBlocks()) { 42397 printf("Leak of %d blocks found in xmlUCSIsSyriac", 42398 xmlMemBlocks() - mem_base); 42399 test_ret++; 42400 printf(" %d", n_code); 42401 printf("\n"); 42402 } 42403 } 42404 function_tests++; 42405 #endif 42406 42407 return(test_ret); 42408 } 42409 42410 42411 static int 42412 test_xmlUCSIsTagalog(void) { 42413 int test_ret = 0; 42414 42415 #if defined(LIBXML_UNICODE_ENABLED) 42416 int mem_base; 42417 int ret_val; 42418 int code; /* UCS code point */ 42419 int n_code; 42420 42421 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42422 mem_base = xmlMemBlocks(); 42423 code = gen_int(n_code, 0); 42424 42425 ret_val = xmlUCSIsTagalog(code); 42426 desret_int(ret_val); 42427 call_tests++; 42428 des_int(n_code, code, 0); 42429 xmlResetLastError(); 42430 if (mem_base != xmlMemBlocks()) { 42431 printf("Leak of %d blocks found in xmlUCSIsTagalog", 42432 xmlMemBlocks() - mem_base); 42433 test_ret++; 42434 printf(" %d", n_code); 42435 printf("\n"); 42436 } 42437 } 42438 function_tests++; 42439 #endif 42440 42441 return(test_ret); 42442 } 42443 42444 42445 static int 42446 test_xmlUCSIsTagbanwa(void) { 42447 int test_ret = 0; 42448 42449 #if defined(LIBXML_UNICODE_ENABLED) 42450 int mem_base; 42451 int ret_val; 42452 int code; /* UCS code point */ 42453 int n_code; 42454 42455 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42456 mem_base = xmlMemBlocks(); 42457 code = gen_int(n_code, 0); 42458 42459 ret_val = xmlUCSIsTagbanwa(code); 42460 desret_int(ret_val); 42461 call_tests++; 42462 des_int(n_code, code, 0); 42463 xmlResetLastError(); 42464 if (mem_base != xmlMemBlocks()) { 42465 printf("Leak of %d blocks found in xmlUCSIsTagbanwa", 42466 xmlMemBlocks() - mem_base); 42467 test_ret++; 42468 printf(" %d", n_code); 42469 printf("\n"); 42470 } 42471 } 42472 function_tests++; 42473 #endif 42474 42475 return(test_ret); 42476 } 42477 42478 42479 static int 42480 test_xmlUCSIsTags(void) { 42481 int test_ret = 0; 42482 42483 #if defined(LIBXML_UNICODE_ENABLED) 42484 int mem_base; 42485 int ret_val; 42486 int code; /* UCS code point */ 42487 int n_code; 42488 42489 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42490 mem_base = xmlMemBlocks(); 42491 code = gen_int(n_code, 0); 42492 42493 ret_val = xmlUCSIsTags(code); 42494 desret_int(ret_val); 42495 call_tests++; 42496 des_int(n_code, code, 0); 42497 xmlResetLastError(); 42498 if (mem_base != xmlMemBlocks()) { 42499 printf("Leak of %d blocks found in xmlUCSIsTags", 42500 xmlMemBlocks() - mem_base); 42501 test_ret++; 42502 printf(" %d", n_code); 42503 printf("\n"); 42504 } 42505 } 42506 function_tests++; 42507 #endif 42508 42509 return(test_ret); 42510 } 42511 42512 42513 static int 42514 test_xmlUCSIsTaiLe(void) { 42515 int test_ret = 0; 42516 42517 #if defined(LIBXML_UNICODE_ENABLED) 42518 int mem_base; 42519 int ret_val; 42520 int code; /* UCS code point */ 42521 int n_code; 42522 42523 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42524 mem_base = xmlMemBlocks(); 42525 code = gen_int(n_code, 0); 42526 42527 ret_val = xmlUCSIsTaiLe(code); 42528 desret_int(ret_val); 42529 call_tests++; 42530 des_int(n_code, code, 0); 42531 xmlResetLastError(); 42532 if (mem_base != xmlMemBlocks()) { 42533 printf("Leak of %d blocks found in xmlUCSIsTaiLe", 42534 xmlMemBlocks() - mem_base); 42535 test_ret++; 42536 printf(" %d", n_code); 42537 printf("\n"); 42538 } 42539 } 42540 function_tests++; 42541 #endif 42542 42543 return(test_ret); 42544 } 42545 42546 42547 static int 42548 test_xmlUCSIsTaiXuanJingSymbols(void) { 42549 int test_ret = 0; 42550 42551 #if defined(LIBXML_UNICODE_ENABLED) 42552 int mem_base; 42553 int ret_val; 42554 int code; /* UCS code point */ 42555 int n_code; 42556 42557 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42558 mem_base = xmlMemBlocks(); 42559 code = gen_int(n_code, 0); 42560 42561 ret_val = xmlUCSIsTaiXuanJingSymbols(code); 42562 desret_int(ret_val); 42563 call_tests++; 42564 des_int(n_code, code, 0); 42565 xmlResetLastError(); 42566 if (mem_base != xmlMemBlocks()) { 42567 printf("Leak of %d blocks found in xmlUCSIsTaiXuanJingSymbols", 42568 xmlMemBlocks() - mem_base); 42569 test_ret++; 42570 printf(" %d", n_code); 42571 printf("\n"); 42572 } 42573 } 42574 function_tests++; 42575 #endif 42576 42577 return(test_ret); 42578 } 42579 42580 42581 static int 42582 test_xmlUCSIsTamil(void) { 42583 int test_ret = 0; 42584 42585 #if defined(LIBXML_UNICODE_ENABLED) 42586 int mem_base; 42587 int ret_val; 42588 int code; /* UCS code point */ 42589 int n_code; 42590 42591 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42592 mem_base = xmlMemBlocks(); 42593 code = gen_int(n_code, 0); 42594 42595 ret_val = xmlUCSIsTamil(code); 42596 desret_int(ret_val); 42597 call_tests++; 42598 des_int(n_code, code, 0); 42599 xmlResetLastError(); 42600 if (mem_base != xmlMemBlocks()) { 42601 printf("Leak of %d blocks found in xmlUCSIsTamil", 42602 xmlMemBlocks() - mem_base); 42603 test_ret++; 42604 printf(" %d", n_code); 42605 printf("\n"); 42606 } 42607 } 42608 function_tests++; 42609 #endif 42610 42611 return(test_ret); 42612 } 42613 42614 42615 static int 42616 test_xmlUCSIsTelugu(void) { 42617 int test_ret = 0; 42618 42619 #if defined(LIBXML_UNICODE_ENABLED) 42620 int mem_base; 42621 int ret_val; 42622 int code; /* UCS code point */ 42623 int n_code; 42624 42625 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42626 mem_base = xmlMemBlocks(); 42627 code = gen_int(n_code, 0); 42628 42629 ret_val = xmlUCSIsTelugu(code); 42630 desret_int(ret_val); 42631 call_tests++; 42632 des_int(n_code, code, 0); 42633 xmlResetLastError(); 42634 if (mem_base != xmlMemBlocks()) { 42635 printf("Leak of %d blocks found in xmlUCSIsTelugu", 42636 xmlMemBlocks() - mem_base); 42637 test_ret++; 42638 printf(" %d", n_code); 42639 printf("\n"); 42640 } 42641 } 42642 function_tests++; 42643 #endif 42644 42645 return(test_ret); 42646 } 42647 42648 42649 static int 42650 test_xmlUCSIsThaana(void) { 42651 int test_ret = 0; 42652 42653 #if defined(LIBXML_UNICODE_ENABLED) 42654 int mem_base; 42655 int ret_val; 42656 int code; /* UCS code point */ 42657 int n_code; 42658 42659 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42660 mem_base = xmlMemBlocks(); 42661 code = gen_int(n_code, 0); 42662 42663 ret_val = xmlUCSIsThaana(code); 42664 desret_int(ret_val); 42665 call_tests++; 42666 des_int(n_code, code, 0); 42667 xmlResetLastError(); 42668 if (mem_base != xmlMemBlocks()) { 42669 printf("Leak of %d blocks found in xmlUCSIsThaana", 42670 xmlMemBlocks() - mem_base); 42671 test_ret++; 42672 printf(" %d", n_code); 42673 printf("\n"); 42674 } 42675 } 42676 function_tests++; 42677 #endif 42678 42679 return(test_ret); 42680 } 42681 42682 42683 static int 42684 test_xmlUCSIsThai(void) { 42685 int test_ret = 0; 42686 42687 #if defined(LIBXML_UNICODE_ENABLED) 42688 int mem_base; 42689 int ret_val; 42690 int code; /* UCS code point */ 42691 int n_code; 42692 42693 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42694 mem_base = xmlMemBlocks(); 42695 code = gen_int(n_code, 0); 42696 42697 ret_val = xmlUCSIsThai(code); 42698 desret_int(ret_val); 42699 call_tests++; 42700 des_int(n_code, code, 0); 42701 xmlResetLastError(); 42702 if (mem_base != xmlMemBlocks()) { 42703 printf("Leak of %d blocks found in xmlUCSIsThai", 42704 xmlMemBlocks() - mem_base); 42705 test_ret++; 42706 printf(" %d", n_code); 42707 printf("\n"); 42708 } 42709 } 42710 function_tests++; 42711 #endif 42712 42713 return(test_ret); 42714 } 42715 42716 42717 static int 42718 test_xmlUCSIsTibetan(void) { 42719 int test_ret = 0; 42720 42721 #if defined(LIBXML_UNICODE_ENABLED) 42722 int mem_base; 42723 int ret_val; 42724 int code; /* UCS code point */ 42725 int n_code; 42726 42727 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42728 mem_base = xmlMemBlocks(); 42729 code = gen_int(n_code, 0); 42730 42731 ret_val = xmlUCSIsTibetan(code); 42732 desret_int(ret_val); 42733 call_tests++; 42734 des_int(n_code, code, 0); 42735 xmlResetLastError(); 42736 if (mem_base != xmlMemBlocks()) { 42737 printf("Leak of %d blocks found in xmlUCSIsTibetan", 42738 xmlMemBlocks() - mem_base); 42739 test_ret++; 42740 printf(" %d", n_code); 42741 printf("\n"); 42742 } 42743 } 42744 function_tests++; 42745 #endif 42746 42747 return(test_ret); 42748 } 42749 42750 42751 static int 42752 test_xmlUCSIsUgaritic(void) { 42753 int test_ret = 0; 42754 42755 #if defined(LIBXML_UNICODE_ENABLED) 42756 int mem_base; 42757 int ret_val; 42758 int code; /* UCS code point */ 42759 int n_code; 42760 42761 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42762 mem_base = xmlMemBlocks(); 42763 code = gen_int(n_code, 0); 42764 42765 ret_val = xmlUCSIsUgaritic(code); 42766 desret_int(ret_val); 42767 call_tests++; 42768 des_int(n_code, code, 0); 42769 xmlResetLastError(); 42770 if (mem_base != xmlMemBlocks()) { 42771 printf("Leak of %d blocks found in xmlUCSIsUgaritic", 42772 xmlMemBlocks() - mem_base); 42773 test_ret++; 42774 printf(" %d", n_code); 42775 printf("\n"); 42776 } 42777 } 42778 function_tests++; 42779 #endif 42780 42781 return(test_ret); 42782 } 42783 42784 42785 static int 42786 test_xmlUCSIsUnifiedCanadianAboriginalSyllabics(void) { 42787 int test_ret = 0; 42788 42789 #if defined(LIBXML_UNICODE_ENABLED) 42790 int mem_base; 42791 int ret_val; 42792 int code; /* UCS code point */ 42793 int n_code; 42794 42795 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42796 mem_base = xmlMemBlocks(); 42797 code = gen_int(n_code, 0); 42798 42799 ret_val = xmlUCSIsUnifiedCanadianAboriginalSyllabics(code); 42800 desret_int(ret_val); 42801 call_tests++; 42802 des_int(n_code, code, 0); 42803 xmlResetLastError(); 42804 if (mem_base != xmlMemBlocks()) { 42805 printf("Leak of %d blocks found in xmlUCSIsUnifiedCanadianAboriginalSyllabics", 42806 xmlMemBlocks() - mem_base); 42807 test_ret++; 42808 printf(" %d", n_code); 42809 printf("\n"); 42810 } 42811 } 42812 function_tests++; 42813 #endif 42814 42815 return(test_ret); 42816 } 42817 42818 42819 static int 42820 test_xmlUCSIsVariationSelectors(void) { 42821 int test_ret = 0; 42822 42823 #if defined(LIBXML_UNICODE_ENABLED) 42824 int mem_base; 42825 int ret_val; 42826 int code; /* UCS code point */ 42827 int n_code; 42828 42829 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42830 mem_base = xmlMemBlocks(); 42831 code = gen_int(n_code, 0); 42832 42833 ret_val = xmlUCSIsVariationSelectors(code); 42834 desret_int(ret_val); 42835 call_tests++; 42836 des_int(n_code, code, 0); 42837 xmlResetLastError(); 42838 if (mem_base != xmlMemBlocks()) { 42839 printf("Leak of %d blocks found in xmlUCSIsVariationSelectors", 42840 xmlMemBlocks() - mem_base); 42841 test_ret++; 42842 printf(" %d", n_code); 42843 printf("\n"); 42844 } 42845 } 42846 function_tests++; 42847 #endif 42848 42849 return(test_ret); 42850 } 42851 42852 42853 static int 42854 test_xmlUCSIsVariationSelectorsSupplement(void) { 42855 int test_ret = 0; 42856 42857 #if defined(LIBXML_UNICODE_ENABLED) 42858 int mem_base; 42859 int ret_val; 42860 int code; /* UCS code point */ 42861 int n_code; 42862 42863 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42864 mem_base = xmlMemBlocks(); 42865 code = gen_int(n_code, 0); 42866 42867 ret_val = xmlUCSIsVariationSelectorsSupplement(code); 42868 desret_int(ret_val); 42869 call_tests++; 42870 des_int(n_code, code, 0); 42871 xmlResetLastError(); 42872 if (mem_base != xmlMemBlocks()) { 42873 printf("Leak of %d blocks found in xmlUCSIsVariationSelectorsSupplement", 42874 xmlMemBlocks() - mem_base); 42875 test_ret++; 42876 printf(" %d", n_code); 42877 printf("\n"); 42878 } 42879 } 42880 function_tests++; 42881 #endif 42882 42883 return(test_ret); 42884 } 42885 42886 42887 static int 42888 test_xmlUCSIsYiRadicals(void) { 42889 int test_ret = 0; 42890 42891 #if defined(LIBXML_UNICODE_ENABLED) 42892 int mem_base; 42893 int ret_val; 42894 int code; /* UCS code point */ 42895 int n_code; 42896 42897 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42898 mem_base = xmlMemBlocks(); 42899 code = gen_int(n_code, 0); 42900 42901 ret_val = xmlUCSIsYiRadicals(code); 42902 desret_int(ret_val); 42903 call_tests++; 42904 des_int(n_code, code, 0); 42905 xmlResetLastError(); 42906 if (mem_base != xmlMemBlocks()) { 42907 printf("Leak of %d blocks found in xmlUCSIsYiRadicals", 42908 xmlMemBlocks() - mem_base); 42909 test_ret++; 42910 printf(" %d", n_code); 42911 printf("\n"); 42912 } 42913 } 42914 function_tests++; 42915 #endif 42916 42917 return(test_ret); 42918 } 42919 42920 42921 static int 42922 test_xmlUCSIsYiSyllables(void) { 42923 int test_ret = 0; 42924 42925 #if defined(LIBXML_UNICODE_ENABLED) 42926 int mem_base; 42927 int ret_val; 42928 int code; /* UCS code point */ 42929 int n_code; 42930 42931 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42932 mem_base = xmlMemBlocks(); 42933 code = gen_int(n_code, 0); 42934 42935 ret_val = xmlUCSIsYiSyllables(code); 42936 desret_int(ret_val); 42937 call_tests++; 42938 des_int(n_code, code, 0); 42939 xmlResetLastError(); 42940 if (mem_base != xmlMemBlocks()) { 42941 printf("Leak of %d blocks found in xmlUCSIsYiSyllables", 42942 xmlMemBlocks() - mem_base); 42943 test_ret++; 42944 printf(" %d", n_code); 42945 printf("\n"); 42946 } 42947 } 42948 function_tests++; 42949 #endif 42950 42951 return(test_ret); 42952 } 42953 42954 42955 static int 42956 test_xmlUCSIsYijingHexagramSymbols(void) { 42957 int test_ret = 0; 42958 42959 #if defined(LIBXML_UNICODE_ENABLED) 42960 int mem_base; 42961 int ret_val; 42962 int code; /* UCS code point */ 42963 int n_code; 42964 42965 for (n_code = 0;n_code < gen_nb_int;n_code++) { 42966 mem_base = xmlMemBlocks(); 42967 code = gen_int(n_code, 0); 42968 42969 ret_val = xmlUCSIsYijingHexagramSymbols(code); 42970 desret_int(ret_val); 42971 call_tests++; 42972 des_int(n_code, code, 0); 42973 xmlResetLastError(); 42974 if (mem_base != xmlMemBlocks()) { 42975 printf("Leak of %d blocks found in xmlUCSIsYijingHexagramSymbols", 42976 xmlMemBlocks() - mem_base); 42977 test_ret++; 42978 printf(" %d", n_code); 42979 printf("\n"); 42980 } 42981 } 42982 function_tests++; 42983 #endif 42984 42985 return(test_ret); 42986 } 42987 42988 static int 42989 test_xmlunicode(void) { 42990 int test_ret = 0; 42991 42992 if (quiet == 0) printf("Testing xmlunicode : 166 of 166 functions ...\n"); 42993 test_ret += test_xmlUCSIsAegeanNumbers(); 42994 test_ret += test_xmlUCSIsAlphabeticPresentationForms(); 42995 test_ret += test_xmlUCSIsArabic(); 42996 test_ret += test_xmlUCSIsArabicPresentationFormsA(); 42997 test_ret += test_xmlUCSIsArabicPresentationFormsB(); 42998 test_ret += test_xmlUCSIsArmenian(); 42999 test_ret += test_xmlUCSIsArrows(); 43000 test_ret += test_xmlUCSIsBasicLatin(); 43001 test_ret += test_xmlUCSIsBengali(); 43002 test_ret += test_xmlUCSIsBlock(); 43003 test_ret += test_xmlUCSIsBlockElements(); 43004 test_ret += test_xmlUCSIsBopomofo(); 43005 test_ret += test_xmlUCSIsBopomofoExtended(); 43006 test_ret += test_xmlUCSIsBoxDrawing(); 43007 test_ret += test_xmlUCSIsBraillePatterns(); 43008 test_ret += test_xmlUCSIsBuhid(); 43009 test_ret += test_xmlUCSIsByzantineMusicalSymbols(); 43010 test_ret += test_xmlUCSIsCJKCompatibility(); 43011 test_ret += test_xmlUCSIsCJKCompatibilityForms(); 43012 test_ret += test_xmlUCSIsCJKCompatibilityIdeographs(); 43013 test_ret += test_xmlUCSIsCJKCompatibilityIdeographsSupplement(); 43014 test_ret += test_xmlUCSIsCJKRadicalsSupplement(); 43015 test_ret += test_xmlUCSIsCJKSymbolsandPunctuation(); 43016 test_ret += test_xmlUCSIsCJKUnifiedIdeographs(); 43017 test_ret += test_xmlUCSIsCJKUnifiedIdeographsExtensionA(); 43018 test_ret += test_xmlUCSIsCJKUnifiedIdeographsExtensionB(); 43019 test_ret += test_xmlUCSIsCat(); 43020 test_ret += test_xmlUCSIsCatC(); 43021 test_ret += test_xmlUCSIsCatCc(); 43022 test_ret += test_xmlUCSIsCatCf(); 43023 test_ret += test_xmlUCSIsCatCo(); 43024 test_ret += test_xmlUCSIsCatCs(); 43025 test_ret += test_xmlUCSIsCatL(); 43026 test_ret += test_xmlUCSIsCatLl(); 43027 test_ret += test_xmlUCSIsCatLm(); 43028 test_ret += test_xmlUCSIsCatLo(); 43029 test_ret += test_xmlUCSIsCatLt(); 43030 test_ret += test_xmlUCSIsCatLu(); 43031 test_ret += test_xmlUCSIsCatM(); 43032 test_ret += test_xmlUCSIsCatMc(); 43033 test_ret += test_xmlUCSIsCatMe(); 43034 test_ret += test_xmlUCSIsCatMn(); 43035 test_ret += test_xmlUCSIsCatN(); 43036 test_ret += test_xmlUCSIsCatNd(); 43037 test_ret += test_xmlUCSIsCatNl(); 43038 test_ret += test_xmlUCSIsCatNo(); 43039 test_ret += test_xmlUCSIsCatP(); 43040 test_ret += test_xmlUCSIsCatPc(); 43041 test_ret += test_xmlUCSIsCatPd(); 43042 test_ret += test_xmlUCSIsCatPe(); 43043 test_ret += test_xmlUCSIsCatPf(); 43044 test_ret += test_xmlUCSIsCatPi(); 43045 test_ret += test_xmlUCSIsCatPo(); 43046 test_ret += test_xmlUCSIsCatPs(); 43047 test_ret += test_xmlUCSIsCatS(); 43048 test_ret += test_xmlUCSIsCatSc(); 43049 test_ret += test_xmlUCSIsCatSk(); 43050 test_ret += test_xmlUCSIsCatSm(); 43051 test_ret += test_xmlUCSIsCatSo(); 43052 test_ret += test_xmlUCSIsCatZ(); 43053 test_ret += test_xmlUCSIsCatZl(); 43054 test_ret += test_xmlUCSIsCatZp(); 43055 test_ret += test_xmlUCSIsCatZs(); 43056 test_ret += test_xmlUCSIsCherokee(); 43057 test_ret += test_xmlUCSIsCombiningDiacriticalMarks(); 43058 test_ret += test_xmlUCSIsCombiningDiacriticalMarksforSymbols(); 43059 test_ret += test_xmlUCSIsCombiningHalfMarks(); 43060 test_ret += test_xmlUCSIsCombiningMarksforSymbols(); 43061 test_ret += test_xmlUCSIsControlPictures(); 43062 test_ret += test_xmlUCSIsCurrencySymbols(); 43063 test_ret += test_xmlUCSIsCypriotSyllabary(); 43064 test_ret += test_xmlUCSIsCyrillic(); 43065 test_ret += test_xmlUCSIsCyrillicSupplement(); 43066 test_ret += test_xmlUCSIsDeseret(); 43067 test_ret += test_xmlUCSIsDevanagari(); 43068 test_ret += test_xmlUCSIsDingbats(); 43069 test_ret += test_xmlUCSIsEnclosedAlphanumerics(); 43070 test_ret += test_xmlUCSIsEnclosedCJKLettersandMonths(); 43071 test_ret += test_xmlUCSIsEthiopic(); 43072 test_ret += test_xmlUCSIsGeneralPunctuation(); 43073 test_ret += test_xmlUCSIsGeometricShapes(); 43074 test_ret += test_xmlUCSIsGeorgian(); 43075 test_ret += test_xmlUCSIsGothic(); 43076 test_ret += test_xmlUCSIsGreek(); 43077 test_ret += test_xmlUCSIsGreekExtended(); 43078 test_ret += test_xmlUCSIsGreekandCoptic(); 43079 test_ret += test_xmlUCSIsGujarati(); 43080 test_ret += test_xmlUCSIsGurmukhi(); 43081 test_ret += test_xmlUCSIsHalfwidthandFullwidthForms(); 43082 test_ret += test_xmlUCSIsHangulCompatibilityJamo(); 43083 test_ret += test_xmlUCSIsHangulJamo(); 43084 test_ret += test_xmlUCSIsHangulSyllables(); 43085 test_ret += test_xmlUCSIsHanunoo(); 43086 test_ret += test_xmlUCSIsHebrew(); 43087 test_ret += test_xmlUCSIsHighPrivateUseSurrogates(); 43088 test_ret += test_xmlUCSIsHighSurrogates(); 43089 test_ret += test_xmlUCSIsHiragana(); 43090 test_ret += test_xmlUCSIsIPAExtensions(); 43091 test_ret += test_xmlUCSIsIdeographicDescriptionCharacters(); 43092 test_ret += test_xmlUCSIsKanbun(); 43093 test_ret += test_xmlUCSIsKangxiRadicals(); 43094 test_ret += test_xmlUCSIsKannada(); 43095 test_ret += test_xmlUCSIsKatakana(); 43096 test_ret += test_xmlUCSIsKatakanaPhoneticExtensions(); 43097 test_ret += test_xmlUCSIsKhmer(); 43098 test_ret += test_xmlUCSIsKhmerSymbols(); 43099 test_ret += test_xmlUCSIsLao(); 43100 test_ret += test_xmlUCSIsLatin1Supplement(); 43101 test_ret += test_xmlUCSIsLatinExtendedA(); 43102 test_ret += test_xmlUCSIsLatinExtendedAdditional(); 43103 test_ret += test_xmlUCSIsLatinExtendedB(); 43104 test_ret += test_xmlUCSIsLetterlikeSymbols(); 43105 test_ret += test_xmlUCSIsLimbu(); 43106 test_ret += test_xmlUCSIsLinearBIdeograms(); 43107 test_ret += test_xmlUCSIsLinearBSyllabary(); 43108 test_ret += test_xmlUCSIsLowSurrogates(); 43109 test_ret += test_xmlUCSIsMalayalam(); 43110 test_ret += test_xmlUCSIsMathematicalAlphanumericSymbols(); 43111 test_ret += test_xmlUCSIsMathematicalOperators(); 43112 test_ret += test_xmlUCSIsMiscellaneousMathematicalSymbolsA(); 43113 test_ret += test_xmlUCSIsMiscellaneousMathematicalSymbolsB(); 43114 test_ret += test_xmlUCSIsMiscellaneousSymbols(); 43115 test_ret += test_xmlUCSIsMiscellaneousSymbolsandArrows(); 43116 test_ret += test_xmlUCSIsMiscellaneousTechnical(); 43117 test_ret += test_xmlUCSIsMongolian(); 43118 test_ret += test_xmlUCSIsMusicalSymbols(); 43119 test_ret += test_xmlUCSIsMyanmar(); 43120 test_ret += test_xmlUCSIsNumberForms(); 43121 test_ret += test_xmlUCSIsOgham(); 43122 test_ret += test_xmlUCSIsOldItalic(); 43123 test_ret += test_xmlUCSIsOpticalCharacterRecognition(); 43124 test_ret += test_xmlUCSIsOriya(); 43125 test_ret += test_xmlUCSIsOsmanya(); 43126 test_ret += test_xmlUCSIsPhoneticExtensions(); 43127 test_ret += test_xmlUCSIsPrivateUse(); 43128 test_ret += test_xmlUCSIsPrivateUseArea(); 43129 test_ret += test_xmlUCSIsRunic(); 43130 test_ret += test_xmlUCSIsShavian(); 43131 test_ret += test_xmlUCSIsSinhala(); 43132 test_ret += test_xmlUCSIsSmallFormVariants(); 43133 test_ret += test_xmlUCSIsSpacingModifierLetters(); 43134 test_ret += test_xmlUCSIsSpecials(); 43135 test_ret += test_xmlUCSIsSuperscriptsandSubscripts(); 43136 test_ret += test_xmlUCSIsSupplementalArrowsA(); 43137 test_ret += test_xmlUCSIsSupplementalArrowsB(); 43138 test_ret += test_xmlUCSIsSupplementalMathematicalOperators(); 43139 test_ret += test_xmlUCSIsSupplementaryPrivateUseAreaA(); 43140 test_ret += test_xmlUCSIsSupplementaryPrivateUseAreaB(); 43141 test_ret += test_xmlUCSIsSyriac(); 43142 test_ret += test_xmlUCSIsTagalog(); 43143 test_ret += test_xmlUCSIsTagbanwa(); 43144 test_ret += test_xmlUCSIsTags(); 43145 test_ret += test_xmlUCSIsTaiLe(); 43146 test_ret += test_xmlUCSIsTaiXuanJingSymbols(); 43147 test_ret += test_xmlUCSIsTamil(); 43148 test_ret += test_xmlUCSIsTelugu(); 43149 test_ret += test_xmlUCSIsThaana(); 43150 test_ret += test_xmlUCSIsThai(); 43151 test_ret += test_xmlUCSIsTibetan(); 43152 test_ret += test_xmlUCSIsUgaritic(); 43153 test_ret += test_xmlUCSIsUnifiedCanadianAboriginalSyllabics(); 43154 test_ret += test_xmlUCSIsVariationSelectors(); 43155 test_ret += test_xmlUCSIsVariationSelectorsSupplement(); 43156 test_ret += test_xmlUCSIsYiRadicals(); 43157 test_ret += test_xmlUCSIsYiSyllables(); 43158 test_ret += test_xmlUCSIsYijingHexagramSymbols(); 43159 43160 if (test_ret != 0) 43161 printf("Module xmlunicode: %d errors\n", test_ret); 43162 return(test_ret); 43163 } 43164 43165 static int 43166 test_xmlNewTextWriter(void) { 43167 int test_ret = 0; 43168 43169 #if defined(LIBXML_WRITER_ENABLED) 43170 int mem_base; 43171 xmlTextWriterPtr ret_val; 43172 xmlOutputBufferPtr out; /* an xmlOutputBufferPtr */ 43173 int n_out; 43174 43175 for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) { 43176 mem_base = xmlMemBlocks(); 43177 out = gen_xmlOutputBufferPtr(n_out, 0); 43178 43179 ret_val = xmlNewTextWriter(out); 43180 if (ret_val != NULL) out = NULL; 43181 desret_xmlTextWriterPtr(ret_val); 43182 call_tests++; 43183 des_xmlOutputBufferPtr(n_out, out, 0); 43184 xmlResetLastError(); 43185 if (mem_base != xmlMemBlocks()) { 43186 printf("Leak of %d blocks found in xmlNewTextWriter", 43187 xmlMemBlocks() - mem_base); 43188 test_ret++; 43189 printf(" %d", n_out); 43190 printf("\n"); 43191 } 43192 } 43193 function_tests++; 43194 #endif 43195 43196 return(test_ret); 43197 } 43198 43199 43200 static int 43201 test_xmlNewTextWriterFilename(void) { 43202 int test_ret = 0; 43203 43204 #if defined(LIBXML_WRITER_ENABLED) 43205 int mem_base; 43206 xmlTextWriterPtr ret_val; 43207 const char * uri; /* the URI of the resource for the output */ 43208 int n_uri; 43209 int compression; /* compress the output? */ 43210 int n_compression; 43211 43212 for (n_uri = 0;n_uri < gen_nb_fileoutput;n_uri++) { 43213 for (n_compression = 0;n_compression < gen_nb_int;n_compression++) { 43214 mem_base = xmlMemBlocks(); 43215 uri = gen_fileoutput(n_uri, 0); 43216 compression = gen_int(n_compression, 1); 43217 43218 ret_val = xmlNewTextWriterFilename(uri, compression); 43219 desret_xmlTextWriterPtr(ret_val); 43220 call_tests++; 43221 des_fileoutput(n_uri, uri, 0); 43222 des_int(n_compression, compression, 1); 43223 xmlResetLastError(); 43224 if (mem_base != xmlMemBlocks()) { 43225 printf("Leak of %d blocks found in xmlNewTextWriterFilename", 43226 xmlMemBlocks() - mem_base); 43227 test_ret++; 43228 printf(" %d", n_uri); 43229 printf(" %d", n_compression); 43230 printf("\n"); 43231 } 43232 } 43233 } 43234 function_tests++; 43235 #endif 43236 43237 return(test_ret); 43238 } 43239 43240 43241 static int 43242 test_xmlNewTextWriterMemory(void) { 43243 int test_ret = 0; 43244 43245 #if defined(LIBXML_WRITER_ENABLED) 43246 int mem_base; 43247 xmlTextWriterPtr ret_val; 43248 xmlBufferPtr buf; /* xmlBufferPtr */ 43249 int n_buf; 43250 int compression; /* compress the output? */ 43251 int n_compression; 43252 43253 for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) { 43254 for (n_compression = 0;n_compression < gen_nb_int;n_compression++) { 43255 mem_base = xmlMemBlocks(); 43256 buf = gen_xmlBufferPtr(n_buf, 0); 43257 compression = gen_int(n_compression, 1); 43258 43259 ret_val = xmlNewTextWriterMemory(buf, compression); 43260 desret_xmlTextWriterPtr(ret_val); 43261 call_tests++; 43262 des_xmlBufferPtr(n_buf, buf, 0); 43263 des_int(n_compression, compression, 1); 43264 xmlResetLastError(); 43265 if (mem_base != xmlMemBlocks()) { 43266 printf("Leak of %d blocks found in xmlNewTextWriterMemory", 43267 xmlMemBlocks() - mem_base); 43268 test_ret++; 43269 printf(" %d", n_buf); 43270 printf(" %d", n_compression); 43271 printf("\n"); 43272 } 43273 } 43274 } 43275 function_tests++; 43276 #endif 43277 43278 return(test_ret); 43279 } 43280 43281 43282 static int 43283 test_xmlNewTextWriterPushParser(void) { 43284 int test_ret = 0; 43285 43286 #if defined(LIBXML_WRITER_ENABLED) 43287 int mem_base; 43288 xmlTextWriterPtr ret_val; 43289 xmlParserCtxtPtr ctxt; /* xmlParserCtxtPtr to hold the new XML document tree */ 43290 int n_ctxt; 43291 int compression; /* compress the output? */ 43292 int n_compression; 43293 43294 for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) { 43295 for (n_compression = 0;n_compression < gen_nb_int;n_compression++) { 43296 mem_base = xmlMemBlocks(); 43297 ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0); 43298 compression = gen_int(n_compression, 1); 43299 43300 ret_val = xmlNewTextWriterPushParser(ctxt, compression); 43301 if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;} if (ret_val != NULL) ctxt = NULL; 43302 desret_xmlTextWriterPtr(ret_val); 43303 call_tests++; 43304 des_xmlParserCtxtPtr(n_ctxt, ctxt, 0); 43305 des_int(n_compression, compression, 1); 43306 xmlResetLastError(); 43307 if (mem_base != xmlMemBlocks()) { 43308 printf("Leak of %d blocks found in xmlNewTextWriterPushParser", 43309 xmlMemBlocks() - mem_base); 43310 test_ret++; 43311 printf(" %d", n_ctxt); 43312 printf(" %d", n_compression); 43313 printf("\n"); 43314 } 43315 } 43316 } 43317 function_tests++; 43318 #endif 43319 43320 return(test_ret); 43321 } 43322 43323 43324 static int 43325 test_xmlNewTextWriterTree(void) { 43326 int test_ret = 0; 43327 43328 #if defined(LIBXML_WRITER_ENABLED) 43329 int mem_base; 43330 xmlTextWriterPtr ret_val; 43331 xmlDocPtr doc; /* xmlDocPtr */ 43332 int n_doc; 43333 xmlNodePtr node; /* xmlNodePtr or NULL for doc->children */ 43334 int n_node; 43335 int compression; /* compress the output? */ 43336 int n_compression; 43337 43338 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 43339 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 43340 for (n_compression = 0;n_compression < gen_nb_int;n_compression++) { 43341 mem_base = xmlMemBlocks(); 43342 doc = gen_xmlDocPtr(n_doc, 0); 43343 node = gen_xmlNodePtr(n_node, 1); 43344 compression = gen_int(n_compression, 2); 43345 43346 ret_val = xmlNewTextWriterTree(doc, node, compression); 43347 desret_xmlTextWriterPtr(ret_val); 43348 call_tests++; 43349 des_xmlDocPtr(n_doc, doc, 0); 43350 des_xmlNodePtr(n_node, node, 1); 43351 des_int(n_compression, compression, 2); 43352 xmlResetLastError(); 43353 if (mem_base != xmlMemBlocks()) { 43354 printf("Leak of %d blocks found in xmlNewTextWriterTree", 43355 xmlMemBlocks() - mem_base); 43356 test_ret++; 43357 printf(" %d", n_doc); 43358 printf(" %d", n_node); 43359 printf(" %d", n_compression); 43360 printf("\n"); 43361 } 43362 } 43363 } 43364 } 43365 function_tests++; 43366 #endif 43367 43368 return(test_ret); 43369 } 43370 43371 43372 static int 43373 test_xmlTextWriterEndAttribute(void) { 43374 int test_ret = 0; 43375 43376 #if defined(LIBXML_WRITER_ENABLED) 43377 int mem_base; 43378 int ret_val; 43379 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 43380 int n_writer; 43381 43382 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 43383 mem_base = xmlMemBlocks(); 43384 writer = gen_xmlTextWriterPtr(n_writer, 0); 43385 43386 ret_val = xmlTextWriterEndAttribute(writer); 43387 desret_int(ret_val); 43388 call_tests++; 43389 des_xmlTextWriterPtr(n_writer, writer, 0); 43390 xmlResetLastError(); 43391 if (mem_base != xmlMemBlocks()) { 43392 printf("Leak of %d blocks found in xmlTextWriterEndAttribute", 43393 xmlMemBlocks() - mem_base); 43394 test_ret++; 43395 printf(" %d", n_writer); 43396 printf("\n"); 43397 } 43398 } 43399 function_tests++; 43400 #endif 43401 43402 return(test_ret); 43403 } 43404 43405 43406 static int 43407 test_xmlTextWriterEndCDATA(void) { 43408 int test_ret = 0; 43409 43410 #if defined(LIBXML_WRITER_ENABLED) 43411 int mem_base; 43412 int ret_val; 43413 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 43414 int n_writer; 43415 43416 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 43417 mem_base = xmlMemBlocks(); 43418 writer = gen_xmlTextWriterPtr(n_writer, 0); 43419 43420 ret_val = xmlTextWriterEndCDATA(writer); 43421 desret_int(ret_val); 43422 call_tests++; 43423 des_xmlTextWriterPtr(n_writer, writer, 0); 43424 xmlResetLastError(); 43425 if (mem_base != xmlMemBlocks()) { 43426 printf("Leak of %d blocks found in xmlTextWriterEndCDATA", 43427 xmlMemBlocks() - mem_base); 43428 test_ret++; 43429 printf(" %d", n_writer); 43430 printf("\n"); 43431 } 43432 } 43433 function_tests++; 43434 #endif 43435 43436 return(test_ret); 43437 } 43438 43439 43440 static int 43441 test_xmlTextWriterEndComment(void) { 43442 int test_ret = 0; 43443 43444 #if defined(LIBXML_WRITER_ENABLED) 43445 int mem_base; 43446 int ret_val; 43447 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 43448 int n_writer; 43449 43450 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 43451 mem_base = xmlMemBlocks(); 43452 writer = gen_xmlTextWriterPtr(n_writer, 0); 43453 43454 ret_val = xmlTextWriterEndComment(writer); 43455 desret_int(ret_val); 43456 call_tests++; 43457 des_xmlTextWriterPtr(n_writer, writer, 0); 43458 xmlResetLastError(); 43459 if (mem_base != xmlMemBlocks()) { 43460 printf("Leak of %d blocks found in xmlTextWriterEndComment", 43461 xmlMemBlocks() - mem_base); 43462 test_ret++; 43463 printf(" %d", n_writer); 43464 printf("\n"); 43465 } 43466 } 43467 function_tests++; 43468 #endif 43469 43470 return(test_ret); 43471 } 43472 43473 43474 static int 43475 test_xmlTextWriterEndDTD(void) { 43476 int test_ret = 0; 43477 43478 #if defined(LIBXML_WRITER_ENABLED) 43479 int mem_base; 43480 int ret_val; 43481 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 43482 int n_writer; 43483 43484 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 43485 mem_base = xmlMemBlocks(); 43486 writer = gen_xmlTextWriterPtr(n_writer, 0); 43487 43488 ret_val = xmlTextWriterEndDTD(writer); 43489 desret_int(ret_val); 43490 call_tests++; 43491 des_xmlTextWriterPtr(n_writer, writer, 0); 43492 xmlResetLastError(); 43493 if (mem_base != xmlMemBlocks()) { 43494 printf("Leak of %d blocks found in xmlTextWriterEndDTD", 43495 xmlMemBlocks() - mem_base); 43496 test_ret++; 43497 printf(" %d", n_writer); 43498 printf("\n"); 43499 } 43500 } 43501 function_tests++; 43502 #endif 43503 43504 return(test_ret); 43505 } 43506 43507 43508 static int 43509 test_xmlTextWriterEndDTDAttlist(void) { 43510 int test_ret = 0; 43511 43512 #if defined(LIBXML_WRITER_ENABLED) 43513 int mem_base; 43514 int ret_val; 43515 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 43516 int n_writer; 43517 43518 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 43519 mem_base = xmlMemBlocks(); 43520 writer = gen_xmlTextWriterPtr(n_writer, 0); 43521 43522 ret_val = xmlTextWriterEndDTDAttlist(writer); 43523 desret_int(ret_val); 43524 call_tests++; 43525 des_xmlTextWriterPtr(n_writer, writer, 0); 43526 xmlResetLastError(); 43527 if (mem_base != xmlMemBlocks()) { 43528 printf("Leak of %d blocks found in xmlTextWriterEndDTDAttlist", 43529 xmlMemBlocks() - mem_base); 43530 test_ret++; 43531 printf(" %d", n_writer); 43532 printf("\n"); 43533 } 43534 } 43535 function_tests++; 43536 #endif 43537 43538 return(test_ret); 43539 } 43540 43541 43542 static int 43543 test_xmlTextWriterEndDTDElement(void) { 43544 int test_ret = 0; 43545 43546 #if defined(LIBXML_WRITER_ENABLED) 43547 int mem_base; 43548 int ret_val; 43549 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 43550 int n_writer; 43551 43552 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 43553 mem_base = xmlMemBlocks(); 43554 writer = gen_xmlTextWriterPtr(n_writer, 0); 43555 43556 ret_val = xmlTextWriterEndDTDElement(writer); 43557 desret_int(ret_val); 43558 call_tests++; 43559 des_xmlTextWriterPtr(n_writer, writer, 0); 43560 xmlResetLastError(); 43561 if (mem_base != xmlMemBlocks()) { 43562 printf("Leak of %d blocks found in xmlTextWriterEndDTDElement", 43563 xmlMemBlocks() - mem_base); 43564 test_ret++; 43565 printf(" %d", n_writer); 43566 printf("\n"); 43567 } 43568 } 43569 function_tests++; 43570 #endif 43571 43572 return(test_ret); 43573 } 43574 43575 43576 static int 43577 test_xmlTextWriterEndDTDEntity(void) { 43578 int test_ret = 0; 43579 43580 #if defined(LIBXML_WRITER_ENABLED) 43581 int mem_base; 43582 int ret_val; 43583 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 43584 int n_writer; 43585 43586 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 43587 mem_base = xmlMemBlocks(); 43588 writer = gen_xmlTextWriterPtr(n_writer, 0); 43589 43590 ret_val = xmlTextWriterEndDTDEntity(writer); 43591 desret_int(ret_val); 43592 call_tests++; 43593 des_xmlTextWriterPtr(n_writer, writer, 0); 43594 xmlResetLastError(); 43595 if (mem_base != xmlMemBlocks()) { 43596 printf("Leak of %d blocks found in xmlTextWriterEndDTDEntity", 43597 xmlMemBlocks() - mem_base); 43598 test_ret++; 43599 printf(" %d", n_writer); 43600 printf("\n"); 43601 } 43602 } 43603 function_tests++; 43604 #endif 43605 43606 return(test_ret); 43607 } 43608 43609 43610 static int 43611 test_xmlTextWriterEndDocument(void) { 43612 int test_ret = 0; 43613 43614 #if defined(LIBXML_WRITER_ENABLED) 43615 int mem_base; 43616 int ret_val; 43617 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 43618 int n_writer; 43619 43620 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 43621 mem_base = xmlMemBlocks(); 43622 writer = gen_xmlTextWriterPtr(n_writer, 0); 43623 43624 ret_val = xmlTextWriterEndDocument(writer); 43625 desret_int(ret_val); 43626 call_tests++; 43627 des_xmlTextWriterPtr(n_writer, writer, 0); 43628 xmlResetLastError(); 43629 if (mem_base != xmlMemBlocks()) { 43630 printf("Leak of %d blocks found in xmlTextWriterEndDocument", 43631 xmlMemBlocks() - mem_base); 43632 test_ret++; 43633 printf(" %d", n_writer); 43634 printf("\n"); 43635 } 43636 } 43637 function_tests++; 43638 #endif 43639 43640 return(test_ret); 43641 } 43642 43643 43644 static int 43645 test_xmlTextWriterEndElement(void) { 43646 int test_ret = 0; 43647 43648 #if defined(LIBXML_WRITER_ENABLED) 43649 int mem_base; 43650 int ret_val; 43651 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 43652 int n_writer; 43653 43654 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 43655 mem_base = xmlMemBlocks(); 43656 writer = gen_xmlTextWriterPtr(n_writer, 0); 43657 43658 ret_val = xmlTextWriterEndElement(writer); 43659 desret_int(ret_val); 43660 call_tests++; 43661 des_xmlTextWriterPtr(n_writer, writer, 0); 43662 xmlResetLastError(); 43663 if (mem_base != xmlMemBlocks()) { 43664 printf("Leak of %d blocks found in xmlTextWriterEndElement", 43665 xmlMemBlocks() - mem_base); 43666 test_ret++; 43667 printf(" %d", n_writer); 43668 printf("\n"); 43669 } 43670 } 43671 function_tests++; 43672 #endif 43673 43674 return(test_ret); 43675 } 43676 43677 43678 static int 43679 test_xmlTextWriterEndPI(void) { 43680 int test_ret = 0; 43681 43682 #if defined(LIBXML_WRITER_ENABLED) 43683 int mem_base; 43684 int ret_val; 43685 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 43686 int n_writer; 43687 43688 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 43689 mem_base = xmlMemBlocks(); 43690 writer = gen_xmlTextWriterPtr(n_writer, 0); 43691 43692 ret_val = xmlTextWriterEndPI(writer); 43693 desret_int(ret_val); 43694 call_tests++; 43695 des_xmlTextWriterPtr(n_writer, writer, 0); 43696 xmlResetLastError(); 43697 if (mem_base != xmlMemBlocks()) { 43698 printf("Leak of %d blocks found in xmlTextWriterEndPI", 43699 xmlMemBlocks() - mem_base); 43700 test_ret++; 43701 printf(" %d", n_writer); 43702 printf("\n"); 43703 } 43704 } 43705 function_tests++; 43706 #endif 43707 43708 return(test_ret); 43709 } 43710 43711 43712 static int 43713 test_xmlTextWriterFlush(void) { 43714 int test_ret = 0; 43715 43716 #if defined(LIBXML_WRITER_ENABLED) 43717 int mem_base; 43718 int ret_val; 43719 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 43720 int n_writer; 43721 43722 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 43723 mem_base = xmlMemBlocks(); 43724 writer = gen_xmlTextWriterPtr(n_writer, 0); 43725 43726 ret_val = xmlTextWriterFlush(writer); 43727 desret_int(ret_val); 43728 call_tests++; 43729 des_xmlTextWriterPtr(n_writer, writer, 0); 43730 xmlResetLastError(); 43731 if (mem_base != xmlMemBlocks()) { 43732 printf("Leak of %d blocks found in xmlTextWriterFlush", 43733 xmlMemBlocks() - mem_base); 43734 test_ret++; 43735 printf(" %d", n_writer); 43736 printf("\n"); 43737 } 43738 } 43739 function_tests++; 43740 #endif 43741 43742 return(test_ret); 43743 } 43744 43745 43746 static int 43747 test_xmlTextWriterFullEndElement(void) { 43748 int test_ret = 0; 43749 43750 #if defined(LIBXML_WRITER_ENABLED) 43751 int mem_base; 43752 int ret_val; 43753 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 43754 int n_writer; 43755 43756 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 43757 mem_base = xmlMemBlocks(); 43758 writer = gen_xmlTextWriterPtr(n_writer, 0); 43759 43760 ret_val = xmlTextWriterFullEndElement(writer); 43761 desret_int(ret_val); 43762 call_tests++; 43763 des_xmlTextWriterPtr(n_writer, writer, 0); 43764 xmlResetLastError(); 43765 if (mem_base != xmlMemBlocks()) { 43766 printf("Leak of %d blocks found in xmlTextWriterFullEndElement", 43767 xmlMemBlocks() - mem_base); 43768 test_ret++; 43769 printf(" %d", n_writer); 43770 printf("\n"); 43771 } 43772 } 43773 function_tests++; 43774 #endif 43775 43776 return(test_ret); 43777 } 43778 43779 43780 static int 43781 test_xmlTextWriterSetIndent(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 int indent; /* do indentation? */ 43790 int n_indent; 43791 43792 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 43793 for (n_indent = 0;n_indent < gen_nb_int;n_indent++) { 43794 mem_base = xmlMemBlocks(); 43795 writer = gen_xmlTextWriterPtr(n_writer, 0); 43796 indent = gen_int(n_indent, 1); 43797 43798 ret_val = xmlTextWriterSetIndent(writer, indent); 43799 desret_int(ret_val); 43800 call_tests++; 43801 des_xmlTextWriterPtr(n_writer, writer, 0); 43802 des_int(n_indent, indent, 1); 43803 xmlResetLastError(); 43804 if (mem_base != xmlMemBlocks()) { 43805 printf("Leak of %d blocks found in xmlTextWriterSetIndent", 43806 xmlMemBlocks() - mem_base); 43807 test_ret++; 43808 printf(" %d", n_writer); 43809 printf(" %d", n_indent); 43810 printf("\n"); 43811 } 43812 } 43813 } 43814 function_tests++; 43815 #endif 43816 43817 return(test_ret); 43818 } 43819 43820 43821 static int 43822 test_xmlTextWriterSetIndentString(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 xmlChar * str; /* the xmlChar string */ 43831 int n_str; 43832 43833 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 43834 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 43835 mem_base = xmlMemBlocks(); 43836 writer = gen_xmlTextWriterPtr(n_writer, 0); 43837 str = gen_const_xmlChar_ptr(n_str, 1); 43838 43839 ret_val = xmlTextWriterSetIndentString(writer, (const xmlChar *)str); 43840 desret_int(ret_val); 43841 call_tests++; 43842 des_xmlTextWriterPtr(n_writer, writer, 0); 43843 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1); 43844 xmlResetLastError(); 43845 if (mem_base != xmlMemBlocks()) { 43846 printf("Leak of %d blocks found in xmlTextWriterSetIndentString", 43847 xmlMemBlocks() - mem_base); 43848 test_ret++; 43849 printf(" %d", n_writer); 43850 printf(" %d", n_str); 43851 printf("\n"); 43852 } 43853 } 43854 } 43855 function_tests++; 43856 #endif 43857 43858 return(test_ret); 43859 } 43860 43861 43862 static int 43863 test_xmlTextWriterSetQuoteChar(void) { 43864 int test_ret = 0; 43865 43866 #if defined(LIBXML_WRITER_ENABLED) 43867 int mem_base; 43868 int ret_val; 43869 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 43870 int n_writer; 43871 xmlChar quotechar; /* the quote character */ 43872 int n_quotechar; 43873 43874 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 43875 for (n_quotechar = 0;n_quotechar < gen_nb_xmlChar;n_quotechar++) { 43876 mem_base = xmlMemBlocks(); 43877 writer = gen_xmlTextWriterPtr(n_writer, 0); 43878 quotechar = gen_xmlChar(n_quotechar, 1); 43879 43880 ret_val = xmlTextWriterSetQuoteChar(writer, quotechar); 43881 desret_int(ret_val); 43882 call_tests++; 43883 des_xmlTextWriterPtr(n_writer, writer, 0); 43884 des_xmlChar(n_quotechar, quotechar, 1); 43885 xmlResetLastError(); 43886 if (mem_base != xmlMemBlocks()) { 43887 printf("Leak of %d blocks found in xmlTextWriterSetQuoteChar", 43888 xmlMemBlocks() - mem_base); 43889 test_ret++; 43890 printf(" %d", n_writer); 43891 printf(" %d", n_quotechar); 43892 printf("\n"); 43893 } 43894 } 43895 } 43896 function_tests++; 43897 #endif 43898 43899 return(test_ret); 43900 } 43901 43902 43903 static int 43904 test_xmlTextWriterStartAttribute(void) { 43905 int test_ret = 0; 43906 43907 #if defined(LIBXML_WRITER_ENABLED) 43908 int mem_base; 43909 int ret_val; 43910 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 43911 int n_writer; 43912 xmlChar * name; /* element name */ 43913 int n_name; 43914 43915 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 43916 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 43917 mem_base = xmlMemBlocks(); 43918 writer = gen_xmlTextWriterPtr(n_writer, 0); 43919 name = gen_const_xmlChar_ptr(n_name, 1); 43920 43921 ret_val = xmlTextWriterStartAttribute(writer, (const xmlChar *)name); 43922 desret_int(ret_val); 43923 call_tests++; 43924 des_xmlTextWriterPtr(n_writer, writer, 0); 43925 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 43926 xmlResetLastError(); 43927 if (mem_base != xmlMemBlocks()) { 43928 printf("Leak of %d blocks found in xmlTextWriterStartAttribute", 43929 xmlMemBlocks() - mem_base); 43930 test_ret++; 43931 printf(" %d", n_writer); 43932 printf(" %d", n_name); 43933 printf("\n"); 43934 } 43935 } 43936 } 43937 function_tests++; 43938 #endif 43939 43940 return(test_ret); 43941 } 43942 43943 43944 static int 43945 test_xmlTextWriterStartAttributeNS(void) { 43946 int test_ret = 0; 43947 43948 #if defined(LIBXML_WRITER_ENABLED) 43949 int mem_base; 43950 int ret_val; 43951 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 43952 int n_writer; 43953 xmlChar * prefix; /* namespace prefix or NULL */ 43954 int n_prefix; 43955 xmlChar * name; /* element local name */ 43956 int n_name; 43957 xmlChar * namespaceURI; /* namespace URI or NULL */ 43958 int n_namespaceURI; 43959 43960 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 43961 for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) { 43962 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 43963 for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) { 43964 mem_base = xmlMemBlocks(); 43965 writer = gen_xmlTextWriterPtr(n_writer, 0); 43966 prefix = gen_const_xmlChar_ptr(n_prefix, 1); 43967 name = gen_const_xmlChar_ptr(n_name, 2); 43968 namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3); 43969 43970 ret_val = xmlTextWriterStartAttributeNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI); 43971 desret_int(ret_val); 43972 call_tests++; 43973 des_xmlTextWriterPtr(n_writer, writer, 0); 43974 des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1); 43975 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 43976 des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3); 43977 xmlResetLastError(); 43978 if (mem_base != xmlMemBlocks()) { 43979 printf("Leak of %d blocks found in xmlTextWriterStartAttributeNS", 43980 xmlMemBlocks() - mem_base); 43981 test_ret++; 43982 printf(" %d", n_writer); 43983 printf(" %d", n_prefix); 43984 printf(" %d", n_name); 43985 printf(" %d", n_namespaceURI); 43986 printf("\n"); 43987 } 43988 } 43989 } 43990 } 43991 } 43992 function_tests++; 43993 #endif 43994 43995 return(test_ret); 43996 } 43997 43998 43999 static int 44000 test_xmlTextWriterStartCDATA(void) { 44001 int test_ret = 0; 44002 44003 #if defined(LIBXML_WRITER_ENABLED) 44004 int mem_base; 44005 int ret_val; 44006 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44007 int n_writer; 44008 44009 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 44010 mem_base = xmlMemBlocks(); 44011 writer = gen_xmlTextWriterPtr(n_writer, 0); 44012 44013 ret_val = xmlTextWriterStartCDATA(writer); 44014 desret_int(ret_val); 44015 call_tests++; 44016 des_xmlTextWriterPtr(n_writer, writer, 0); 44017 xmlResetLastError(); 44018 if (mem_base != xmlMemBlocks()) { 44019 printf("Leak of %d blocks found in xmlTextWriterStartCDATA", 44020 xmlMemBlocks() - mem_base); 44021 test_ret++; 44022 printf(" %d", n_writer); 44023 printf("\n"); 44024 } 44025 } 44026 function_tests++; 44027 #endif 44028 44029 return(test_ret); 44030 } 44031 44032 44033 static int 44034 test_xmlTextWriterStartComment(void) { 44035 int test_ret = 0; 44036 44037 #if defined(LIBXML_WRITER_ENABLED) 44038 int mem_base; 44039 int ret_val; 44040 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44041 int n_writer; 44042 44043 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 44044 mem_base = xmlMemBlocks(); 44045 writer = gen_xmlTextWriterPtr(n_writer, 0); 44046 44047 ret_val = xmlTextWriterStartComment(writer); 44048 desret_int(ret_val); 44049 call_tests++; 44050 des_xmlTextWriterPtr(n_writer, writer, 0); 44051 xmlResetLastError(); 44052 if (mem_base != xmlMemBlocks()) { 44053 printf("Leak of %d blocks found in xmlTextWriterStartComment", 44054 xmlMemBlocks() - mem_base); 44055 test_ret++; 44056 printf(" %d", n_writer); 44057 printf("\n"); 44058 } 44059 } 44060 function_tests++; 44061 #endif 44062 44063 return(test_ret); 44064 } 44065 44066 44067 static int 44068 test_xmlTextWriterStartDTD(void) { 44069 int test_ret = 0; 44070 44071 #if defined(LIBXML_WRITER_ENABLED) 44072 int mem_base; 44073 int ret_val; 44074 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44075 int n_writer; 44076 xmlChar * name; /* the name of the DTD */ 44077 int n_name; 44078 xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */ 44079 int n_pubid; 44080 xmlChar * sysid; /* the system identifier, which is the URI of the DTD */ 44081 int n_sysid; 44082 44083 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 44084 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 44085 for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) { 44086 for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) { 44087 mem_base = xmlMemBlocks(); 44088 writer = gen_xmlTextWriterPtr(n_writer, 0); 44089 name = gen_const_xmlChar_ptr(n_name, 1); 44090 pubid = gen_const_xmlChar_ptr(n_pubid, 2); 44091 sysid = gen_const_xmlChar_ptr(n_sysid, 3); 44092 44093 ret_val = xmlTextWriterStartDTD(writer, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid); 44094 desret_int(ret_val); 44095 call_tests++; 44096 des_xmlTextWriterPtr(n_writer, writer, 0); 44097 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 44098 des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 2); 44099 des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 3); 44100 xmlResetLastError(); 44101 if (mem_base != xmlMemBlocks()) { 44102 printf("Leak of %d blocks found in xmlTextWriterStartDTD", 44103 xmlMemBlocks() - mem_base); 44104 test_ret++; 44105 printf(" %d", n_writer); 44106 printf(" %d", n_name); 44107 printf(" %d", n_pubid); 44108 printf(" %d", n_sysid); 44109 printf("\n"); 44110 } 44111 } 44112 } 44113 } 44114 } 44115 function_tests++; 44116 #endif 44117 44118 return(test_ret); 44119 } 44120 44121 44122 static int 44123 test_xmlTextWriterStartDTDAttlist(void) { 44124 int test_ret = 0; 44125 44126 #if defined(LIBXML_WRITER_ENABLED) 44127 int mem_base; 44128 int ret_val; 44129 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44130 int n_writer; 44131 xmlChar * name; /* the name of the DTD ATTLIST */ 44132 int n_name; 44133 44134 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 44135 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 44136 mem_base = xmlMemBlocks(); 44137 writer = gen_xmlTextWriterPtr(n_writer, 0); 44138 name = gen_const_xmlChar_ptr(n_name, 1); 44139 44140 ret_val = xmlTextWriterStartDTDAttlist(writer, (const xmlChar *)name); 44141 desret_int(ret_val); 44142 call_tests++; 44143 des_xmlTextWriterPtr(n_writer, writer, 0); 44144 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 44145 xmlResetLastError(); 44146 if (mem_base != xmlMemBlocks()) { 44147 printf("Leak of %d blocks found in xmlTextWriterStartDTDAttlist", 44148 xmlMemBlocks() - mem_base); 44149 test_ret++; 44150 printf(" %d", n_writer); 44151 printf(" %d", n_name); 44152 printf("\n"); 44153 } 44154 } 44155 } 44156 function_tests++; 44157 #endif 44158 44159 return(test_ret); 44160 } 44161 44162 44163 static int 44164 test_xmlTextWriterStartDTDElement(void) { 44165 int test_ret = 0; 44166 44167 #if defined(LIBXML_WRITER_ENABLED) 44168 int mem_base; 44169 int ret_val; 44170 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44171 int n_writer; 44172 xmlChar * name; /* the name of the DTD element */ 44173 int n_name; 44174 44175 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 44176 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 44177 mem_base = xmlMemBlocks(); 44178 writer = gen_xmlTextWriterPtr(n_writer, 0); 44179 name = gen_const_xmlChar_ptr(n_name, 1); 44180 44181 ret_val = xmlTextWriterStartDTDElement(writer, (const xmlChar *)name); 44182 desret_int(ret_val); 44183 call_tests++; 44184 des_xmlTextWriterPtr(n_writer, writer, 0); 44185 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 44186 xmlResetLastError(); 44187 if (mem_base != xmlMemBlocks()) { 44188 printf("Leak of %d blocks found in xmlTextWriterStartDTDElement", 44189 xmlMemBlocks() - mem_base); 44190 test_ret++; 44191 printf(" %d", n_writer); 44192 printf(" %d", n_name); 44193 printf("\n"); 44194 } 44195 } 44196 } 44197 function_tests++; 44198 #endif 44199 44200 return(test_ret); 44201 } 44202 44203 44204 static int 44205 test_xmlTextWriterStartDTDEntity(void) { 44206 int test_ret = 0; 44207 44208 #if defined(LIBXML_WRITER_ENABLED) 44209 int mem_base; 44210 int ret_val; 44211 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44212 int n_writer; 44213 int pe; /* TRUE if this is a parameter entity, FALSE if not */ 44214 int n_pe; 44215 xmlChar * name; /* the name of the DTD ATTLIST */ 44216 int n_name; 44217 44218 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 44219 for (n_pe = 0;n_pe < gen_nb_int;n_pe++) { 44220 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 44221 mem_base = xmlMemBlocks(); 44222 writer = gen_xmlTextWriterPtr(n_writer, 0); 44223 pe = gen_int(n_pe, 1); 44224 name = gen_const_xmlChar_ptr(n_name, 2); 44225 44226 ret_val = xmlTextWriterStartDTDEntity(writer, pe, (const xmlChar *)name); 44227 desret_int(ret_val); 44228 call_tests++; 44229 des_xmlTextWriterPtr(n_writer, writer, 0); 44230 des_int(n_pe, pe, 1); 44231 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 44232 xmlResetLastError(); 44233 if (mem_base != xmlMemBlocks()) { 44234 printf("Leak of %d blocks found in xmlTextWriterStartDTDEntity", 44235 xmlMemBlocks() - mem_base); 44236 test_ret++; 44237 printf(" %d", n_writer); 44238 printf(" %d", n_pe); 44239 printf(" %d", n_name); 44240 printf("\n"); 44241 } 44242 } 44243 } 44244 } 44245 function_tests++; 44246 #endif 44247 44248 return(test_ret); 44249 } 44250 44251 44252 static int 44253 test_xmlTextWriterStartDocument(void) { 44254 int test_ret = 0; 44255 44256 #if defined(LIBXML_WRITER_ENABLED) 44257 int mem_base; 44258 int ret_val; 44259 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44260 int n_writer; 44261 char * version; /* the xml version ("1.0") or NULL for default ("1.0") */ 44262 int n_version; 44263 char * encoding; /* the encoding or NULL for default */ 44264 int n_encoding; 44265 char * standalone; /* "yes" or "no" or NULL for default */ 44266 int n_standalone; 44267 44268 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 44269 for (n_version = 0;n_version < gen_nb_const_char_ptr;n_version++) { 44270 for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) { 44271 for (n_standalone = 0;n_standalone < gen_nb_const_char_ptr;n_standalone++) { 44272 mem_base = xmlMemBlocks(); 44273 writer = gen_xmlTextWriterPtr(n_writer, 0); 44274 version = gen_const_char_ptr(n_version, 1); 44275 encoding = gen_const_char_ptr(n_encoding, 2); 44276 standalone = gen_const_char_ptr(n_standalone, 3); 44277 44278 ret_val = xmlTextWriterStartDocument(writer, (const char *)version, (const char *)encoding, (const char *)standalone); 44279 desret_int(ret_val); 44280 call_tests++; 44281 des_xmlTextWriterPtr(n_writer, writer, 0); 44282 des_const_char_ptr(n_version, (const char *)version, 1); 44283 des_const_char_ptr(n_encoding, (const char *)encoding, 2); 44284 des_const_char_ptr(n_standalone, (const char *)standalone, 3); 44285 xmlResetLastError(); 44286 if (mem_base != xmlMemBlocks()) { 44287 printf("Leak of %d blocks found in xmlTextWriterStartDocument", 44288 xmlMemBlocks() - mem_base); 44289 test_ret++; 44290 printf(" %d", n_writer); 44291 printf(" %d", n_version); 44292 printf(" %d", n_encoding); 44293 printf(" %d", n_standalone); 44294 printf("\n"); 44295 } 44296 } 44297 } 44298 } 44299 } 44300 function_tests++; 44301 #endif 44302 44303 return(test_ret); 44304 } 44305 44306 44307 static int 44308 test_xmlTextWriterStartElement(void) { 44309 int test_ret = 0; 44310 44311 #if defined(LIBXML_WRITER_ENABLED) 44312 int mem_base; 44313 int ret_val; 44314 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44315 int n_writer; 44316 xmlChar * name; /* element name */ 44317 int n_name; 44318 44319 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 44320 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 44321 mem_base = xmlMemBlocks(); 44322 writer = gen_xmlTextWriterPtr(n_writer, 0); 44323 name = gen_const_xmlChar_ptr(n_name, 1); 44324 44325 ret_val = xmlTextWriterStartElement(writer, (const xmlChar *)name); 44326 desret_int(ret_val); 44327 call_tests++; 44328 des_xmlTextWriterPtr(n_writer, writer, 0); 44329 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 44330 xmlResetLastError(); 44331 if (mem_base != xmlMemBlocks()) { 44332 printf("Leak of %d blocks found in xmlTextWriterStartElement", 44333 xmlMemBlocks() - mem_base); 44334 test_ret++; 44335 printf(" %d", n_writer); 44336 printf(" %d", n_name); 44337 printf("\n"); 44338 } 44339 } 44340 } 44341 function_tests++; 44342 #endif 44343 44344 return(test_ret); 44345 } 44346 44347 44348 static int 44349 test_xmlTextWriterStartElementNS(void) { 44350 int test_ret = 0; 44351 44352 #if defined(LIBXML_WRITER_ENABLED) 44353 int mem_base; 44354 int ret_val; 44355 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44356 int n_writer; 44357 xmlChar * prefix; /* namespace prefix or NULL */ 44358 int n_prefix; 44359 xmlChar * name; /* element local name */ 44360 int n_name; 44361 xmlChar * namespaceURI; /* namespace URI or NULL */ 44362 int n_namespaceURI; 44363 44364 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 44365 for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) { 44366 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 44367 for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) { 44368 mem_base = xmlMemBlocks(); 44369 writer = gen_xmlTextWriterPtr(n_writer, 0); 44370 prefix = gen_const_xmlChar_ptr(n_prefix, 1); 44371 name = gen_const_xmlChar_ptr(n_name, 2); 44372 namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3); 44373 44374 ret_val = xmlTextWriterStartElementNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI); 44375 desret_int(ret_val); 44376 call_tests++; 44377 des_xmlTextWriterPtr(n_writer, writer, 0); 44378 des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1); 44379 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 44380 des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3); 44381 xmlResetLastError(); 44382 if (mem_base != xmlMemBlocks()) { 44383 printf("Leak of %d blocks found in xmlTextWriterStartElementNS", 44384 xmlMemBlocks() - mem_base); 44385 test_ret++; 44386 printf(" %d", n_writer); 44387 printf(" %d", n_prefix); 44388 printf(" %d", n_name); 44389 printf(" %d", n_namespaceURI); 44390 printf("\n"); 44391 } 44392 } 44393 } 44394 } 44395 } 44396 function_tests++; 44397 #endif 44398 44399 return(test_ret); 44400 } 44401 44402 44403 static int 44404 test_xmlTextWriterStartPI(void) { 44405 int test_ret = 0; 44406 44407 #if defined(LIBXML_WRITER_ENABLED) 44408 int mem_base; 44409 int ret_val; 44410 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44411 int n_writer; 44412 xmlChar * target; /* PI target */ 44413 int n_target; 44414 44415 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 44416 for (n_target = 0;n_target < gen_nb_const_xmlChar_ptr;n_target++) { 44417 mem_base = xmlMemBlocks(); 44418 writer = gen_xmlTextWriterPtr(n_writer, 0); 44419 target = gen_const_xmlChar_ptr(n_target, 1); 44420 44421 ret_val = xmlTextWriterStartPI(writer, (const xmlChar *)target); 44422 desret_int(ret_val); 44423 call_tests++; 44424 des_xmlTextWriterPtr(n_writer, writer, 0); 44425 des_const_xmlChar_ptr(n_target, (const xmlChar *)target, 1); 44426 xmlResetLastError(); 44427 if (mem_base != xmlMemBlocks()) { 44428 printf("Leak of %d blocks found in xmlTextWriterStartPI", 44429 xmlMemBlocks() - mem_base); 44430 test_ret++; 44431 printf(" %d", n_writer); 44432 printf(" %d", n_target); 44433 printf("\n"); 44434 } 44435 } 44436 } 44437 function_tests++; 44438 #endif 44439 44440 return(test_ret); 44441 } 44442 44443 44444 static int 44445 test_xmlTextWriterWriteAttribute(void) { 44446 int test_ret = 0; 44447 44448 #if defined(LIBXML_WRITER_ENABLED) 44449 int mem_base; 44450 int ret_val; 44451 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44452 int n_writer; 44453 xmlChar * name; /* attribute name */ 44454 int n_name; 44455 xmlChar * content; /* attribute content */ 44456 int n_content; 44457 44458 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 44459 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 44460 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 44461 mem_base = xmlMemBlocks(); 44462 writer = gen_xmlTextWriterPtr(n_writer, 0); 44463 name = gen_const_xmlChar_ptr(n_name, 1); 44464 content = gen_const_xmlChar_ptr(n_content, 2); 44465 44466 ret_val = xmlTextWriterWriteAttribute(writer, (const xmlChar *)name, (const xmlChar *)content); 44467 desret_int(ret_val); 44468 call_tests++; 44469 des_xmlTextWriterPtr(n_writer, writer, 0); 44470 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 44471 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2); 44472 xmlResetLastError(); 44473 if (mem_base != xmlMemBlocks()) { 44474 printf("Leak of %d blocks found in xmlTextWriterWriteAttribute", 44475 xmlMemBlocks() - mem_base); 44476 test_ret++; 44477 printf(" %d", n_writer); 44478 printf(" %d", n_name); 44479 printf(" %d", n_content); 44480 printf("\n"); 44481 } 44482 } 44483 } 44484 } 44485 function_tests++; 44486 #endif 44487 44488 return(test_ret); 44489 } 44490 44491 44492 static int 44493 test_xmlTextWriterWriteAttributeNS(void) { 44494 int test_ret = 0; 44495 44496 #if defined(LIBXML_WRITER_ENABLED) 44497 int mem_base; 44498 int ret_val; 44499 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44500 int n_writer; 44501 xmlChar * prefix; /* namespace prefix */ 44502 int n_prefix; 44503 xmlChar * name; /* attribute local name */ 44504 int n_name; 44505 xmlChar * namespaceURI; /* namespace URI */ 44506 int n_namespaceURI; 44507 xmlChar * content; /* attribute content */ 44508 int n_content; 44509 44510 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 44511 for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) { 44512 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 44513 for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) { 44514 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 44515 mem_base = xmlMemBlocks(); 44516 writer = gen_xmlTextWriterPtr(n_writer, 0); 44517 prefix = gen_const_xmlChar_ptr(n_prefix, 1); 44518 name = gen_const_xmlChar_ptr(n_name, 2); 44519 namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3); 44520 content = gen_const_xmlChar_ptr(n_content, 4); 44521 44522 ret_val = xmlTextWriterWriteAttributeNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI, (const xmlChar *)content); 44523 desret_int(ret_val); 44524 call_tests++; 44525 des_xmlTextWriterPtr(n_writer, writer, 0); 44526 des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1); 44527 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 44528 des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3); 44529 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 4); 44530 xmlResetLastError(); 44531 if (mem_base != xmlMemBlocks()) { 44532 printf("Leak of %d blocks found in xmlTextWriterWriteAttributeNS", 44533 xmlMemBlocks() - mem_base); 44534 test_ret++; 44535 printf(" %d", n_writer); 44536 printf(" %d", n_prefix); 44537 printf(" %d", n_name); 44538 printf(" %d", n_namespaceURI); 44539 printf(" %d", n_content); 44540 printf("\n"); 44541 } 44542 } 44543 } 44544 } 44545 } 44546 } 44547 function_tests++; 44548 #endif 44549 44550 return(test_ret); 44551 } 44552 44553 44554 static int 44555 test_xmlTextWriterWriteBase64(void) { 44556 int test_ret = 0; 44557 44558 #if defined(LIBXML_WRITER_ENABLED) 44559 int mem_base; 44560 int ret_val; 44561 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44562 int n_writer; 44563 char * data; /* binary data */ 44564 int n_data; 44565 int start; /* the position within the data of the first byte to encode */ 44566 int n_start; 44567 int len; /* the number of bytes to encode */ 44568 int n_len; 44569 44570 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 44571 for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) { 44572 for (n_start = 0;n_start < gen_nb_int;n_start++) { 44573 for (n_len = 0;n_len < gen_nb_int;n_len++) { 44574 mem_base = xmlMemBlocks(); 44575 writer = gen_xmlTextWriterPtr(n_writer, 0); 44576 data = gen_const_char_ptr(n_data, 1); 44577 start = gen_int(n_start, 2); 44578 len = gen_int(n_len, 3); 44579 44580 ret_val = xmlTextWriterWriteBase64(writer, (const char *)data, start, len); 44581 desret_int(ret_val); 44582 call_tests++; 44583 des_xmlTextWriterPtr(n_writer, writer, 0); 44584 des_const_char_ptr(n_data, (const char *)data, 1); 44585 des_int(n_start, start, 2); 44586 des_int(n_len, len, 3); 44587 xmlResetLastError(); 44588 if (mem_base != xmlMemBlocks()) { 44589 printf("Leak of %d blocks found in xmlTextWriterWriteBase64", 44590 xmlMemBlocks() - mem_base); 44591 test_ret++; 44592 printf(" %d", n_writer); 44593 printf(" %d", n_data); 44594 printf(" %d", n_start); 44595 printf(" %d", n_len); 44596 printf("\n"); 44597 } 44598 } 44599 } 44600 } 44601 } 44602 function_tests++; 44603 #endif 44604 44605 return(test_ret); 44606 } 44607 44608 44609 static int 44610 test_xmlTextWriterWriteBinHex(void) { 44611 int test_ret = 0; 44612 44613 #if defined(LIBXML_WRITER_ENABLED) 44614 int mem_base; 44615 int ret_val; 44616 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44617 int n_writer; 44618 char * data; /* binary data */ 44619 int n_data; 44620 int start; /* the position within the data of the first byte to encode */ 44621 int n_start; 44622 int len; /* the number of bytes to encode */ 44623 int n_len; 44624 44625 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 44626 for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) { 44627 for (n_start = 0;n_start < gen_nb_int;n_start++) { 44628 for (n_len = 0;n_len < gen_nb_int;n_len++) { 44629 mem_base = xmlMemBlocks(); 44630 writer = gen_xmlTextWriterPtr(n_writer, 0); 44631 data = gen_const_char_ptr(n_data, 1); 44632 start = gen_int(n_start, 2); 44633 len = gen_int(n_len, 3); 44634 44635 ret_val = xmlTextWriterWriteBinHex(writer, (const char *)data, start, len); 44636 desret_int(ret_val); 44637 call_tests++; 44638 des_xmlTextWriterPtr(n_writer, writer, 0); 44639 des_const_char_ptr(n_data, (const char *)data, 1); 44640 des_int(n_start, start, 2); 44641 des_int(n_len, len, 3); 44642 xmlResetLastError(); 44643 if (mem_base != xmlMemBlocks()) { 44644 printf("Leak of %d blocks found in xmlTextWriterWriteBinHex", 44645 xmlMemBlocks() - mem_base); 44646 test_ret++; 44647 printf(" %d", n_writer); 44648 printf(" %d", n_data); 44649 printf(" %d", n_start); 44650 printf(" %d", n_len); 44651 printf("\n"); 44652 } 44653 } 44654 } 44655 } 44656 } 44657 function_tests++; 44658 #endif 44659 44660 return(test_ret); 44661 } 44662 44663 44664 static int 44665 test_xmlTextWriterWriteCDATA(void) { 44666 int test_ret = 0; 44667 44668 #if defined(LIBXML_WRITER_ENABLED) 44669 int mem_base; 44670 int ret_val; 44671 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44672 int n_writer; 44673 xmlChar * content; /* CDATA content */ 44674 int n_content; 44675 44676 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 44677 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 44678 mem_base = xmlMemBlocks(); 44679 writer = gen_xmlTextWriterPtr(n_writer, 0); 44680 content = gen_const_xmlChar_ptr(n_content, 1); 44681 44682 ret_val = xmlTextWriterWriteCDATA(writer, (const xmlChar *)content); 44683 desret_int(ret_val); 44684 call_tests++; 44685 des_xmlTextWriterPtr(n_writer, writer, 0); 44686 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1); 44687 xmlResetLastError(); 44688 if (mem_base != xmlMemBlocks()) { 44689 printf("Leak of %d blocks found in xmlTextWriterWriteCDATA", 44690 xmlMemBlocks() - mem_base); 44691 test_ret++; 44692 printf(" %d", n_writer); 44693 printf(" %d", n_content); 44694 printf("\n"); 44695 } 44696 } 44697 } 44698 function_tests++; 44699 #endif 44700 44701 return(test_ret); 44702 } 44703 44704 44705 static int 44706 test_xmlTextWriterWriteComment(void) { 44707 int test_ret = 0; 44708 44709 #if defined(LIBXML_WRITER_ENABLED) 44710 int mem_base; 44711 int ret_val; 44712 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44713 int n_writer; 44714 xmlChar * content; /* comment string */ 44715 int n_content; 44716 44717 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 44718 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 44719 mem_base = xmlMemBlocks(); 44720 writer = gen_xmlTextWriterPtr(n_writer, 0); 44721 content = gen_const_xmlChar_ptr(n_content, 1); 44722 44723 ret_val = xmlTextWriterWriteComment(writer, (const xmlChar *)content); 44724 desret_int(ret_val); 44725 call_tests++; 44726 des_xmlTextWriterPtr(n_writer, writer, 0); 44727 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1); 44728 xmlResetLastError(); 44729 if (mem_base != xmlMemBlocks()) { 44730 printf("Leak of %d blocks found in xmlTextWriterWriteComment", 44731 xmlMemBlocks() - mem_base); 44732 test_ret++; 44733 printf(" %d", n_writer); 44734 printf(" %d", n_content); 44735 printf("\n"); 44736 } 44737 } 44738 } 44739 function_tests++; 44740 #endif 44741 44742 return(test_ret); 44743 } 44744 44745 44746 static int 44747 test_xmlTextWriterWriteDTD(void) { 44748 int test_ret = 0; 44749 44750 #if defined(LIBXML_WRITER_ENABLED) 44751 int mem_base; 44752 int ret_val; 44753 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44754 int n_writer; 44755 xmlChar * name; /* the name of the DTD */ 44756 int n_name; 44757 xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */ 44758 int n_pubid; 44759 xmlChar * sysid; /* the system identifier, which is the URI of the DTD */ 44760 int n_sysid; 44761 xmlChar * subset; /* string content of the DTD */ 44762 int n_subset; 44763 44764 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 44765 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 44766 for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) { 44767 for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) { 44768 for (n_subset = 0;n_subset < gen_nb_const_xmlChar_ptr;n_subset++) { 44769 mem_base = xmlMemBlocks(); 44770 writer = gen_xmlTextWriterPtr(n_writer, 0); 44771 name = gen_const_xmlChar_ptr(n_name, 1); 44772 pubid = gen_const_xmlChar_ptr(n_pubid, 2); 44773 sysid = gen_const_xmlChar_ptr(n_sysid, 3); 44774 subset = gen_const_xmlChar_ptr(n_subset, 4); 44775 44776 ret_val = xmlTextWriterWriteDTD(writer, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)subset); 44777 desret_int(ret_val); 44778 call_tests++; 44779 des_xmlTextWriterPtr(n_writer, writer, 0); 44780 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 44781 des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 2); 44782 des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 3); 44783 des_const_xmlChar_ptr(n_subset, (const xmlChar *)subset, 4); 44784 xmlResetLastError(); 44785 if (mem_base != xmlMemBlocks()) { 44786 printf("Leak of %d blocks found in xmlTextWriterWriteDTD", 44787 xmlMemBlocks() - mem_base); 44788 test_ret++; 44789 printf(" %d", n_writer); 44790 printf(" %d", n_name); 44791 printf(" %d", n_pubid); 44792 printf(" %d", n_sysid); 44793 printf(" %d", n_subset); 44794 printf("\n"); 44795 } 44796 } 44797 } 44798 } 44799 } 44800 } 44801 function_tests++; 44802 #endif 44803 44804 return(test_ret); 44805 } 44806 44807 44808 static int 44809 test_xmlTextWriterWriteDTDAttlist(void) { 44810 int test_ret = 0; 44811 44812 #if defined(LIBXML_WRITER_ENABLED) 44813 int mem_base; 44814 int ret_val; 44815 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44816 int n_writer; 44817 xmlChar * name; /* the name of the DTD ATTLIST */ 44818 int n_name; 44819 xmlChar * content; /* content of the ATTLIST */ 44820 int n_content; 44821 44822 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 44823 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 44824 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 44825 mem_base = xmlMemBlocks(); 44826 writer = gen_xmlTextWriterPtr(n_writer, 0); 44827 name = gen_const_xmlChar_ptr(n_name, 1); 44828 content = gen_const_xmlChar_ptr(n_content, 2); 44829 44830 ret_val = xmlTextWriterWriteDTDAttlist(writer, (const xmlChar *)name, (const xmlChar *)content); 44831 desret_int(ret_val); 44832 call_tests++; 44833 des_xmlTextWriterPtr(n_writer, writer, 0); 44834 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 44835 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2); 44836 xmlResetLastError(); 44837 if (mem_base != xmlMemBlocks()) { 44838 printf("Leak of %d blocks found in xmlTextWriterWriteDTDAttlist", 44839 xmlMemBlocks() - mem_base); 44840 test_ret++; 44841 printf(" %d", n_writer); 44842 printf(" %d", n_name); 44843 printf(" %d", n_content); 44844 printf("\n"); 44845 } 44846 } 44847 } 44848 } 44849 function_tests++; 44850 #endif 44851 44852 return(test_ret); 44853 } 44854 44855 44856 static int 44857 test_xmlTextWriterWriteDTDElement(void) { 44858 int test_ret = 0; 44859 44860 #if defined(LIBXML_WRITER_ENABLED) 44861 int mem_base; 44862 int ret_val; 44863 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44864 int n_writer; 44865 xmlChar * name; /* the name of the DTD element */ 44866 int n_name; 44867 xmlChar * content; /* content of the element */ 44868 int n_content; 44869 44870 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 44871 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 44872 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 44873 mem_base = xmlMemBlocks(); 44874 writer = gen_xmlTextWriterPtr(n_writer, 0); 44875 name = gen_const_xmlChar_ptr(n_name, 1); 44876 content = gen_const_xmlChar_ptr(n_content, 2); 44877 44878 ret_val = xmlTextWriterWriteDTDElement(writer, (const xmlChar *)name, (const xmlChar *)content); 44879 desret_int(ret_val); 44880 call_tests++; 44881 des_xmlTextWriterPtr(n_writer, writer, 0); 44882 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 44883 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2); 44884 xmlResetLastError(); 44885 if (mem_base != xmlMemBlocks()) { 44886 printf("Leak of %d blocks found in xmlTextWriterWriteDTDElement", 44887 xmlMemBlocks() - mem_base); 44888 test_ret++; 44889 printf(" %d", n_writer); 44890 printf(" %d", n_name); 44891 printf(" %d", n_content); 44892 printf("\n"); 44893 } 44894 } 44895 } 44896 } 44897 function_tests++; 44898 #endif 44899 44900 return(test_ret); 44901 } 44902 44903 44904 static int 44905 test_xmlTextWriterWriteDTDEntity(void) { 44906 int test_ret = 0; 44907 44908 #if defined(LIBXML_WRITER_ENABLED) 44909 int mem_base; 44910 int ret_val; 44911 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44912 int n_writer; 44913 int pe; /* TRUE if this is a parameter entity, FALSE if not */ 44914 int n_pe; 44915 xmlChar * name; /* the name of the DTD entity */ 44916 int n_name; 44917 xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */ 44918 int n_pubid; 44919 xmlChar * sysid; /* the system identifier, which is the URI of the DTD */ 44920 int n_sysid; 44921 xmlChar * ndataid; /* the xml notation name. */ 44922 int n_ndataid; 44923 xmlChar * content; /* content of the entity */ 44924 int n_content; 44925 44926 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 44927 for (n_pe = 0;n_pe < gen_nb_int;n_pe++) { 44928 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 44929 for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) { 44930 for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) { 44931 for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) { 44932 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 44933 mem_base = xmlMemBlocks(); 44934 writer = gen_xmlTextWriterPtr(n_writer, 0); 44935 pe = gen_int(n_pe, 1); 44936 name = gen_const_xmlChar_ptr(n_name, 2); 44937 pubid = gen_const_xmlChar_ptr(n_pubid, 3); 44938 sysid = gen_const_xmlChar_ptr(n_sysid, 4); 44939 ndataid = gen_const_xmlChar_ptr(n_ndataid, 5); 44940 content = gen_const_xmlChar_ptr(n_content, 6); 44941 44942 ret_val = xmlTextWriterWriteDTDEntity(writer, pe, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)ndataid, (const xmlChar *)content); 44943 desret_int(ret_val); 44944 call_tests++; 44945 des_xmlTextWriterPtr(n_writer, writer, 0); 44946 des_int(n_pe, pe, 1); 44947 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 44948 des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 3); 44949 des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 4); 44950 des_const_xmlChar_ptr(n_ndataid, (const xmlChar *)ndataid, 5); 44951 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 6); 44952 xmlResetLastError(); 44953 if (mem_base != xmlMemBlocks()) { 44954 printf("Leak of %d blocks found in xmlTextWriterWriteDTDEntity", 44955 xmlMemBlocks() - mem_base); 44956 test_ret++; 44957 printf(" %d", n_writer); 44958 printf(" %d", n_pe); 44959 printf(" %d", n_name); 44960 printf(" %d", n_pubid); 44961 printf(" %d", n_sysid); 44962 printf(" %d", n_ndataid); 44963 printf(" %d", n_content); 44964 printf("\n"); 44965 } 44966 } 44967 } 44968 } 44969 } 44970 } 44971 } 44972 } 44973 function_tests++; 44974 #endif 44975 44976 return(test_ret); 44977 } 44978 44979 44980 static int 44981 test_xmlTextWriterWriteDTDExternalEntity(void) { 44982 int test_ret = 0; 44983 44984 #if defined(LIBXML_WRITER_ENABLED) 44985 int mem_base; 44986 int ret_val; 44987 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 44988 int n_writer; 44989 int pe; /* TRUE if this is a parameter entity, FALSE if not */ 44990 int n_pe; 44991 xmlChar * name; /* the name of the DTD entity */ 44992 int n_name; 44993 xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */ 44994 int n_pubid; 44995 xmlChar * sysid; /* the system identifier, which is the URI of the DTD */ 44996 int n_sysid; 44997 xmlChar * ndataid; /* the xml notation name. */ 44998 int n_ndataid; 44999 45000 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 45001 for (n_pe = 0;n_pe < gen_nb_int;n_pe++) { 45002 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 45003 for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) { 45004 for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) { 45005 for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) { 45006 mem_base = xmlMemBlocks(); 45007 writer = gen_xmlTextWriterPtr(n_writer, 0); 45008 pe = gen_int(n_pe, 1); 45009 name = gen_const_xmlChar_ptr(n_name, 2); 45010 pubid = gen_const_xmlChar_ptr(n_pubid, 3); 45011 sysid = gen_const_xmlChar_ptr(n_sysid, 4); 45012 ndataid = gen_const_xmlChar_ptr(n_ndataid, 5); 45013 45014 ret_val = xmlTextWriterWriteDTDExternalEntity(writer, pe, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)ndataid); 45015 desret_int(ret_val); 45016 call_tests++; 45017 des_xmlTextWriterPtr(n_writer, writer, 0); 45018 des_int(n_pe, pe, 1); 45019 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 45020 des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 3); 45021 des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 4); 45022 des_const_xmlChar_ptr(n_ndataid, (const xmlChar *)ndataid, 5); 45023 xmlResetLastError(); 45024 if (mem_base != xmlMemBlocks()) { 45025 printf("Leak of %d blocks found in xmlTextWriterWriteDTDExternalEntity", 45026 xmlMemBlocks() - mem_base); 45027 test_ret++; 45028 printf(" %d", n_writer); 45029 printf(" %d", n_pe); 45030 printf(" %d", n_name); 45031 printf(" %d", n_pubid); 45032 printf(" %d", n_sysid); 45033 printf(" %d", n_ndataid); 45034 printf("\n"); 45035 } 45036 } 45037 } 45038 } 45039 } 45040 } 45041 } 45042 function_tests++; 45043 #endif 45044 45045 return(test_ret); 45046 } 45047 45048 45049 static int 45050 test_xmlTextWriterWriteDTDExternalEntityContents(void) { 45051 int test_ret = 0; 45052 45053 #if defined(LIBXML_WRITER_ENABLED) 45054 int mem_base; 45055 int ret_val; 45056 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 45057 int n_writer; 45058 xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */ 45059 int n_pubid; 45060 xmlChar * sysid; /* the system identifier, which is the URI of the DTD */ 45061 int n_sysid; 45062 xmlChar * ndataid; /* the xml notation name. */ 45063 int n_ndataid; 45064 45065 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 45066 for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) { 45067 for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) { 45068 for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) { 45069 mem_base = xmlMemBlocks(); 45070 writer = gen_xmlTextWriterPtr(n_writer, 0); 45071 pubid = gen_const_xmlChar_ptr(n_pubid, 1); 45072 sysid = gen_const_xmlChar_ptr(n_sysid, 2); 45073 ndataid = gen_const_xmlChar_ptr(n_ndataid, 3); 45074 45075 ret_val = xmlTextWriterWriteDTDExternalEntityContents(writer, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)ndataid); 45076 desret_int(ret_val); 45077 call_tests++; 45078 des_xmlTextWriterPtr(n_writer, writer, 0); 45079 des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 1); 45080 des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 2); 45081 des_const_xmlChar_ptr(n_ndataid, (const xmlChar *)ndataid, 3); 45082 xmlResetLastError(); 45083 if (mem_base != xmlMemBlocks()) { 45084 printf("Leak of %d blocks found in xmlTextWriterWriteDTDExternalEntityContents", 45085 xmlMemBlocks() - mem_base); 45086 test_ret++; 45087 printf(" %d", n_writer); 45088 printf(" %d", n_pubid); 45089 printf(" %d", n_sysid); 45090 printf(" %d", n_ndataid); 45091 printf("\n"); 45092 } 45093 } 45094 } 45095 } 45096 } 45097 function_tests++; 45098 #endif 45099 45100 return(test_ret); 45101 } 45102 45103 45104 static int 45105 test_xmlTextWriterWriteDTDInternalEntity(void) { 45106 int test_ret = 0; 45107 45108 #if defined(LIBXML_WRITER_ENABLED) 45109 int mem_base; 45110 int ret_val; 45111 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 45112 int n_writer; 45113 int pe; /* TRUE if this is a parameter entity, FALSE if not */ 45114 int n_pe; 45115 xmlChar * name; /* the name of the DTD entity */ 45116 int n_name; 45117 xmlChar * content; /* content of the entity */ 45118 int n_content; 45119 45120 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 45121 for (n_pe = 0;n_pe < gen_nb_int;n_pe++) { 45122 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 45123 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 45124 mem_base = xmlMemBlocks(); 45125 writer = gen_xmlTextWriterPtr(n_writer, 0); 45126 pe = gen_int(n_pe, 1); 45127 name = gen_const_xmlChar_ptr(n_name, 2); 45128 content = gen_const_xmlChar_ptr(n_content, 3); 45129 45130 ret_val = xmlTextWriterWriteDTDInternalEntity(writer, pe, (const xmlChar *)name, (const xmlChar *)content); 45131 desret_int(ret_val); 45132 call_tests++; 45133 des_xmlTextWriterPtr(n_writer, writer, 0); 45134 des_int(n_pe, pe, 1); 45135 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 45136 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3); 45137 xmlResetLastError(); 45138 if (mem_base != xmlMemBlocks()) { 45139 printf("Leak of %d blocks found in xmlTextWriterWriteDTDInternalEntity", 45140 xmlMemBlocks() - mem_base); 45141 test_ret++; 45142 printf(" %d", n_writer); 45143 printf(" %d", n_pe); 45144 printf(" %d", n_name); 45145 printf(" %d", n_content); 45146 printf("\n"); 45147 } 45148 } 45149 } 45150 } 45151 } 45152 function_tests++; 45153 #endif 45154 45155 return(test_ret); 45156 } 45157 45158 45159 static int 45160 test_xmlTextWriterWriteDTDNotation(void) { 45161 int test_ret = 0; 45162 45163 #if defined(LIBXML_WRITER_ENABLED) 45164 int mem_base; 45165 int ret_val; 45166 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 45167 int n_writer; 45168 xmlChar * name; /* the name of the xml notation */ 45169 int n_name; 45170 xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */ 45171 int n_pubid; 45172 xmlChar * sysid; /* the system identifier, which is the URI of the DTD */ 45173 int n_sysid; 45174 45175 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 45176 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 45177 for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) { 45178 for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) { 45179 mem_base = xmlMemBlocks(); 45180 writer = gen_xmlTextWriterPtr(n_writer, 0); 45181 name = gen_const_xmlChar_ptr(n_name, 1); 45182 pubid = gen_const_xmlChar_ptr(n_pubid, 2); 45183 sysid = gen_const_xmlChar_ptr(n_sysid, 3); 45184 45185 ret_val = xmlTextWriterWriteDTDNotation(writer, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid); 45186 desret_int(ret_val); 45187 call_tests++; 45188 des_xmlTextWriterPtr(n_writer, writer, 0); 45189 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 45190 des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 2); 45191 des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 3); 45192 xmlResetLastError(); 45193 if (mem_base != xmlMemBlocks()) { 45194 printf("Leak of %d blocks found in xmlTextWriterWriteDTDNotation", 45195 xmlMemBlocks() - mem_base); 45196 test_ret++; 45197 printf(" %d", n_writer); 45198 printf(" %d", n_name); 45199 printf(" %d", n_pubid); 45200 printf(" %d", n_sysid); 45201 printf("\n"); 45202 } 45203 } 45204 } 45205 } 45206 } 45207 function_tests++; 45208 #endif 45209 45210 return(test_ret); 45211 } 45212 45213 45214 static int 45215 test_xmlTextWriterWriteElement(void) { 45216 int test_ret = 0; 45217 45218 #if defined(LIBXML_WRITER_ENABLED) 45219 int mem_base; 45220 int ret_val; 45221 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 45222 int n_writer; 45223 xmlChar * name; /* element name */ 45224 int n_name; 45225 xmlChar * content; /* element content */ 45226 int n_content; 45227 45228 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 45229 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 45230 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 45231 mem_base = xmlMemBlocks(); 45232 writer = gen_xmlTextWriterPtr(n_writer, 0); 45233 name = gen_const_xmlChar_ptr(n_name, 1); 45234 content = gen_const_xmlChar_ptr(n_content, 2); 45235 45236 ret_val = xmlTextWriterWriteElement(writer, (const xmlChar *)name, (const xmlChar *)content); 45237 desret_int(ret_val); 45238 call_tests++; 45239 des_xmlTextWriterPtr(n_writer, writer, 0); 45240 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 45241 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2); 45242 xmlResetLastError(); 45243 if (mem_base != xmlMemBlocks()) { 45244 printf("Leak of %d blocks found in xmlTextWriterWriteElement", 45245 xmlMemBlocks() - mem_base); 45246 test_ret++; 45247 printf(" %d", n_writer); 45248 printf(" %d", n_name); 45249 printf(" %d", n_content); 45250 printf("\n"); 45251 } 45252 } 45253 } 45254 } 45255 function_tests++; 45256 #endif 45257 45258 return(test_ret); 45259 } 45260 45261 45262 static int 45263 test_xmlTextWriterWriteElementNS(void) { 45264 int test_ret = 0; 45265 45266 #if defined(LIBXML_WRITER_ENABLED) 45267 int mem_base; 45268 int ret_val; 45269 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 45270 int n_writer; 45271 xmlChar * prefix; /* namespace prefix */ 45272 int n_prefix; 45273 xmlChar * name; /* element local name */ 45274 int n_name; 45275 xmlChar * namespaceURI; /* namespace URI */ 45276 int n_namespaceURI; 45277 xmlChar * content; /* element content */ 45278 int n_content; 45279 45280 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 45281 for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) { 45282 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 45283 for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) { 45284 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 45285 mem_base = xmlMemBlocks(); 45286 writer = gen_xmlTextWriterPtr(n_writer, 0); 45287 prefix = gen_const_xmlChar_ptr(n_prefix, 1); 45288 name = gen_const_xmlChar_ptr(n_name, 2); 45289 namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3); 45290 content = gen_const_xmlChar_ptr(n_content, 4); 45291 45292 ret_val = xmlTextWriterWriteElementNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI, (const xmlChar *)content); 45293 desret_int(ret_val); 45294 call_tests++; 45295 des_xmlTextWriterPtr(n_writer, writer, 0); 45296 des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1); 45297 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2); 45298 des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3); 45299 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 4); 45300 xmlResetLastError(); 45301 if (mem_base != xmlMemBlocks()) { 45302 printf("Leak of %d blocks found in xmlTextWriterWriteElementNS", 45303 xmlMemBlocks() - mem_base); 45304 test_ret++; 45305 printf(" %d", n_writer); 45306 printf(" %d", n_prefix); 45307 printf(" %d", n_name); 45308 printf(" %d", n_namespaceURI); 45309 printf(" %d", n_content); 45310 printf("\n"); 45311 } 45312 } 45313 } 45314 } 45315 } 45316 } 45317 function_tests++; 45318 #endif 45319 45320 return(test_ret); 45321 } 45322 45323 45324 static int 45325 test_xmlTextWriterWriteFormatAttribute(void) { 45326 int test_ret = 0; 45327 45328 45329 /* missing type support */ 45330 return(test_ret); 45331 } 45332 45333 45334 static int 45335 test_xmlTextWriterWriteFormatAttributeNS(void) { 45336 int test_ret = 0; 45337 45338 45339 /* missing type support */ 45340 return(test_ret); 45341 } 45342 45343 45344 static int 45345 test_xmlTextWriterWriteFormatCDATA(void) { 45346 int test_ret = 0; 45347 45348 45349 /* missing type support */ 45350 return(test_ret); 45351 } 45352 45353 45354 static int 45355 test_xmlTextWriterWriteFormatComment(void) { 45356 int test_ret = 0; 45357 45358 45359 /* missing type support */ 45360 return(test_ret); 45361 } 45362 45363 45364 static int 45365 test_xmlTextWriterWriteFormatDTD(void) { 45366 int test_ret = 0; 45367 45368 45369 /* missing type support */ 45370 return(test_ret); 45371 } 45372 45373 45374 static int 45375 test_xmlTextWriterWriteFormatDTDAttlist(void) { 45376 int test_ret = 0; 45377 45378 45379 /* missing type support */ 45380 return(test_ret); 45381 } 45382 45383 45384 static int 45385 test_xmlTextWriterWriteFormatDTDElement(void) { 45386 int test_ret = 0; 45387 45388 45389 /* missing type support */ 45390 return(test_ret); 45391 } 45392 45393 45394 static int 45395 test_xmlTextWriterWriteFormatDTDInternalEntity(void) { 45396 int test_ret = 0; 45397 45398 45399 /* missing type support */ 45400 return(test_ret); 45401 } 45402 45403 45404 static int 45405 test_xmlTextWriterWriteFormatElement(void) { 45406 int test_ret = 0; 45407 45408 45409 /* missing type support */ 45410 return(test_ret); 45411 } 45412 45413 45414 static int 45415 test_xmlTextWriterWriteFormatElementNS(void) { 45416 int test_ret = 0; 45417 45418 45419 /* missing type support */ 45420 return(test_ret); 45421 } 45422 45423 45424 static int 45425 test_xmlTextWriterWriteFormatPI(void) { 45426 int test_ret = 0; 45427 45428 45429 /* missing type support */ 45430 return(test_ret); 45431 } 45432 45433 45434 static int 45435 test_xmlTextWriterWriteFormatRaw(void) { 45436 int test_ret = 0; 45437 45438 45439 /* missing type support */ 45440 return(test_ret); 45441 } 45442 45443 45444 static int 45445 test_xmlTextWriterWriteFormatString(void) { 45446 int test_ret = 0; 45447 45448 45449 /* missing type support */ 45450 return(test_ret); 45451 } 45452 45453 45454 static int 45455 test_xmlTextWriterWritePI(void) { 45456 int test_ret = 0; 45457 45458 #if defined(LIBXML_WRITER_ENABLED) 45459 int mem_base; 45460 int ret_val; 45461 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 45462 int n_writer; 45463 xmlChar * target; /* PI target */ 45464 int n_target; 45465 xmlChar * content; /* PI content */ 45466 int n_content; 45467 45468 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 45469 for (n_target = 0;n_target < gen_nb_const_xmlChar_ptr;n_target++) { 45470 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 45471 mem_base = xmlMemBlocks(); 45472 writer = gen_xmlTextWriterPtr(n_writer, 0); 45473 target = gen_const_xmlChar_ptr(n_target, 1); 45474 content = gen_const_xmlChar_ptr(n_content, 2); 45475 45476 ret_val = xmlTextWriterWritePI(writer, (const xmlChar *)target, (const xmlChar *)content); 45477 desret_int(ret_val); 45478 call_tests++; 45479 des_xmlTextWriterPtr(n_writer, writer, 0); 45480 des_const_xmlChar_ptr(n_target, (const xmlChar *)target, 1); 45481 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2); 45482 xmlResetLastError(); 45483 if (mem_base != xmlMemBlocks()) { 45484 printf("Leak of %d blocks found in xmlTextWriterWritePI", 45485 xmlMemBlocks() - mem_base); 45486 test_ret++; 45487 printf(" %d", n_writer); 45488 printf(" %d", n_target); 45489 printf(" %d", n_content); 45490 printf("\n"); 45491 } 45492 } 45493 } 45494 } 45495 function_tests++; 45496 #endif 45497 45498 return(test_ret); 45499 } 45500 45501 45502 static int 45503 test_xmlTextWriterWriteRaw(void) { 45504 int test_ret = 0; 45505 45506 #if defined(LIBXML_WRITER_ENABLED) 45507 int mem_base; 45508 int ret_val; 45509 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 45510 int n_writer; 45511 xmlChar * content; /* text string */ 45512 int n_content; 45513 45514 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 45515 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 45516 mem_base = xmlMemBlocks(); 45517 writer = gen_xmlTextWriterPtr(n_writer, 0); 45518 content = gen_const_xmlChar_ptr(n_content, 1); 45519 45520 ret_val = xmlTextWriterWriteRaw(writer, (const xmlChar *)content); 45521 desret_int(ret_val); 45522 call_tests++; 45523 des_xmlTextWriterPtr(n_writer, writer, 0); 45524 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1); 45525 xmlResetLastError(); 45526 if (mem_base != xmlMemBlocks()) { 45527 printf("Leak of %d blocks found in xmlTextWriterWriteRaw", 45528 xmlMemBlocks() - mem_base); 45529 test_ret++; 45530 printf(" %d", n_writer); 45531 printf(" %d", n_content); 45532 printf("\n"); 45533 } 45534 } 45535 } 45536 function_tests++; 45537 #endif 45538 45539 return(test_ret); 45540 } 45541 45542 45543 static int 45544 test_xmlTextWriterWriteRawLen(void) { 45545 int test_ret = 0; 45546 45547 #if defined(LIBXML_WRITER_ENABLED) 45548 int mem_base; 45549 int ret_val; 45550 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 45551 int n_writer; 45552 xmlChar * content; /* text string */ 45553 int n_content; 45554 int len; /* length of the text string */ 45555 int n_len; 45556 45557 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 45558 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 45559 for (n_len = 0;n_len < gen_nb_int;n_len++) { 45560 mem_base = xmlMemBlocks(); 45561 writer = gen_xmlTextWriterPtr(n_writer, 0); 45562 content = gen_const_xmlChar_ptr(n_content, 1); 45563 len = gen_int(n_len, 2); 45564 45565 ret_val = xmlTextWriterWriteRawLen(writer, (const xmlChar *)content, len); 45566 desret_int(ret_val); 45567 call_tests++; 45568 des_xmlTextWriterPtr(n_writer, writer, 0); 45569 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1); 45570 des_int(n_len, len, 2); 45571 xmlResetLastError(); 45572 if (mem_base != xmlMemBlocks()) { 45573 printf("Leak of %d blocks found in xmlTextWriterWriteRawLen", 45574 xmlMemBlocks() - mem_base); 45575 test_ret++; 45576 printf(" %d", n_writer); 45577 printf(" %d", n_content); 45578 printf(" %d", n_len); 45579 printf("\n"); 45580 } 45581 } 45582 } 45583 } 45584 function_tests++; 45585 #endif 45586 45587 return(test_ret); 45588 } 45589 45590 45591 static int 45592 test_xmlTextWriterWriteString(void) { 45593 int test_ret = 0; 45594 45595 #if defined(LIBXML_WRITER_ENABLED) 45596 int mem_base; 45597 int ret_val; 45598 xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ 45599 int n_writer; 45600 xmlChar * content; /* text string */ 45601 int n_content; 45602 45603 for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { 45604 for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) { 45605 mem_base = xmlMemBlocks(); 45606 writer = gen_xmlTextWriterPtr(n_writer, 0); 45607 content = gen_const_xmlChar_ptr(n_content, 1); 45608 45609 ret_val = xmlTextWriterWriteString(writer, (const xmlChar *)content); 45610 desret_int(ret_val); 45611 call_tests++; 45612 des_xmlTextWriterPtr(n_writer, writer, 0); 45613 des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1); 45614 xmlResetLastError(); 45615 if (mem_base != xmlMemBlocks()) { 45616 printf("Leak of %d blocks found in xmlTextWriterWriteString", 45617 xmlMemBlocks() - mem_base); 45618 test_ret++; 45619 printf(" %d", n_writer); 45620 printf(" %d", n_content); 45621 printf("\n"); 45622 } 45623 } 45624 } 45625 function_tests++; 45626 #endif 45627 45628 return(test_ret); 45629 } 45630 45631 45632 static int 45633 test_xmlTextWriterWriteVFormatAttribute(void) { 45634 int test_ret = 0; 45635 45636 45637 /* missing type support */ 45638 return(test_ret); 45639 } 45640 45641 45642 static int 45643 test_xmlTextWriterWriteVFormatAttributeNS(void) { 45644 int test_ret = 0; 45645 45646 45647 /* missing type support */ 45648 return(test_ret); 45649 } 45650 45651 45652 static int 45653 test_xmlTextWriterWriteVFormatCDATA(void) { 45654 int test_ret = 0; 45655 45656 45657 /* missing type support */ 45658 return(test_ret); 45659 } 45660 45661 45662 static int 45663 test_xmlTextWriterWriteVFormatComment(void) { 45664 int test_ret = 0; 45665 45666 45667 /* missing type support */ 45668 return(test_ret); 45669 } 45670 45671 45672 static int 45673 test_xmlTextWriterWriteVFormatDTD(void) { 45674 int test_ret = 0; 45675 45676 45677 /* missing type support */ 45678 return(test_ret); 45679 } 45680 45681 45682 static int 45683 test_xmlTextWriterWriteVFormatDTDAttlist(void) { 45684 int test_ret = 0; 45685 45686 45687 /* missing type support */ 45688 return(test_ret); 45689 } 45690 45691 45692 static int 45693 test_xmlTextWriterWriteVFormatDTDElement(void) { 45694 int test_ret = 0; 45695 45696 45697 /* missing type support */ 45698 return(test_ret); 45699 } 45700 45701 45702 static int 45703 test_xmlTextWriterWriteVFormatDTDInternalEntity(void) { 45704 int test_ret = 0; 45705 45706 45707 /* missing type support */ 45708 return(test_ret); 45709 } 45710 45711 45712 static int 45713 test_xmlTextWriterWriteVFormatElement(void) { 45714 int test_ret = 0; 45715 45716 45717 /* missing type support */ 45718 return(test_ret); 45719 } 45720 45721 45722 static int 45723 test_xmlTextWriterWriteVFormatElementNS(void) { 45724 int test_ret = 0; 45725 45726 45727 /* missing type support */ 45728 return(test_ret); 45729 } 45730 45731 45732 static int 45733 test_xmlTextWriterWriteVFormatPI(void) { 45734 int test_ret = 0; 45735 45736 45737 /* missing type support */ 45738 return(test_ret); 45739 } 45740 45741 45742 static int 45743 test_xmlTextWriterWriteVFormatRaw(void) { 45744 int test_ret = 0; 45745 45746 45747 /* missing type support */ 45748 return(test_ret); 45749 } 45750 45751 45752 static int 45753 test_xmlTextWriterWriteVFormatString(void) { 45754 int test_ret = 0; 45755 45756 45757 /* missing type support */ 45758 return(test_ret); 45759 } 45760 45761 static int 45762 test_xmlwriter(void) { 45763 int test_ret = 0; 45764 45765 if (quiet == 0) printf("Testing xmlwriter : 52 of 80 functions ...\n"); 45766 test_ret += test_xmlNewTextWriter(); 45767 test_ret += test_xmlNewTextWriterFilename(); 45768 test_ret += test_xmlNewTextWriterMemory(); 45769 test_ret += test_xmlNewTextWriterPushParser(); 45770 test_ret += test_xmlNewTextWriterTree(); 45771 test_ret += test_xmlTextWriterEndAttribute(); 45772 test_ret += test_xmlTextWriterEndCDATA(); 45773 test_ret += test_xmlTextWriterEndComment(); 45774 test_ret += test_xmlTextWriterEndDTD(); 45775 test_ret += test_xmlTextWriterEndDTDAttlist(); 45776 test_ret += test_xmlTextWriterEndDTDElement(); 45777 test_ret += test_xmlTextWriterEndDTDEntity(); 45778 test_ret += test_xmlTextWriterEndDocument(); 45779 test_ret += test_xmlTextWriterEndElement(); 45780 test_ret += test_xmlTextWriterEndPI(); 45781 test_ret += test_xmlTextWriterFlush(); 45782 test_ret += test_xmlTextWriterFullEndElement(); 45783 test_ret += test_xmlTextWriterSetIndent(); 45784 test_ret += test_xmlTextWriterSetIndentString(); 45785 test_ret += test_xmlTextWriterSetQuoteChar(); 45786 test_ret += test_xmlTextWriterStartAttribute(); 45787 test_ret += test_xmlTextWriterStartAttributeNS(); 45788 test_ret += test_xmlTextWriterStartCDATA(); 45789 test_ret += test_xmlTextWriterStartComment(); 45790 test_ret += test_xmlTextWriterStartDTD(); 45791 test_ret += test_xmlTextWriterStartDTDAttlist(); 45792 test_ret += test_xmlTextWriterStartDTDElement(); 45793 test_ret += test_xmlTextWriterStartDTDEntity(); 45794 test_ret += test_xmlTextWriterStartDocument(); 45795 test_ret += test_xmlTextWriterStartElement(); 45796 test_ret += test_xmlTextWriterStartElementNS(); 45797 test_ret += test_xmlTextWriterStartPI(); 45798 test_ret += test_xmlTextWriterWriteAttribute(); 45799 test_ret += test_xmlTextWriterWriteAttributeNS(); 45800 test_ret += test_xmlTextWriterWriteBase64(); 45801 test_ret += test_xmlTextWriterWriteBinHex(); 45802 test_ret += test_xmlTextWriterWriteCDATA(); 45803 test_ret += test_xmlTextWriterWriteComment(); 45804 test_ret += test_xmlTextWriterWriteDTD(); 45805 test_ret += test_xmlTextWriterWriteDTDAttlist(); 45806 test_ret += test_xmlTextWriterWriteDTDElement(); 45807 test_ret += test_xmlTextWriterWriteDTDEntity(); 45808 test_ret += test_xmlTextWriterWriteDTDExternalEntity(); 45809 test_ret += test_xmlTextWriterWriteDTDExternalEntityContents(); 45810 test_ret += test_xmlTextWriterWriteDTDInternalEntity(); 45811 test_ret += test_xmlTextWriterWriteDTDNotation(); 45812 test_ret += test_xmlTextWriterWriteElement(); 45813 test_ret += test_xmlTextWriterWriteElementNS(); 45814 test_ret += test_xmlTextWriterWriteFormatAttribute(); 45815 test_ret += test_xmlTextWriterWriteFormatAttributeNS(); 45816 test_ret += test_xmlTextWriterWriteFormatCDATA(); 45817 test_ret += test_xmlTextWriterWriteFormatComment(); 45818 test_ret += test_xmlTextWriterWriteFormatDTD(); 45819 test_ret += test_xmlTextWriterWriteFormatDTDAttlist(); 45820 test_ret += test_xmlTextWriterWriteFormatDTDElement(); 45821 test_ret += test_xmlTextWriterWriteFormatDTDInternalEntity(); 45822 test_ret += test_xmlTextWriterWriteFormatElement(); 45823 test_ret += test_xmlTextWriterWriteFormatElementNS(); 45824 test_ret += test_xmlTextWriterWriteFormatPI(); 45825 test_ret += test_xmlTextWriterWriteFormatRaw(); 45826 test_ret += test_xmlTextWriterWriteFormatString(); 45827 test_ret += test_xmlTextWriterWritePI(); 45828 test_ret += test_xmlTextWriterWriteRaw(); 45829 test_ret += test_xmlTextWriterWriteRawLen(); 45830 test_ret += test_xmlTextWriterWriteString(); 45831 test_ret += test_xmlTextWriterWriteVFormatAttribute(); 45832 test_ret += test_xmlTextWriterWriteVFormatAttributeNS(); 45833 test_ret += test_xmlTextWriterWriteVFormatCDATA(); 45834 test_ret += test_xmlTextWriterWriteVFormatComment(); 45835 test_ret += test_xmlTextWriterWriteVFormatDTD(); 45836 test_ret += test_xmlTextWriterWriteVFormatDTDAttlist(); 45837 test_ret += test_xmlTextWriterWriteVFormatDTDElement(); 45838 test_ret += test_xmlTextWriterWriteVFormatDTDInternalEntity(); 45839 test_ret += test_xmlTextWriterWriteVFormatElement(); 45840 test_ret += test_xmlTextWriterWriteVFormatElementNS(); 45841 test_ret += test_xmlTextWriterWriteVFormatPI(); 45842 test_ret += test_xmlTextWriterWriteVFormatRaw(); 45843 test_ret += test_xmlTextWriterWriteVFormatString(); 45844 45845 if (test_ret != 0) 45846 printf("Module xmlwriter: %d errors\n", test_ret); 45847 return(test_ret); 45848 } 45849 45850 static int 45851 test_xmlXPathCastBooleanToNumber(void) { 45852 int test_ret = 0; 45853 45854 #if defined(LIBXML_XPATH_ENABLED) 45855 int mem_base; 45856 double ret_val; 45857 int val; /* a boolean */ 45858 int n_val; 45859 45860 for (n_val = 0;n_val < gen_nb_int;n_val++) { 45861 mem_base = xmlMemBlocks(); 45862 val = gen_int(n_val, 0); 45863 45864 ret_val = xmlXPathCastBooleanToNumber(val); 45865 desret_double(ret_val); 45866 call_tests++; 45867 des_int(n_val, val, 0); 45868 xmlResetLastError(); 45869 if (mem_base != xmlMemBlocks()) { 45870 printf("Leak of %d blocks found in xmlXPathCastBooleanToNumber", 45871 xmlMemBlocks() - mem_base); 45872 test_ret++; 45873 printf(" %d", n_val); 45874 printf("\n"); 45875 } 45876 } 45877 function_tests++; 45878 #endif 45879 45880 return(test_ret); 45881 } 45882 45883 45884 static int 45885 test_xmlXPathCastBooleanToString(void) { 45886 int test_ret = 0; 45887 45888 #if defined(LIBXML_XPATH_ENABLED) 45889 int mem_base; 45890 xmlChar * ret_val; 45891 int val; /* a boolean */ 45892 int n_val; 45893 45894 for (n_val = 0;n_val < gen_nb_int;n_val++) { 45895 mem_base = xmlMemBlocks(); 45896 val = gen_int(n_val, 0); 45897 45898 ret_val = xmlXPathCastBooleanToString(val); 45899 desret_xmlChar_ptr(ret_val); 45900 call_tests++; 45901 des_int(n_val, val, 0); 45902 xmlResetLastError(); 45903 if (mem_base != xmlMemBlocks()) { 45904 printf("Leak of %d blocks found in xmlXPathCastBooleanToString", 45905 xmlMemBlocks() - mem_base); 45906 test_ret++; 45907 printf(" %d", n_val); 45908 printf("\n"); 45909 } 45910 } 45911 function_tests++; 45912 #endif 45913 45914 return(test_ret); 45915 } 45916 45917 45918 static int 45919 test_xmlXPathCastNodeSetToBoolean(void) { 45920 int test_ret = 0; 45921 45922 #if defined(LIBXML_XPATH_ENABLED) 45923 int mem_base; 45924 int ret_val; 45925 xmlNodeSetPtr ns; /* a node-set */ 45926 int n_ns; 45927 45928 for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) { 45929 mem_base = xmlMemBlocks(); 45930 ns = gen_xmlNodeSetPtr(n_ns, 0); 45931 45932 ret_val = xmlXPathCastNodeSetToBoolean(ns); 45933 desret_int(ret_val); 45934 call_tests++; 45935 des_xmlNodeSetPtr(n_ns, ns, 0); 45936 xmlResetLastError(); 45937 if (mem_base != xmlMemBlocks()) { 45938 printf("Leak of %d blocks found in xmlXPathCastNodeSetToBoolean", 45939 xmlMemBlocks() - mem_base); 45940 test_ret++; 45941 printf(" %d", n_ns); 45942 printf("\n"); 45943 } 45944 } 45945 function_tests++; 45946 #endif 45947 45948 return(test_ret); 45949 } 45950 45951 45952 static int 45953 test_xmlXPathCastNodeSetToNumber(void) { 45954 int test_ret = 0; 45955 45956 #if defined(LIBXML_XPATH_ENABLED) 45957 int mem_base; 45958 double ret_val; 45959 xmlNodeSetPtr ns; /* a node-set */ 45960 int n_ns; 45961 45962 for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) { 45963 mem_base = xmlMemBlocks(); 45964 ns = gen_xmlNodeSetPtr(n_ns, 0); 45965 45966 ret_val = xmlXPathCastNodeSetToNumber(ns); 45967 desret_double(ret_val); 45968 call_tests++; 45969 des_xmlNodeSetPtr(n_ns, ns, 0); 45970 xmlResetLastError(); 45971 if (mem_base != xmlMemBlocks()) { 45972 printf("Leak of %d blocks found in xmlXPathCastNodeSetToNumber", 45973 xmlMemBlocks() - mem_base); 45974 test_ret++; 45975 printf(" %d", n_ns); 45976 printf("\n"); 45977 } 45978 } 45979 function_tests++; 45980 #endif 45981 45982 return(test_ret); 45983 } 45984 45985 45986 static int 45987 test_xmlXPathCastNodeSetToString(void) { 45988 int test_ret = 0; 45989 45990 #if defined(LIBXML_XPATH_ENABLED) 45991 int mem_base; 45992 xmlChar * ret_val; 45993 xmlNodeSetPtr ns; /* a node-set */ 45994 int n_ns; 45995 45996 for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) { 45997 mem_base = xmlMemBlocks(); 45998 ns = gen_xmlNodeSetPtr(n_ns, 0); 45999 46000 ret_val = xmlXPathCastNodeSetToString(ns); 46001 desret_xmlChar_ptr(ret_val); 46002 call_tests++; 46003 des_xmlNodeSetPtr(n_ns, ns, 0); 46004 xmlResetLastError(); 46005 if (mem_base != xmlMemBlocks()) { 46006 printf("Leak of %d blocks found in xmlXPathCastNodeSetToString", 46007 xmlMemBlocks() - mem_base); 46008 test_ret++; 46009 printf(" %d", n_ns); 46010 printf("\n"); 46011 } 46012 } 46013 function_tests++; 46014 #endif 46015 46016 return(test_ret); 46017 } 46018 46019 46020 static int 46021 test_xmlXPathCastNodeToNumber(void) { 46022 int test_ret = 0; 46023 46024 #if defined(LIBXML_XPATH_ENABLED) 46025 int mem_base; 46026 double ret_val; 46027 xmlNodePtr node; /* a node */ 46028 int n_node; 46029 46030 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 46031 mem_base = xmlMemBlocks(); 46032 node = gen_xmlNodePtr(n_node, 0); 46033 46034 ret_val = xmlXPathCastNodeToNumber(node); 46035 desret_double(ret_val); 46036 call_tests++; 46037 des_xmlNodePtr(n_node, node, 0); 46038 xmlResetLastError(); 46039 if (mem_base != xmlMemBlocks()) { 46040 printf("Leak of %d blocks found in xmlXPathCastNodeToNumber", 46041 xmlMemBlocks() - mem_base); 46042 test_ret++; 46043 printf(" %d", n_node); 46044 printf("\n"); 46045 } 46046 } 46047 function_tests++; 46048 #endif 46049 46050 return(test_ret); 46051 } 46052 46053 46054 static int 46055 test_xmlXPathCastNodeToString(void) { 46056 int test_ret = 0; 46057 46058 #if defined(LIBXML_XPATH_ENABLED) 46059 int mem_base; 46060 xmlChar * ret_val; 46061 xmlNodePtr node; /* a node */ 46062 int n_node; 46063 46064 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 46065 mem_base = xmlMemBlocks(); 46066 node = gen_xmlNodePtr(n_node, 0); 46067 46068 ret_val = xmlXPathCastNodeToString(node); 46069 desret_xmlChar_ptr(ret_val); 46070 call_tests++; 46071 des_xmlNodePtr(n_node, node, 0); 46072 xmlResetLastError(); 46073 if (mem_base != xmlMemBlocks()) { 46074 printf("Leak of %d blocks found in xmlXPathCastNodeToString", 46075 xmlMemBlocks() - mem_base); 46076 test_ret++; 46077 printf(" %d", n_node); 46078 printf("\n"); 46079 } 46080 } 46081 function_tests++; 46082 #endif 46083 46084 return(test_ret); 46085 } 46086 46087 46088 static int 46089 test_xmlXPathCastNumberToBoolean(void) { 46090 int test_ret = 0; 46091 46092 #if defined(LIBXML_XPATH_ENABLED) 46093 int mem_base; 46094 int ret_val; 46095 double val; /* a number */ 46096 int n_val; 46097 46098 for (n_val = 0;n_val < gen_nb_double;n_val++) { 46099 mem_base = xmlMemBlocks(); 46100 val = gen_double(n_val, 0); 46101 46102 ret_val = xmlXPathCastNumberToBoolean(val); 46103 desret_int(ret_val); 46104 call_tests++; 46105 des_double(n_val, val, 0); 46106 xmlResetLastError(); 46107 if (mem_base != xmlMemBlocks()) { 46108 printf("Leak of %d blocks found in xmlXPathCastNumberToBoolean", 46109 xmlMemBlocks() - mem_base); 46110 test_ret++; 46111 printf(" %d", n_val); 46112 printf("\n"); 46113 } 46114 } 46115 function_tests++; 46116 #endif 46117 46118 return(test_ret); 46119 } 46120 46121 46122 static int 46123 test_xmlXPathCastNumberToString(void) { 46124 int test_ret = 0; 46125 46126 #if defined(LIBXML_XPATH_ENABLED) 46127 int mem_base; 46128 xmlChar * ret_val; 46129 double val; /* a number */ 46130 int n_val; 46131 46132 for (n_val = 0;n_val < gen_nb_double;n_val++) { 46133 mem_base = xmlMemBlocks(); 46134 val = gen_double(n_val, 0); 46135 46136 ret_val = xmlXPathCastNumberToString(val); 46137 desret_xmlChar_ptr(ret_val); 46138 call_tests++; 46139 des_double(n_val, val, 0); 46140 xmlResetLastError(); 46141 if (mem_base != xmlMemBlocks()) { 46142 printf("Leak of %d blocks found in xmlXPathCastNumberToString", 46143 xmlMemBlocks() - mem_base); 46144 test_ret++; 46145 printf(" %d", n_val); 46146 printf("\n"); 46147 } 46148 } 46149 function_tests++; 46150 #endif 46151 46152 return(test_ret); 46153 } 46154 46155 46156 static int 46157 test_xmlXPathCastStringToBoolean(void) { 46158 int test_ret = 0; 46159 46160 #if defined(LIBXML_XPATH_ENABLED) 46161 int mem_base; 46162 int ret_val; 46163 xmlChar * val; /* a string */ 46164 int n_val; 46165 46166 for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) { 46167 mem_base = xmlMemBlocks(); 46168 val = gen_const_xmlChar_ptr(n_val, 0); 46169 46170 ret_val = xmlXPathCastStringToBoolean((const xmlChar *)val); 46171 desret_int(ret_val); 46172 call_tests++; 46173 des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 0); 46174 xmlResetLastError(); 46175 if (mem_base != xmlMemBlocks()) { 46176 printf("Leak of %d blocks found in xmlXPathCastStringToBoolean", 46177 xmlMemBlocks() - mem_base); 46178 test_ret++; 46179 printf(" %d", n_val); 46180 printf("\n"); 46181 } 46182 } 46183 function_tests++; 46184 #endif 46185 46186 return(test_ret); 46187 } 46188 46189 46190 static int 46191 test_xmlXPathCastStringToNumber(void) { 46192 int test_ret = 0; 46193 46194 #if defined(LIBXML_XPATH_ENABLED) 46195 int mem_base; 46196 double ret_val; 46197 xmlChar * val; /* a string */ 46198 int n_val; 46199 46200 for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) { 46201 mem_base = xmlMemBlocks(); 46202 val = gen_const_xmlChar_ptr(n_val, 0); 46203 46204 ret_val = xmlXPathCastStringToNumber((const xmlChar *)val); 46205 desret_double(ret_val); 46206 call_tests++; 46207 des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 0); 46208 xmlResetLastError(); 46209 if (mem_base != xmlMemBlocks()) { 46210 printf("Leak of %d blocks found in xmlXPathCastStringToNumber", 46211 xmlMemBlocks() - mem_base); 46212 test_ret++; 46213 printf(" %d", n_val); 46214 printf("\n"); 46215 } 46216 } 46217 function_tests++; 46218 #endif 46219 46220 return(test_ret); 46221 } 46222 46223 46224 static int 46225 test_xmlXPathCastToBoolean(void) { 46226 int test_ret = 0; 46227 46228 #if defined(LIBXML_XPATH_ENABLED) 46229 int mem_base; 46230 int ret_val; 46231 xmlXPathObjectPtr val; /* an XPath object */ 46232 int n_val; 46233 46234 for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) { 46235 mem_base = xmlMemBlocks(); 46236 val = gen_xmlXPathObjectPtr(n_val, 0); 46237 46238 ret_val = xmlXPathCastToBoolean(val); 46239 desret_int(ret_val); 46240 call_tests++; 46241 des_xmlXPathObjectPtr(n_val, val, 0); 46242 xmlResetLastError(); 46243 if (mem_base != xmlMemBlocks()) { 46244 printf("Leak of %d blocks found in xmlXPathCastToBoolean", 46245 xmlMemBlocks() - mem_base); 46246 test_ret++; 46247 printf(" %d", n_val); 46248 printf("\n"); 46249 } 46250 } 46251 function_tests++; 46252 #endif 46253 46254 return(test_ret); 46255 } 46256 46257 46258 static int 46259 test_xmlXPathCastToNumber(void) { 46260 int test_ret = 0; 46261 46262 #if defined(LIBXML_XPATH_ENABLED) 46263 int mem_base; 46264 double ret_val; 46265 xmlXPathObjectPtr val; /* an XPath object */ 46266 int n_val; 46267 46268 for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) { 46269 mem_base = xmlMemBlocks(); 46270 val = gen_xmlXPathObjectPtr(n_val, 0); 46271 46272 ret_val = xmlXPathCastToNumber(val); 46273 desret_double(ret_val); 46274 call_tests++; 46275 des_xmlXPathObjectPtr(n_val, val, 0); 46276 xmlResetLastError(); 46277 if (mem_base != xmlMemBlocks()) { 46278 printf("Leak of %d blocks found in xmlXPathCastToNumber", 46279 xmlMemBlocks() - mem_base); 46280 test_ret++; 46281 printf(" %d", n_val); 46282 printf("\n"); 46283 } 46284 } 46285 function_tests++; 46286 #endif 46287 46288 return(test_ret); 46289 } 46290 46291 46292 static int 46293 test_xmlXPathCastToString(void) { 46294 int test_ret = 0; 46295 46296 #if defined(LIBXML_XPATH_ENABLED) 46297 int mem_base; 46298 xmlChar * ret_val; 46299 xmlXPathObjectPtr val; /* an XPath object */ 46300 int n_val; 46301 46302 for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) { 46303 mem_base = xmlMemBlocks(); 46304 val = gen_xmlXPathObjectPtr(n_val, 0); 46305 46306 ret_val = xmlXPathCastToString(val); 46307 desret_xmlChar_ptr(ret_val); 46308 call_tests++; 46309 des_xmlXPathObjectPtr(n_val, val, 0); 46310 xmlResetLastError(); 46311 if (mem_base != xmlMemBlocks()) { 46312 printf("Leak of %d blocks found in xmlXPathCastToString", 46313 xmlMemBlocks() - mem_base); 46314 test_ret++; 46315 printf(" %d", n_val); 46316 printf("\n"); 46317 } 46318 } 46319 function_tests++; 46320 #endif 46321 46322 return(test_ret); 46323 } 46324 46325 46326 static int 46327 test_xmlXPathCmpNodes(void) { 46328 int test_ret = 0; 46329 46330 #if defined(LIBXML_XPATH_ENABLED) 46331 int mem_base; 46332 int ret_val; 46333 xmlNodePtr node1; /* the first node */ 46334 int n_node1; 46335 xmlNodePtr node2; /* the second node */ 46336 int n_node2; 46337 46338 for (n_node1 = 0;n_node1 < gen_nb_xmlNodePtr;n_node1++) { 46339 for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) { 46340 mem_base = xmlMemBlocks(); 46341 node1 = gen_xmlNodePtr(n_node1, 0); 46342 node2 = gen_xmlNodePtr(n_node2, 1); 46343 46344 ret_val = xmlXPathCmpNodes(node1, node2); 46345 desret_int(ret_val); 46346 call_tests++; 46347 des_xmlNodePtr(n_node1, node1, 0); 46348 des_xmlNodePtr(n_node2, node2, 1); 46349 xmlResetLastError(); 46350 if (mem_base != xmlMemBlocks()) { 46351 printf("Leak of %d blocks found in xmlXPathCmpNodes", 46352 xmlMemBlocks() - mem_base); 46353 test_ret++; 46354 printf(" %d", n_node1); 46355 printf(" %d", n_node2); 46356 printf("\n"); 46357 } 46358 } 46359 } 46360 function_tests++; 46361 #endif 46362 46363 return(test_ret); 46364 } 46365 46366 46367 static int 46368 test_xmlXPathCompile(void) { 46369 int test_ret = 0; 46370 46371 46372 /* missing type support */ 46373 return(test_ret); 46374 } 46375 46376 #ifdef LIBXML_XPATH_ENABLED 46377 46378 #define gen_nb_xmlXPathCompExprPtr 1 46379 static xmlXPathCompExprPtr gen_xmlXPathCompExprPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 46380 return(NULL); 46381 } 46382 static void des_xmlXPathCompExprPtr(int no ATTRIBUTE_UNUSED, xmlXPathCompExprPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 46383 } 46384 #endif 46385 46386 #ifdef LIBXML_XPATH_ENABLED 46387 46388 #define gen_nb_xmlXPathContextPtr 1 46389 static xmlXPathContextPtr gen_xmlXPathContextPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 46390 return(NULL); 46391 } 46392 static void des_xmlXPathContextPtr(int no ATTRIBUTE_UNUSED, xmlXPathContextPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 46393 } 46394 #endif 46395 46396 46397 static int 46398 test_xmlXPathCompiledEval(void) { 46399 int test_ret = 0; 46400 46401 #if defined(LIBXML_XPATH_ENABLED) 46402 int mem_base; 46403 xmlXPathObjectPtr ret_val; 46404 xmlXPathCompExprPtr comp; /* the compiled XPath expression */ 46405 int n_comp; 46406 xmlXPathContextPtr ctx; /* the XPath context */ 46407 int n_ctx; 46408 46409 for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) { 46410 for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) { 46411 mem_base = xmlMemBlocks(); 46412 comp = gen_xmlXPathCompExprPtr(n_comp, 0); 46413 ctx = gen_xmlXPathContextPtr(n_ctx, 1); 46414 46415 ret_val = xmlXPathCompiledEval(comp, ctx); 46416 desret_xmlXPathObjectPtr(ret_val); 46417 call_tests++; 46418 des_xmlXPathCompExprPtr(n_comp, comp, 0); 46419 des_xmlXPathContextPtr(n_ctx, ctx, 1); 46420 xmlResetLastError(); 46421 if (mem_base != xmlMemBlocks()) { 46422 printf("Leak of %d blocks found in xmlXPathCompiledEval", 46423 xmlMemBlocks() - mem_base); 46424 test_ret++; 46425 printf(" %d", n_comp); 46426 printf(" %d", n_ctx); 46427 printf("\n"); 46428 } 46429 } 46430 } 46431 function_tests++; 46432 #endif 46433 46434 return(test_ret); 46435 } 46436 46437 46438 static int 46439 test_xmlXPathCompiledEvalToBoolean(void) { 46440 int test_ret = 0; 46441 46442 #if defined(LIBXML_XPATH_ENABLED) 46443 int mem_base; 46444 int ret_val; 46445 xmlXPathCompExprPtr comp; /* the compiled XPath expression */ 46446 int n_comp; 46447 xmlXPathContextPtr ctxt; /* the XPath context */ 46448 int n_ctxt; 46449 46450 for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) { 46451 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) { 46452 mem_base = xmlMemBlocks(); 46453 comp = gen_xmlXPathCompExprPtr(n_comp, 0); 46454 ctxt = gen_xmlXPathContextPtr(n_ctxt, 1); 46455 46456 ret_val = xmlXPathCompiledEvalToBoolean(comp, ctxt); 46457 desret_int(ret_val); 46458 call_tests++; 46459 des_xmlXPathCompExprPtr(n_comp, comp, 0); 46460 des_xmlXPathContextPtr(n_ctxt, ctxt, 1); 46461 xmlResetLastError(); 46462 if (mem_base != xmlMemBlocks()) { 46463 printf("Leak of %d blocks found in xmlXPathCompiledEvalToBoolean", 46464 xmlMemBlocks() - mem_base); 46465 test_ret++; 46466 printf(" %d", n_comp); 46467 printf(" %d", n_ctxt); 46468 printf("\n"); 46469 } 46470 } 46471 } 46472 function_tests++; 46473 #endif 46474 46475 return(test_ret); 46476 } 46477 46478 46479 static int 46480 test_xmlXPathContextSetCache(void) { 46481 int test_ret = 0; 46482 46483 #if defined(LIBXML_XPATH_ENABLED) 46484 int mem_base; 46485 int ret_val; 46486 xmlXPathContextPtr ctxt; /* the XPath context */ 46487 int n_ctxt; 46488 int active; /* enables/disables (creates/frees) the cache */ 46489 int n_active; 46490 int value; /* a value with semantics dependant on @options */ 46491 int n_value; 46492 int options; /* options (currently only the value 0 is used) */ 46493 int n_options; 46494 46495 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) { 46496 for (n_active = 0;n_active < gen_nb_int;n_active++) { 46497 for (n_value = 0;n_value < gen_nb_int;n_value++) { 46498 for (n_options = 0;n_options < gen_nb_int;n_options++) { 46499 mem_base = xmlMemBlocks(); 46500 ctxt = gen_xmlXPathContextPtr(n_ctxt, 0); 46501 active = gen_int(n_active, 1); 46502 value = gen_int(n_value, 2); 46503 options = gen_int(n_options, 3); 46504 46505 ret_val = xmlXPathContextSetCache(ctxt, active, value, options); 46506 desret_int(ret_val); 46507 call_tests++; 46508 des_xmlXPathContextPtr(n_ctxt, ctxt, 0); 46509 des_int(n_active, active, 1); 46510 des_int(n_value, value, 2); 46511 des_int(n_options, options, 3); 46512 xmlResetLastError(); 46513 if (mem_base != xmlMemBlocks()) { 46514 printf("Leak of %d blocks found in xmlXPathContextSetCache", 46515 xmlMemBlocks() - mem_base); 46516 test_ret++; 46517 printf(" %d", n_ctxt); 46518 printf(" %d", n_active); 46519 printf(" %d", n_value); 46520 printf(" %d", n_options); 46521 printf("\n"); 46522 } 46523 } 46524 } 46525 } 46526 } 46527 function_tests++; 46528 #endif 46529 46530 return(test_ret); 46531 } 46532 46533 46534 static int 46535 test_xmlXPathConvertBoolean(void) { 46536 int test_ret = 0; 46537 46538 #if defined(LIBXML_XPATH_ENABLED) 46539 int mem_base; 46540 xmlXPathObjectPtr ret_val; 46541 xmlXPathObjectPtr val; /* an XPath object */ 46542 int n_val; 46543 46544 for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) { 46545 mem_base = xmlMemBlocks(); 46546 val = gen_xmlXPathObjectPtr(n_val, 0); 46547 46548 ret_val = xmlXPathConvertBoolean(val); 46549 val = NULL; 46550 desret_xmlXPathObjectPtr(ret_val); 46551 call_tests++; 46552 des_xmlXPathObjectPtr(n_val, val, 0); 46553 xmlResetLastError(); 46554 if (mem_base != xmlMemBlocks()) { 46555 printf("Leak of %d blocks found in xmlXPathConvertBoolean", 46556 xmlMemBlocks() - mem_base); 46557 test_ret++; 46558 printf(" %d", n_val); 46559 printf("\n"); 46560 } 46561 } 46562 function_tests++; 46563 #endif 46564 46565 return(test_ret); 46566 } 46567 46568 46569 static int 46570 test_xmlXPathConvertNumber(void) { 46571 int test_ret = 0; 46572 46573 #if defined(LIBXML_XPATH_ENABLED) 46574 int mem_base; 46575 xmlXPathObjectPtr ret_val; 46576 xmlXPathObjectPtr val; /* an XPath object */ 46577 int n_val; 46578 46579 for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) { 46580 mem_base = xmlMemBlocks(); 46581 val = gen_xmlXPathObjectPtr(n_val, 0); 46582 46583 ret_val = xmlXPathConvertNumber(val); 46584 val = NULL; 46585 desret_xmlXPathObjectPtr(ret_val); 46586 call_tests++; 46587 des_xmlXPathObjectPtr(n_val, val, 0); 46588 xmlResetLastError(); 46589 if (mem_base != xmlMemBlocks()) { 46590 printf("Leak of %d blocks found in xmlXPathConvertNumber", 46591 xmlMemBlocks() - mem_base); 46592 test_ret++; 46593 printf(" %d", n_val); 46594 printf("\n"); 46595 } 46596 } 46597 function_tests++; 46598 #endif 46599 46600 return(test_ret); 46601 } 46602 46603 46604 static int 46605 test_xmlXPathConvertString(void) { 46606 int test_ret = 0; 46607 46608 #if defined(LIBXML_XPATH_ENABLED) 46609 int mem_base; 46610 xmlXPathObjectPtr ret_val; 46611 xmlXPathObjectPtr val; /* an XPath object */ 46612 int n_val; 46613 46614 for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) { 46615 mem_base = xmlMemBlocks(); 46616 val = gen_xmlXPathObjectPtr(n_val, 0); 46617 46618 ret_val = xmlXPathConvertString(val); 46619 val = NULL; 46620 desret_xmlXPathObjectPtr(ret_val); 46621 call_tests++; 46622 des_xmlXPathObjectPtr(n_val, val, 0); 46623 xmlResetLastError(); 46624 if (mem_base != xmlMemBlocks()) { 46625 printf("Leak of %d blocks found in xmlXPathConvertString", 46626 xmlMemBlocks() - mem_base); 46627 test_ret++; 46628 printf(" %d", n_val); 46629 printf("\n"); 46630 } 46631 } 46632 function_tests++; 46633 #endif 46634 46635 return(test_ret); 46636 } 46637 46638 46639 static int 46640 test_xmlXPathCtxtCompile(void) { 46641 int test_ret = 0; 46642 46643 46644 /* missing type support */ 46645 return(test_ret); 46646 } 46647 46648 46649 static int 46650 test_xmlXPathEval(void) { 46651 int test_ret = 0; 46652 46653 #if defined(LIBXML_XPATH_ENABLED) 46654 int mem_base; 46655 xmlXPathObjectPtr ret_val; 46656 xmlChar * str; /* the XPath expression */ 46657 int n_str; 46658 xmlXPathContextPtr ctx; /* the XPath context */ 46659 int n_ctx; 46660 46661 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 46662 for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) { 46663 mem_base = xmlMemBlocks(); 46664 str = gen_const_xmlChar_ptr(n_str, 0); 46665 ctx = gen_xmlXPathContextPtr(n_ctx, 1); 46666 46667 ret_val = xmlXPathEval((const xmlChar *)str, ctx); 46668 desret_xmlXPathObjectPtr(ret_val); 46669 call_tests++; 46670 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); 46671 des_xmlXPathContextPtr(n_ctx, ctx, 1); 46672 xmlResetLastError(); 46673 if (mem_base != xmlMemBlocks()) { 46674 printf("Leak of %d blocks found in xmlXPathEval", 46675 xmlMemBlocks() - mem_base); 46676 test_ret++; 46677 printf(" %d", n_str); 46678 printf(" %d", n_ctx); 46679 printf("\n"); 46680 } 46681 } 46682 } 46683 function_tests++; 46684 #endif 46685 46686 return(test_ret); 46687 } 46688 46689 46690 static int 46691 test_xmlXPathEvalExpression(void) { 46692 int test_ret = 0; 46693 46694 #if defined(LIBXML_XPATH_ENABLED) 46695 int mem_base; 46696 xmlXPathObjectPtr ret_val; 46697 xmlChar * str; /* the XPath expression */ 46698 int n_str; 46699 xmlXPathContextPtr ctxt; /* the XPath context */ 46700 int n_ctxt; 46701 46702 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 46703 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) { 46704 mem_base = xmlMemBlocks(); 46705 str = gen_const_xmlChar_ptr(n_str, 0); 46706 ctxt = gen_xmlXPathContextPtr(n_ctxt, 1); 46707 46708 ret_val = xmlXPathEvalExpression((const xmlChar *)str, ctxt); 46709 desret_xmlXPathObjectPtr(ret_val); 46710 call_tests++; 46711 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); 46712 des_xmlXPathContextPtr(n_ctxt, ctxt, 1); 46713 xmlResetLastError(); 46714 if (mem_base != xmlMemBlocks()) { 46715 printf("Leak of %d blocks found in xmlXPathEvalExpression", 46716 xmlMemBlocks() - mem_base); 46717 test_ret++; 46718 printf(" %d", n_str); 46719 printf(" %d", n_ctxt); 46720 printf("\n"); 46721 } 46722 } 46723 } 46724 function_tests++; 46725 #endif 46726 46727 return(test_ret); 46728 } 46729 46730 46731 static int 46732 test_xmlXPathEvalPredicate(void) { 46733 int test_ret = 0; 46734 46735 #if defined(LIBXML_XPATH_ENABLED) 46736 int mem_base; 46737 int ret_val; 46738 xmlXPathContextPtr ctxt; /* the XPath context */ 46739 int n_ctxt; 46740 xmlXPathObjectPtr res; /* the Predicate Expression evaluation result */ 46741 int n_res; 46742 46743 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) { 46744 for (n_res = 0;n_res < gen_nb_xmlXPathObjectPtr;n_res++) { 46745 mem_base = xmlMemBlocks(); 46746 ctxt = gen_xmlXPathContextPtr(n_ctxt, 0); 46747 res = gen_xmlXPathObjectPtr(n_res, 1); 46748 46749 ret_val = xmlXPathEvalPredicate(ctxt, res); 46750 desret_int(ret_val); 46751 call_tests++; 46752 des_xmlXPathContextPtr(n_ctxt, ctxt, 0); 46753 des_xmlXPathObjectPtr(n_res, res, 1); 46754 xmlResetLastError(); 46755 if (mem_base != xmlMemBlocks()) { 46756 printf("Leak of %d blocks found in xmlXPathEvalPredicate", 46757 xmlMemBlocks() - mem_base); 46758 test_ret++; 46759 printf(" %d", n_ctxt); 46760 printf(" %d", n_res); 46761 printf("\n"); 46762 } 46763 } 46764 } 46765 function_tests++; 46766 #endif 46767 46768 return(test_ret); 46769 } 46770 46771 46772 static int 46773 test_xmlXPathInit(void) { 46774 int test_ret = 0; 46775 46776 #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 46777 int mem_base; 46778 46779 mem_base = xmlMemBlocks(); 46780 46781 xmlXPathInit(); 46782 call_tests++; 46783 xmlResetLastError(); 46784 if (mem_base != xmlMemBlocks()) { 46785 printf("Leak of %d blocks found in xmlXPathInit", 46786 xmlMemBlocks() - mem_base); 46787 test_ret++; 46788 printf("\n"); 46789 } 46790 function_tests++; 46791 #endif 46792 46793 return(test_ret); 46794 } 46795 46796 46797 static int 46798 test_xmlXPathIsInf(void) { 46799 int test_ret = 0; 46800 46801 #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 46802 int mem_base; 46803 int ret_val; 46804 double val; /* a double value */ 46805 int n_val; 46806 46807 for (n_val = 0;n_val < gen_nb_double;n_val++) { 46808 mem_base = xmlMemBlocks(); 46809 val = gen_double(n_val, 0); 46810 46811 ret_val = xmlXPathIsInf(val); 46812 desret_int(ret_val); 46813 call_tests++; 46814 des_double(n_val, val, 0); 46815 xmlResetLastError(); 46816 if (mem_base != xmlMemBlocks()) { 46817 printf("Leak of %d blocks found in xmlXPathIsInf", 46818 xmlMemBlocks() - mem_base); 46819 test_ret++; 46820 printf(" %d", n_val); 46821 printf("\n"); 46822 } 46823 } 46824 function_tests++; 46825 #endif 46826 46827 return(test_ret); 46828 } 46829 46830 46831 static int 46832 test_xmlXPathIsNaN(void) { 46833 int test_ret = 0; 46834 46835 #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) 46836 int mem_base; 46837 int ret_val; 46838 double val; /* a double value */ 46839 int n_val; 46840 46841 for (n_val = 0;n_val < gen_nb_double;n_val++) { 46842 mem_base = xmlMemBlocks(); 46843 val = gen_double(n_val, 0); 46844 46845 ret_val = xmlXPathIsNaN(val); 46846 desret_int(ret_val); 46847 call_tests++; 46848 des_double(n_val, val, 0); 46849 xmlResetLastError(); 46850 if (mem_base != xmlMemBlocks()) { 46851 printf("Leak of %d blocks found in xmlXPathIsNaN", 46852 xmlMemBlocks() - mem_base); 46853 test_ret++; 46854 printf(" %d", n_val); 46855 printf("\n"); 46856 } 46857 } 46858 function_tests++; 46859 #endif 46860 46861 return(test_ret); 46862 } 46863 46864 46865 static int 46866 test_xmlXPathNewContext(void) { 46867 int test_ret = 0; 46868 46869 46870 /* missing type support */ 46871 return(test_ret); 46872 } 46873 46874 46875 static int 46876 test_xmlXPathNodeEval(void) { 46877 int test_ret = 0; 46878 46879 #if defined(LIBXML_XPATH_ENABLED) 46880 int mem_base; 46881 xmlXPathObjectPtr ret_val; 46882 xmlNodePtr node; /* the node to to use as the context node */ 46883 int n_node; 46884 xmlChar * str; /* the XPath expression */ 46885 int n_str; 46886 xmlXPathContextPtr ctx; /* the XPath context */ 46887 int n_ctx; 46888 46889 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 46890 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 46891 for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) { 46892 mem_base = xmlMemBlocks(); 46893 node = gen_xmlNodePtr(n_node, 0); 46894 str = gen_const_xmlChar_ptr(n_str, 1); 46895 ctx = gen_xmlXPathContextPtr(n_ctx, 2); 46896 46897 ret_val = xmlXPathNodeEval(node, (const xmlChar *)str, ctx); 46898 desret_xmlXPathObjectPtr(ret_val); 46899 call_tests++; 46900 des_xmlNodePtr(n_node, node, 0); 46901 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1); 46902 des_xmlXPathContextPtr(n_ctx, ctx, 2); 46903 xmlResetLastError(); 46904 if (mem_base != xmlMemBlocks()) { 46905 printf("Leak of %d blocks found in xmlXPathNodeEval", 46906 xmlMemBlocks() - mem_base); 46907 test_ret++; 46908 printf(" %d", n_node); 46909 printf(" %d", n_str); 46910 printf(" %d", n_ctx); 46911 printf("\n"); 46912 } 46913 } 46914 } 46915 } 46916 function_tests++; 46917 #endif 46918 46919 return(test_ret); 46920 } 46921 46922 46923 static int 46924 test_xmlXPathNodeSetCreate(void) { 46925 int test_ret = 0; 46926 46927 #if defined(LIBXML_XPATH_ENABLED) 46928 int mem_base; 46929 xmlNodeSetPtr ret_val; 46930 xmlNodePtr val; /* an initial xmlNodePtr, or NULL */ 46931 int n_val; 46932 46933 for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) { 46934 mem_base = xmlMemBlocks(); 46935 val = gen_xmlNodePtr(n_val, 0); 46936 46937 ret_val = xmlXPathNodeSetCreate(val); 46938 desret_xmlNodeSetPtr(ret_val); 46939 call_tests++; 46940 des_xmlNodePtr(n_val, val, 0); 46941 xmlResetLastError(); 46942 if (mem_base != xmlMemBlocks()) { 46943 printf("Leak of %d blocks found in xmlXPathNodeSetCreate", 46944 xmlMemBlocks() - mem_base); 46945 test_ret++; 46946 printf(" %d", n_val); 46947 printf("\n"); 46948 } 46949 } 46950 function_tests++; 46951 #endif 46952 46953 return(test_ret); 46954 } 46955 46956 46957 static int 46958 test_xmlXPathObjectCopy(void) { 46959 int test_ret = 0; 46960 46961 #if defined(LIBXML_XPATH_ENABLED) 46962 int mem_base; 46963 xmlXPathObjectPtr ret_val; 46964 xmlXPathObjectPtr val; /* the original object */ 46965 int n_val; 46966 46967 for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) { 46968 mem_base = xmlMemBlocks(); 46969 val = gen_xmlXPathObjectPtr(n_val, 0); 46970 46971 ret_val = xmlXPathObjectCopy(val); 46972 desret_xmlXPathObjectPtr(ret_val); 46973 call_tests++; 46974 des_xmlXPathObjectPtr(n_val, val, 0); 46975 xmlResetLastError(); 46976 if (mem_base != xmlMemBlocks()) { 46977 printf("Leak of %d blocks found in xmlXPathObjectCopy", 46978 xmlMemBlocks() - mem_base); 46979 test_ret++; 46980 printf(" %d", n_val); 46981 printf("\n"); 46982 } 46983 } 46984 function_tests++; 46985 #endif 46986 46987 return(test_ret); 46988 } 46989 46990 46991 static int 46992 test_xmlXPathOrderDocElems(void) { 46993 int test_ret = 0; 46994 46995 #if defined(LIBXML_XPATH_ENABLED) 46996 int mem_base; 46997 long ret_val; 46998 xmlDocPtr doc; /* an input document */ 46999 int n_doc; 47000 47001 for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) { 47002 mem_base = xmlMemBlocks(); 47003 doc = gen_xmlDocPtr(n_doc, 0); 47004 47005 ret_val = xmlXPathOrderDocElems(doc); 47006 desret_long(ret_val); 47007 call_tests++; 47008 des_xmlDocPtr(n_doc, doc, 0); 47009 xmlResetLastError(); 47010 if (mem_base != xmlMemBlocks()) { 47011 printf("Leak of %d blocks found in xmlXPathOrderDocElems", 47012 xmlMemBlocks() - mem_base); 47013 test_ret++; 47014 printf(" %d", n_doc); 47015 printf("\n"); 47016 } 47017 } 47018 function_tests++; 47019 #endif 47020 47021 return(test_ret); 47022 } 47023 47024 47025 static int 47026 test_xmlXPathSetContextNode(void) { 47027 int test_ret = 0; 47028 47029 #if defined(LIBXML_XPATH_ENABLED) 47030 int mem_base; 47031 int ret_val; 47032 xmlNodePtr node; /* the node to to use as the context node */ 47033 int n_node; 47034 xmlXPathContextPtr ctx; /* the XPath context */ 47035 int n_ctx; 47036 47037 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 47038 for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) { 47039 mem_base = xmlMemBlocks(); 47040 node = gen_xmlNodePtr(n_node, 0); 47041 ctx = gen_xmlXPathContextPtr(n_ctx, 1); 47042 47043 ret_val = xmlXPathSetContextNode(node, ctx); 47044 desret_int(ret_val); 47045 call_tests++; 47046 des_xmlNodePtr(n_node, node, 0); 47047 des_xmlXPathContextPtr(n_ctx, ctx, 1); 47048 xmlResetLastError(); 47049 if (mem_base != xmlMemBlocks()) { 47050 printf("Leak of %d blocks found in xmlXPathSetContextNode", 47051 xmlMemBlocks() - mem_base); 47052 test_ret++; 47053 printf(" %d", n_node); 47054 printf(" %d", n_ctx); 47055 printf("\n"); 47056 } 47057 } 47058 } 47059 function_tests++; 47060 #endif 47061 47062 return(test_ret); 47063 } 47064 47065 static int 47066 test_xpath(void) { 47067 int test_ret = 0; 47068 47069 if (quiet == 0) printf("Testing xpath : 32 of 40 functions ...\n"); 47070 test_ret += test_xmlXPathCastBooleanToNumber(); 47071 test_ret += test_xmlXPathCastBooleanToString(); 47072 test_ret += test_xmlXPathCastNodeSetToBoolean(); 47073 test_ret += test_xmlXPathCastNodeSetToNumber(); 47074 test_ret += test_xmlXPathCastNodeSetToString(); 47075 test_ret += test_xmlXPathCastNodeToNumber(); 47076 test_ret += test_xmlXPathCastNodeToString(); 47077 test_ret += test_xmlXPathCastNumberToBoolean(); 47078 test_ret += test_xmlXPathCastNumberToString(); 47079 test_ret += test_xmlXPathCastStringToBoolean(); 47080 test_ret += test_xmlXPathCastStringToNumber(); 47081 test_ret += test_xmlXPathCastToBoolean(); 47082 test_ret += test_xmlXPathCastToNumber(); 47083 test_ret += test_xmlXPathCastToString(); 47084 test_ret += test_xmlXPathCmpNodes(); 47085 test_ret += test_xmlXPathCompile(); 47086 test_ret += test_xmlXPathCompiledEval(); 47087 test_ret += test_xmlXPathCompiledEvalToBoolean(); 47088 test_ret += test_xmlXPathContextSetCache(); 47089 test_ret += test_xmlXPathConvertBoolean(); 47090 test_ret += test_xmlXPathConvertNumber(); 47091 test_ret += test_xmlXPathConvertString(); 47092 test_ret += test_xmlXPathCtxtCompile(); 47093 test_ret += test_xmlXPathEval(); 47094 test_ret += test_xmlXPathEvalExpression(); 47095 test_ret += test_xmlXPathEvalPredicate(); 47096 test_ret += test_xmlXPathInit(); 47097 test_ret += test_xmlXPathIsInf(); 47098 test_ret += test_xmlXPathIsNaN(); 47099 test_ret += test_xmlXPathNewContext(); 47100 test_ret += test_xmlXPathNodeEval(); 47101 test_ret += test_xmlXPathNodeSetCreate(); 47102 test_ret += test_xmlXPathObjectCopy(); 47103 test_ret += test_xmlXPathOrderDocElems(); 47104 test_ret += test_xmlXPathSetContextNode(); 47105 47106 if (test_ret != 0) 47107 printf("Module xpath: %d errors\n", test_ret); 47108 return(test_ret); 47109 } 47110 #ifdef LIBXML_XPATH_ENABLED 47111 47112 #define gen_nb_xmlXPathParserContextPtr 1 47113 static xmlXPathParserContextPtr gen_xmlXPathParserContextPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 47114 return(NULL); 47115 } 47116 static void des_xmlXPathParserContextPtr(int no ATTRIBUTE_UNUSED, xmlXPathParserContextPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 47117 } 47118 #endif 47119 47120 47121 static int 47122 test_valuePop(void) { 47123 int test_ret = 0; 47124 47125 #if defined(LIBXML_XPATH_ENABLED) 47126 int mem_base; 47127 xmlXPathObjectPtr ret_val; 47128 xmlXPathParserContextPtr ctxt; /* an XPath evaluation context */ 47129 int n_ctxt; 47130 47131 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 47132 mem_base = xmlMemBlocks(); 47133 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 47134 47135 ret_val = valuePop(ctxt); 47136 desret_xmlXPathObjectPtr(ret_val); 47137 call_tests++; 47138 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 47139 xmlResetLastError(); 47140 if (mem_base != xmlMemBlocks()) { 47141 printf("Leak of %d blocks found in valuePop", 47142 xmlMemBlocks() - mem_base); 47143 test_ret++; 47144 printf(" %d", n_ctxt); 47145 printf("\n"); 47146 } 47147 } 47148 function_tests++; 47149 #endif 47150 47151 return(test_ret); 47152 } 47153 47154 47155 static int 47156 test_valuePush(void) { 47157 int test_ret = 0; 47158 47159 #if defined(LIBXML_XPATH_ENABLED) 47160 int mem_base; 47161 int ret_val; 47162 xmlXPathParserContextPtr ctxt; /* an XPath evaluation context */ 47163 int n_ctxt; 47164 xmlXPathObjectPtr value; /* the XPath object */ 47165 int n_value; 47166 47167 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 47168 for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) { 47169 mem_base = xmlMemBlocks(); 47170 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 47171 value = gen_xmlXPathObjectPtr(n_value, 1); 47172 47173 ret_val = valuePush(ctxt, value); 47174 desret_int(ret_val); 47175 call_tests++; 47176 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 47177 des_xmlXPathObjectPtr(n_value, value, 1); 47178 xmlResetLastError(); 47179 if (mem_base != xmlMemBlocks()) { 47180 printf("Leak of %d blocks found in valuePush", 47181 xmlMemBlocks() - mem_base); 47182 test_ret++; 47183 printf(" %d", n_ctxt); 47184 printf(" %d", n_value); 47185 printf("\n"); 47186 } 47187 } 47188 } 47189 function_tests++; 47190 #endif 47191 47192 return(test_ret); 47193 } 47194 47195 47196 static int 47197 test_xmlXPathAddValues(void) { 47198 int test_ret = 0; 47199 47200 #if defined(LIBXML_XPATH_ENABLED) 47201 int mem_base; 47202 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 47203 int n_ctxt; 47204 47205 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 47206 mem_base = xmlMemBlocks(); 47207 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 47208 47209 xmlXPathAddValues(ctxt); 47210 call_tests++; 47211 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 47212 xmlResetLastError(); 47213 if (mem_base != xmlMemBlocks()) { 47214 printf("Leak of %d blocks found in xmlXPathAddValues", 47215 xmlMemBlocks() - mem_base); 47216 test_ret++; 47217 printf(" %d", n_ctxt); 47218 printf("\n"); 47219 } 47220 } 47221 function_tests++; 47222 #endif 47223 47224 return(test_ret); 47225 } 47226 47227 47228 static int 47229 test_xmlXPathBooleanFunction(void) { 47230 int test_ret = 0; 47231 47232 #if defined(LIBXML_XPATH_ENABLED) 47233 int mem_base; 47234 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 47235 int n_ctxt; 47236 int nargs; /* the number of arguments */ 47237 int n_nargs; 47238 47239 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 47240 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 47241 mem_base = xmlMemBlocks(); 47242 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 47243 nargs = gen_int(n_nargs, 1); 47244 47245 xmlXPathBooleanFunction(ctxt, nargs); 47246 call_tests++; 47247 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 47248 des_int(n_nargs, nargs, 1); 47249 xmlResetLastError(); 47250 if (mem_base != xmlMemBlocks()) { 47251 printf("Leak of %d blocks found in xmlXPathBooleanFunction", 47252 xmlMemBlocks() - mem_base); 47253 test_ret++; 47254 printf(" %d", n_ctxt); 47255 printf(" %d", n_nargs); 47256 printf("\n"); 47257 } 47258 } 47259 } 47260 function_tests++; 47261 #endif 47262 47263 return(test_ret); 47264 } 47265 47266 47267 static int 47268 test_xmlXPathCeilingFunction(void) { 47269 int test_ret = 0; 47270 47271 #if defined(LIBXML_XPATH_ENABLED) 47272 int mem_base; 47273 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 47274 int n_ctxt; 47275 int nargs; /* the number of arguments */ 47276 int n_nargs; 47277 47278 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 47279 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 47280 mem_base = xmlMemBlocks(); 47281 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 47282 nargs = gen_int(n_nargs, 1); 47283 47284 xmlXPathCeilingFunction(ctxt, nargs); 47285 call_tests++; 47286 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 47287 des_int(n_nargs, nargs, 1); 47288 xmlResetLastError(); 47289 if (mem_base != xmlMemBlocks()) { 47290 printf("Leak of %d blocks found in xmlXPathCeilingFunction", 47291 xmlMemBlocks() - mem_base); 47292 test_ret++; 47293 printf(" %d", n_ctxt); 47294 printf(" %d", n_nargs); 47295 printf("\n"); 47296 } 47297 } 47298 } 47299 function_tests++; 47300 #endif 47301 47302 return(test_ret); 47303 } 47304 47305 47306 static int 47307 test_xmlXPathCompareValues(void) { 47308 int test_ret = 0; 47309 47310 #if defined(LIBXML_XPATH_ENABLED) 47311 int mem_base; 47312 int ret_val; 47313 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 47314 int n_ctxt; 47315 int inf; /* less than (1) or greater than (0) */ 47316 int n_inf; 47317 int strict; /* is the comparison strict */ 47318 int n_strict; 47319 47320 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 47321 for (n_inf = 0;n_inf < gen_nb_int;n_inf++) { 47322 for (n_strict = 0;n_strict < gen_nb_int;n_strict++) { 47323 mem_base = xmlMemBlocks(); 47324 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 47325 inf = gen_int(n_inf, 1); 47326 strict = gen_int(n_strict, 2); 47327 47328 ret_val = xmlXPathCompareValues(ctxt, inf, strict); 47329 desret_int(ret_val); 47330 call_tests++; 47331 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 47332 des_int(n_inf, inf, 1); 47333 des_int(n_strict, strict, 2); 47334 xmlResetLastError(); 47335 if (mem_base != xmlMemBlocks()) { 47336 printf("Leak of %d blocks found in xmlXPathCompareValues", 47337 xmlMemBlocks() - mem_base); 47338 test_ret++; 47339 printf(" %d", n_ctxt); 47340 printf(" %d", n_inf); 47341 printf(" %d", n_strict); 47342 printf("\n"); 47343 } 47344 } 47345 } 47346 } 47347 function_tests++; 47348 #endif 47349 47350 return(test_ret); 47351 } 47352 47353 47354 static int 47355 test_xmlXPathConcatFunction(void) { 47356 int test_ret = 0; 47357 47358 #if defined(LIBXML_XPATH_ENABLED) 47359 int mem_base; 47360 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 47361 int n_ctxt; 47362 int nargs; /* the number of arguments */ 47363 int n_nargs; 47364 47365 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 47366 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 47367 mem_base = xmlMemBlocks(); 47368 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 47369 nargs = gen_int(n_nargs, 1); 47370 47371 xmlXPathConcatFunction(ctxt, nargs); 47372 call_tests++; 47373 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 47374 des_int(n_nargs, nargs, 1); 47375 xmlResetLastError(); 47376 if (mem_base != xmlMemBlocks()) { 47377 printf("Leak of %d blocks found in xmlXPathConcatFunction", 47378 xmlMemBlocks() - mem_base); 47379 test_ret++; 47380 printf(" %d", n_ctxt); 47381 printf(" %d", n_nargs); 47382 printf("\n"); 47383 } 47384 } 47385 } 47386 function_tests++; 47387 #endif 47388 47389 return(test_ret); 47390 } 47391 47392 47393 static int 47394 test_xmlXPathContainsFunction(void) { 47395 int test_ret = 0; 47396 47397 #if defined(LIBXML_XPATH_ENABLED) 47398 int mem_base; 47399 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 47400 int n_ctxt; 47401 int nargs; /* the number of arguments */ 47402 int n_nargs; 47403 47404 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 47405 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 47406 mem_base = xmlMemBlocks(); 47407 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 47408 nargs = gen_int(n_nargs, 1); 47409 47410 xmlXPathContainsFunction(ctxt, nargs); 47411 call_tests++; 47412 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 47413 des_int(n_nargs, nargs, 1); 47414 xmlResetLastError(); 47415 if (mem_base != xmlMemBlocks()) { 47416 printf("Leak of %d blocks found in xmlXPathContainsFunction", 47417 xmlMemBlocks() - mem_base); 47418 test_ret++; 47419 printf(" %d", n_ctxt); 47420 printf(" %d", n_nargs); 47421 printf("\n"); 47422 } 47423 } 47424 } 47425 function_tests++; 47426 #endif 47427 47428 return(test_ret); 47429 } 47430 47431 47432 static int 47433 test_xmlXPathCountFunction(void) { 47434 int test_ret = 0; 47435 47436 #if defined(LIBXML_XPATH_ENABLED) 47437 int mem_base; 47438 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 47439 int n_ctxt; 47440 int nargs; /* the number of arguments */ 47441 int n_nargs; 47442 47443 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 47444 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 47445 mem_base = xmlMemBlocks(); 47446 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 47447 nargs = gen_int(n_nargs, 1); 47448 47449 xmlXPathCountFunction(ctxt, nargs); 47450 call_tests++; 47451 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 47452 des_int(n_nargs, nargs, 1); 47453 xmlResetLastError(); 47454 if (mem_base != xmlMemBlocks()) { 47455 printf("Leak of %d blocks found in xmlXPathCountFunction", 47456 xmlMemBlocks() - mem_base); 47457 test_ret++; 47458 printf(" %d", n_ctxt); 47459 printf(" %d", n_nargs); 47460 printf("\n"); 47461 } 47462 } 47463 } 47464 function_tests++; 47465 #endif 47466 47467 return(test_ret); 47468 } 47469 47470 47471 static int 47472 test_xmlXPathDebugDumpCompExpr(void) { 47473 int test_ret = 0; 47474 47475 #if defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_DEBUG_ENABLED) 47476 int mem_base; 47477 FILE * output; /* the FILE * for the output */ 47478 int n_output; 47479 xmlXPathCompExprPtr comp; /* the precompiled XPath expression */ 47480 int n_comp; 47481 int depth; /* the indentation level. */ 47482 int n_depth; 47483 47484 for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) { 47485 for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) { 47486 for (n_depth = 0;n_depth < gen_nb_int;n_depth++) { 47487 mem_base = xmlMemBlocks(); 47488 output = gen_FILE_ptr(n_output, 0); 47489 comp = gen_xmlXPathCompExprPtr(n_comp, 1); 47490 depth = gen_int(n_depth, 2); 47491 47492 xmlXPathDebugDumpCompExpr(output, comp, depth); 47493 call_tests++; 47494 des_FILE_ptr(n_output, output, 0); 47495 des_xmlXPathCompExprPtr(n_comp, comp, 1); 47496 des_int(n_depth, depth, 2); 47497 xmlResetLastError(); 47498 if (mem_base != xmlMemBlocks()) { 47499 printf("Leak of %d blocks found in xmlXPathDebugDumpCompExpr", 47500 xmlMemBlocks() - mem_base); 47501 test_ret++; 47502 printf(" %d", n_output); 47503 printf(" %d", n_comp); 47504 printf(" %d", n_depth); 47505 printf("\n"); 47506 } 47507 } 47508 } 47509 } 47510 function_tests++; 47511 #endif 47512 47513 return(test_ret); 47514 } 47515 47516 47517 static int 47518 test_xmlXPathDebugDumpObject(void) { 47519 int test_ret = 0; 47520 47521 #if defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_DEBUG_ENABLED) 47522 int mem_base; 47523 FILE * output; /* the FILE * to dump the output */ 47524 int n_output; 47525 xmlXPathObjectPtr cur; /* the object to inspect */ 47526 int n_cur; 47527 int depth; /* indentation level */ 47528 int n_depth; 47529 47530 for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) { 47531 for (n_cur = 0;n_cur < gen_nb_xmlXPathObjectPtr;n_cur++) { 47532 for (n_depth = 0;n_depth < gen_nb_int;n_depth++) { 47533 mem_base = xmlMemBlocks(); 47534 output = gen_FILE_ptr(n_output, 0); 47535 cur = gen_xmlXPathObjectPtr(n_cur, 1); 47536 depth = gen_int(n_depth, 2); 47537 47538 xmlXPathDebugDumpObject(output, cur, depth); 47539 call_tests++; 47540 des_FILE_ptr(n_output, output, 0); 47541 des_xmlXPathObjectPtr(n_cur, cur, 1); 47542 des_int(n_depth, depth, 2); 47543 xmlResetLastError(); 47544 if (mem_base != xmlMemBlocks()) { 47545 printf("Leak of %d blocks found in xmlXPathDebugDumpObject", 47546 xmlMemBlocks() - mem_base); 47547 test_ret++; 47548 printf(" %d", n_output); 47549 printf(" %d", n_cur); 47550 printf(" %d", n_depth); 47551 printf("\n"); 47552 } 47553 } 47554 } 47555 } 47556 function_tests++; 47557 #endif 47558 47559 return(test_ret); 47560 } 47561 47562 47563 static int 47564 test_xmlXPathDifference(void) { 47565 int test_ret = 0; 47566 47567 #if defined(LIBXML_XPATH_ENABLED) 47568 int mem_base; 47569 xmlNodeSetPtr ret_val; 47570 xmlNodeSetPtr nodes1; /* a node-set */ 47571 int n_nodes1; 47572 xmlNodeSetPtr nodes2; /* a node-set */ 47573 int n_nodes2; 47574 47575 for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) { 47576 for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) { 47577 mem_base = xmlMemBlocks(); 47578 nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0); 47579 nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1); 47580 47581 ret_val = xmlXPathDifference(nodes1, nodes2); 47582 desret_xmlNodeSetPtr(ret_val); 47583 call_tests++; 47584 des_xmlNodeSetPtr(n_nodes1, nodes1, 0); 47585 des_xmlNodeSetPtr(n_nodes2, nodes2, 1); 47586 xmlResetLastError(); 47587 if (mem_base != xmlMemBlocks()) { 47588 printf("Leak of %d blocks found in xmlXPathDifference", 47589 xmlMemBlocks() - mem_base); 47590 test_ret++; 47591 printf(" %d", n_nodes1); 47592 printf(" %d", n_nodes2); 47593 printf("\n"); 47594 } 47595 } 47596 } 47597 function_tests++; 47598 #endif 47599 47600 return(test_ret); 47601 } 47602 47603 47604 static int 47605 test_xmlXPathDistinct(void) { 47606 int test_ret = 0; 47607 47608 #if defined(LIBXML_XPATH_ENABLED) 47609 int mem_base; 47610 xmlNodeSetPtr ret_val; 47611 xmlNodeSetPtr nodes; /* a node-set */ 47612 int n_nodes; 47613 47614 for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) { 47615 mem_base = xmlMemBlocks(); 47616 nodes = gen_xmlNodeSetPtr(n_nodes, 0); 47617 47618 ret_val = xmlXPathDistinct(nodes); 47619 desret_xmlNodeSetPtr(ret_val); 47620 call_tests++; 47621 des_xmlNodeSetPtr(n_nodes, nodes, 0); 47622 xmlResetLastError(); 47623 if (mem_base != xmlMemBlocks()) { 47624 printf("Leak of %d blocks found in xmlXPathDistinct", 47625 xmlMemBlocks() - mem_base); 47626 test_ret++; 47627 printf(" %d", n_nodes); 47628 printf("\n"); 47629 } 47630 } 47631 function_tests++; 47632 #endif 47633 47634 return(test_ret); 47635 } 47636 47637 47638 static int 47639 test_xmlXPathDistinctSorted(void) { 47640 int test_ret = 0; 47641 47642 #if defined(LIBXML_XPATH_ENABLED) 47643 int mem_base; 47644 xmlNodeSetPtr ret_val; 47645 xmlNodeSetPtr nodes; /* a node-set, sorted by document order */ 47646 int n_nodes; 47647 47648 for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) { 47649 mem_base = xmlMemBlocks(); 47650 nodes = gen_xmlNodeSetPtr(n_nodes, 0); 47651 47652 ret_val = xmlXPathDistinctSorted(nodes); 47653 desret_xmlNodeSetPtr(ret_val); 47654 call_tests++; 47655 des_xmlNodeSetPtr(n_nodes, nodes, 0); 47656 xmlResetLastError(); 47657 if (mem_base != xmlMemBlocks()) { 47658 printf("Leak of %d blocks found in xmlXPathDistinctSorted", 47659 xmlMemBlocks() - mem_base); 47660 test_ret++; 47661 printf(" %d", n_nodes); 47662 printf("\n"); 47663 } 47664 } 47665 function_tests++; 47666 #endif 47667 47668 return(test_ret); 47669 } 47670 47671 47672 static int 47673 test_xmlXPathDivValues(void) { 47674 int test_ret = 0; 47675 47676 #if defined(LIBXML_XPATH_ENABLED) 47677 int mem_base; 47678 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 47679 int n_ctxt; 47680 47681 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 47682 mem_base = xmlMemBlocks(); 47683 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 47684 47685 xmlXPathDivValues(ctxt); 47686 call_tests++; 47687 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 47688 xmlResetLastError(); 47689 if (mem_base != xmlMemBlocks()) { 47690 printf("Leak of %d blocks found in xmlXPathDivValues", 47691 xmlMemBlocks() - mem_base); 47692 test_ret++; 47693 printf(" %d", n_ctxt); 47694 printf("\n"); 47695 } 47696 } 47697 function_tests++; 47698 #endif 47699 47700 return(test_ret); 47701 } 47702 47703 47704 static int 47705 test_xmlXPathEqualValues(void) { 47706 int test_ret = 0; 47707 47708 #if defined(LIBXML_XPATH_ENABLED) 47709 int mem_base; 47710 int ret_val; 47711 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 47712 int n_ctxt; 47713 47714 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 47715 mem_base = xmlMemBlocks(); 47716 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 47717 47718 ret_val = xmlXPathEqualValues(ctxt); 47719 desret_int(ret_val); 47720 call_tests++; 47721 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 47722 xmlResetLastError(); 47723 if (mem_base != xmlMemBlocks()) { 47724 printf("Leak of %d blocks found in xmlXPathEqualValues", 47725 xmlMemBlocks() - mem_base); 47726 test_ret++; 47727 printf(" %d", n_ctxt); 47728 printf("\n"); 47729 } 47730 } 47731 function_tests++; 47732 #endif 47733 47734 return(test_ret); 47735 } 47736 47737 47738 static int 47739 test_xmlXPathErr(void) { 47740 int test_ret = 0; 47741 47742 #if defined(LIBXML_XPATH_ENABLED) 47743 int mem_base; 47744 xmlXPathParserContextPtr ctxt; /* a XPath parser context */ 47745 int n_ctxt; 47746 int error; /* the error code */ 47747 int n_error; 47748 47749 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 47750 for (n_error = 0;n_error < gen_nb_int;n_error++) { 47751 mem_base = xmlMemBlocks(); 47752 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 47753 error = gen_int(n_error, 1); 47754 47755 xmlXPathErr(ctxt, error); 47756 call_tests++; 47757 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 47758 des_int(n_error, error, 1); 47759 xmlResetLastError(); 47760 if (mem_base != xmlMemBlocks()) { 47761 printf("Leak of %d blocks found in xmlXPathErr", 47762 xmlMemBlocks() - mem_base); 47763 test_ret++; 47764 printf(" %d", n_ctxt); 47765 printf(" %d", n_error); 47766 printf("\n"); 47767 } 47768 } 47769 } 47770 function_tests++; 47771 #endif 47772 47773 return(test_ret); 47774 } 47775 47776 47777 static int 47778 test_xmlXPathEvalExpr(void) { 47779 int test_ret = 0; 47780 47781 #if defined(LIBXML_XPATH_ENABLED) 47782 int mem_base; 47783 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 47784 int n_ctxt; 47785 47786 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 47787 mem_base = xmlMemBlocks(); 47788 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 47789 47790 xmlXPathEvalExpr(ctxt); 47791 call_tests++; 47792 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 47793 xmlResetLastError(); 47794 if (mem_base != xmlMemBlocks()) { 47795 printf("Leak of %d blocks found in xmlXPathEvalExpr", 47796 xmlMemBlocks() - mem_base); 47797 test_ret++; 47798 printf(" %d", n_ctxt); 47799 printf("\n"); 47800 } 47801 } 47802 function_tests++; 47803 #endif 47804 47805 return(test_ret); 47806 } 47807 47808 47809 static int 47810 test_xmlXPathEvaluatePredicateResult(void) { 47811 int test_ret = 0; 47812 47813 #if defined(LIBXML_XPATH_ENABLED) 47814 int mem_base; 47815 int ret_val; 47816 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 47817 int n_ctxt; 47818 xmlXPathObjectPtr res; /* the Predicate Expression evaluation result */ 47819 int n_res; 47820 47821 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 47822 for (n_res = 0;n_res < gen_nb_xmlXPathObjectPtr;n_res++) { 47823 mem_base = xmlMemBlocks(); 47824 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 47825 res = gen_xmlXPathObjectPtr(n_res, 1); 47826 47827 ret_val = xmlXPathEvaluatePredicateResult(ctxt, res); 47828 desret_int(ret_val); 47829 call_tests++; 47830 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 47831 des_xmlXPathObjectPtr(n_res, res, 1); 47832 xmlResetLastError(); 47833 if (mem_base != xmlMemBlocks()) { 47834 printf("Leak of %d blocks found in xmlXPathEvaluatePredicateResult", 47835 xmlMemBlocks() - mem_base); 47836 test_ret++; 47837 printf(" %d", n_ctxt); 47838 printf(" %d", n_res); 47839 printf("\n"); 47840 } 47841 } 47842 } 47843 function_tests++; 47844 #endif 47845 47846 return(test_ret); 47847 } 47848 47849 47850 static int 47851 test_xmlXPathFalseFunction(void) { 47852 int test_ret = 0; 47853 47854 #if defined(LIBXML_XPATH_ENABLED) 47855 int mem_base; 47856 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 47857 int n_ctxt; 47858 int nargs; /* the number of arguments */ 47859 int n_nargs; 47860 47861 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 47862 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 47863 mem_base = xmlMemBlocks(); 47864 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 47865 nargs = gen_int(n_nargs, 1); 47866 47867 xmlXPathFalseFunction(ctxt, nargs); 47868 call_tests++; 47869 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 47870 des_int(n_nargs, nargs, 1); 47871 xmlResetLastError(); 47872 if (mem_base != xmlMemBlocks()) { 47873 printf("Leak of %d blocks found in xmlXPathFalseFunction", 47874 xmlMemBlocks() - mem_base); 47875 test_ret++; 47876 printf(" %d", n_ctxt); 47877 printf(" %d", n_nargs); 47878 printf("\n"); 47879 } 47880 } 47881 } 47882 function_tests++; 47883 #endif 47884 47885 return(test_ret); 47886 } 47887 47888 47889 static int 47890 test_xmlXPathFloorFunction(void) { 47891 int test_ret = 0; 47892 47893 #if defined(LIBXML_XPATH_ENABLED) 47894 int mem_base; 47895 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 47896 int n_ctxt; 47897 int nargs; /* the number of arguments */ 47898 int n_nargs; 47899 47900 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 47901 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 47902 mem_base = xmlMemBlocks(); 47903 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 47904 nargs = gen_int(n_nargs, 1); 47905 47906 xmlXPathFloorFunction(ctxt, nargs); 47907 call_tests++; 47908 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 47909 des_int(n_nargs, nargs, 1); 47910 xmlResetLastError(); 47911 if (mem_base != xmlMemBlocks()) { 47912 printf("Leak of %d blocks found in xmlXPathFloorFunction", 47913 xmlMemBlocks() - mem_base); 47914 test_ret++; 47915 printf(" %d", n_ctxt); 47916 printf(" %d", n_nargs); 47917 printf("\n"); 47918 } 47919 } 47920 } 47921 function_tests++; 47922 #endif 47923 47924 return(test_ret); 47925 } 47926 47927 47928 static int 47929 test_xmlXPathFunctionLookup(void) { 47930 int test_ret = 0; 47931 47932 47933 /* missing type support */ 47934 return(test_ret); 47935 } 47936 47937 47938 static int 47939 test_xmlXPathFunctionLookupNS(void) { 47940 int test_ret = 0; 47941 47942 47943 /* missing type support */ 47944 return(test_ret); 47945 } 47946 47947 47948 static int 47949 test_xmlXPathHasSameNodes(void) { 47950 int test_ret = 0; 47951 47952 #if defined(LIBXML_XPATH_ENABLED) 47953 int mem_base; 47954 int ret_val; 47955 xmlNodeSetPtr nodes1; /* a node-set */ 47956 int n_nodes1; 47957 xmlNodeSetPtr nodes2; /* a node-set */ 47958 int n_nodes2; 47959 47960 for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) { 47961 for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) { 47962 mem_base = xmlMemBlocks(); 47963 nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0); 47964 nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1); 47965 47966 ret_val = xmlXPathHasSameNodes(nodes1, nodes2); 47967 desret_int(ret_val); 47968 call_tests++; 47969 des_xmlNodeSetPtr(n_nodes1, nodes1, 0); 47970 des_xmlNodeSetPtr(n_nodes2, nodes2, 1); 47971 xmlResetLastError(); 47972 if (mem_base != xmlMemBlocks()) { 47973 printf("Leak of %d blocks found in xmlXPathHasSameNodes", 47974 xmlMemBlocks() - mem_base); 47975 test_ret++; 47976 printf(" %d", n_nodes1); 47977 printf(" %d", n_nodes2); 47978 printf("\n"); 47979 } 47980 } 47981 } 47982 function_tests++; 47983 #endif 47984 47985 return(test_ret); 47986 } 47987 47988 47989 static int 47990 test_xmlXPathIdFunction(void) { 47991 int test_ret = 0; 47992 47993 #if defined(LIBXML_XPATH_ENABLED) 47994 int mem_base; 47995 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 47996 int n_ctxt; 47997 int nargs; /* the number of arguments */ 47998 int n_nargs; 47999 48000 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 48001 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 48002 mem_base = xmlMemBlocks(); 48003 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 48004 nargs = gen_int(n_nargs, 1); 48005 48006 xmlXPathIdFunction(ctxt, nargs); 48007 call_tests++; 48008 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 48009 des_int(n_nargs, nargs, 1); 48010 xmlResetLastError(); 48011 if (mem_base != xmlMemBlocks()) { 48012 printf("Leak of %d blocks found in xmlXPathIdFunction", 48013 xmlMemBlocks() - mem_base); 48014 test_ret++; 48015 printf(" %d", n_ctxt); 48016 printf(" %d", n_nargs); 48017 printf("\n"); 48018 } 48019 } 48020 } 48021 function_tests++; 48022 #endif 48023 48024 return(test_ret); 48025 } 48026 48027 48028 static int 48029 test_xmlXPathIntersection(void) { 48030 int test_ret = 0; 48031 48032 #if defined(LIBXML_XPATH_ENABLED) 48033 int mem_base; 48034 xmlNodeSetPtr ret_val; 48035 xmlNodeSetPtr nodes1; /* a node-set */ 48036 int n_nodes1; 48037 xmlNodeSetPtr nodes2; /* a node-set */ 48038 int n_nodes2; 48039 48040 for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) { 48041 for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) { 48042 mem_base = xmlMemBlocks(); 48043 nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0); 48044 nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1); 48045 48046 ret_val = xmlXPathIntersection(nodes1, nodes2); 48047 desret_xmlNodeSetPtr(ret_val); 48048 call_tests++; 48049 des_xmlNodeSetPtr(n_nodes1, nodes1, 0); 48050 des_xmlNodeSetPtr(n_nodes2, nodes2, 1); 48051 xmlResetLastError(); 48052 if (mem_base != xmlMemBlocks()) { 48053 printf("Leak of %d blocks found in xmlXPathIntersection", 48054 xmlMemBlocks() - mem_base); 48055 test_ret++; 48056 printf(" %d", n_nodes1); 48057 printf(" %d", n_nodes2); 48058 printf("\n"); 48059 } 48060 } 48061 } 48062 function_tests++; 48063 #endif 48064 48065 return(test_ret); 48066 } 48067 48068 48069 static int 48070 test_xmlXPathIsNodeType(void) { 48071 int test_ret = 0; 48072 48073 #if defined(LIBXML_XPATH_ENABLED) 48074 int mem_base; 48075 int ret_val; 48076 xmlChar * name; /* a name string */ 48077 int n_name; 48078 48079 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 48080 mem_base = xmlMemBlocks(); 48081 name = gen_const_xmlChar_ptr(n_name, 0); 48082 48083 ret_val = xmlXPathIsNodeType((const xmlChar *)name); 48084 desret_int(ret_val); 48085 call_tests++; 48086 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0); 48087 xmlResetLastError(); 48088 if (mem_base != xmlMemBlocks()) { 48089 printf("Leak of %d blocks found in xmlXPathIsNodeType", 48090 xmlMemBlocks() - mem_base); 48091 test_ret++; 48092 printf(" %d", n_name); 48093 printf("\n"); 48094 } 48095 } 48096 function_tests++; 48097 #endif 48098 48099 return(test_ret); 48100 } 48101 48102 48103 static int 48104 test_xmlXPathLangFunction(void) { 48105 int test_ret = 0; 48106 48107 #if defined(LIBXML_XPATH_ENABLED) 48108 int mem_base; 48109 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 48110 int n_ctxt; 48111 int nargs; /* the number of arguments */ 48112 int n_nargs; 48113 48114 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 48115 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 48116 mem_base = xmlMemBlocks(); 48117 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 48118 nargs = gen_int(n_nargs, 1); 48119 48120 xmlXPathLangFunction(ctxt, nargs); 48121 call_tests++; 48122 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 48123 des_int(n_nargs, nargs, 1); 48124 xmlResetLastError(); 48125 if (mem_base != xmlMemBlocks()) { 48126 printf("Leak of %d blocks found in xmlXPathLangFunction", 48127 xmlMemBlocks() - mem_base); 48128 test_ret++; 48129 printf(" %d", n_ctxt); 48130 printf(" %d", n_nargs); 48131 printf("\n"); 48132 } 48133 } 48134 } 48135 function_tests++; 48136 #endif 48137 48138 return(test_ret); 48139 } 48140 48141 48142 static int 48143 test_xmlXPathLastFunction(void) { 48144 int test_ret = 0; 48145 48146 #if defined(LIBXML_XPATH_ENABLED) 48147 int mem_base; 48148 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 48149 int n_ctxt; 48150 int nargs; /* the number of arguments */ 48151 int n_nargs; 48152 48153 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 48154 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 48155 mem_base = xmlMemBlocks(); 48156 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 48157 nargs = gen_int(n_nargs, 1); 48158 48159 xmlXPathLastFunction(ctxt, nargs); 48160 call_tests++; 48161 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 48162 des_int(n_nargs, nargs, 1); 48163 xmlResetLastError(); 48164 if (mem_base != xmlMemBlocks()) { 48165 printf("Leak of %d blocks found in xmlXPathLastFunction", 48166 xmlMemBlocks() - mem_base); 48167 test_ret++; 48168 printf(" %d", n_ctxt); 48169 printf(" %d", n_nargs); 48170 printf("\n"); 48171 } 48172 } 48173 } 48174 function_tests++; 48175 #endif 48176 48177 return(test_ret); 48178 } 48179 48180 48181 static int 48182 test_xmlXPathLeading(void) { 48183 int test_ret = 0; 48184 48185 #if defined(LIBXML_XPATH_ENABLED) 48186 int mem_base; 48187 xmlNodeSetPtr ret_val; 48188 xmlNodeSetPtr nodes1; /* a node-set */ 48189 int n_nodes1; 48190 xmlNodeSetPtr nodes2; /* a node-set */ 48191 int n_nodes2; 48192 48193 for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) { 48194 for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) { 48195 mem_base = xmlMemBlocks(); 48196 nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0); 48197 nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1); 48198 48199 ret_val = xmlXPathLeading(nodes1, nodes2); 48200 desret_xmlNodeSetPtr(ret_val); 48201 call_tests++; 48202 des_xmlNodeSetPtr(n_nodes1, nodes1, 0); 48203 des_xmlNodeSetPtr(n_nodes2, nodes2, 1); 48204 xmlResetLastError(); 48205 if (mem_base != xmlMemBlocks()) { 48206 printf("Leak of %d blocks found in xmlXPathLeading", 48207 xmlMemBlocks() - mem_base); 48208 test_ret++; 48209 printf(" %d", n_nodes1); 48210 printf(" %d", n_nodes2); 48211 printf("\n"); 48212 } 48213 } 48214 } 48215 function_tests++; 48216 #endif 48217 48218 return(test_ret); 48219 } 48220 48221 48222 static int 48223 test_xmlXPathLeadingSorted(void) { 48224 int test_ret = 0; 48225 48226 #if defined(LIBXML_XPATH_ENABLED) 48227 int mem_base; 48228 xmlNodeSetPtr ret_val; 48229 xmlNodeSetPtr nodes1; /* a node-set, sorted by document order */ 48230 int n_nodes1; 48231 xmlNodeSetPtr nodes2; /* a node-set, sorted by document order */ 48232 int n_nodes2; 48233 48234 for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) { 48235 for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) { 48236 mem_base = xmlMemBlocks(); 48237 nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0); 48238 nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1); 48239 48240 ret_val = xmlXPathLeadingSorted(nodes1, nodes2); 48241 desret_xmlNodeSetPtr(ret_val); 48242 call_tests++; 48243 des_xmlNodeSetPtr(n_nodes1, nodes1, 0); 48244 des_xmlNodeSetPtr(n_nodes2, nodes2, 1); 48245 xmlResetLastError(); 48246 if (mem_base != xmlMemBlocks()) { 48247 printf("Leak of %d blocks found in xmlXPathLeadingSorted", 48248 xmlMemBlocks() - mem_base); 48249 test_ret++; 48250 printf(" %d", n_nodes1); 48251 printf(" %d", n_nodes2); 48252 printf("\n"); 48253 } 48254 } 48255 } 48256 function_tests++; 48257 #endif 48258 48259 return(test_ret); 48260 } 48261 48262 48263 static int 48264 test_xmlXPathLocalNameFunction(void) { 48265 int test_ret = 0; 48266 48267 #if defined(LIBXML_XPATH_ENABLED) 48268 int mem_base; 48269 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 48270 int n_ctxt; 48271 int nargs; /* the number of arguments */ 48272 int n_nargs; 48273 48274 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 48275 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 48276 mem_base = xmlMemBlocks(); 48277 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 48278 nargs = gen_int(n_nargs, 1); 48279 48280 xmlXPathLocalNameFunction(ctxt, nargs); 48281 call_tests++; 48282 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 48283 des_int(n_nargs, nargs, 1); 48284 xmlResetLastError(); 48285 if (mem_base != xmlMemBlocks()) { 48286 printf("Leak of %d blocks found in xmlXPathLocalNameFunction", 48287 xmlMemBlocks() - mem_base); 48288 test_ret++; 48289 printf(" %d", n_ctxt); 48290 printf(" %d", n_nargs); 48291 printf("\n"); 48292 } 48293 } 48294 } 48295 function_tests++; 48296 #endif 48297 48298 return(test_ret); 48299 } 48300 48301 48302 static int 48303 test_xmlXPathModValues(void) { 48304 int test_ret = 0; 48305 48306 #if defined(LIBXML_XPATH_ENABLED) 48307 int mem_base; 48308 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 48309 int n_ctxt; 48310 48311 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 48312 mem_base = xmlMemBlocks(); 48313 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 48314 48315 xmlXPathModValues(ctxt); 48316 call_tests++; 48317 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 48318 xmlResetLastError(); 48319 if (mem_base != xmlMemBlocks()) { 48320 printf("Leak of %d blocks found in xmlXPathModValues", 48321 xmlMemBlocks() - mem_base); 48322 test_ret++; 48323 printf(" %d", n_ctxt); 48324 printf("\n"); 48325 } 48326 } 48327 function_tests++; 48328 #endif 48329 48330 return(test_ret); 48331 } 48332 48333 48334 static int 48335 test_xmlXPathMultValues(void) { 48336 int test_ret = 0; 48337 48338 #if defined(LIBXML_XPATH_ENABLED) 48339 int mem_base; 48340 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 48341 int n_ctxt; 48342 48343 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 48344 mem_base = xmlMemBlocks(); 48345 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 48346 48347 xmlXPathMultValues(ctxt); 48348 call_tests++; 48349 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 48350 xmlResetLastError(); 48351 if (mem_base != xmlMemBlocks()) { 48352 printf("Leak of %d blocks found in xmlXPathMultValues", 48353 xmlMemBlocks() - mem_base); 48354 test_ret++; 48355 printf(" %d", n_ctxt); 48356 printf("\n"); 48357 } 48358 } 48359 function_tests++; 48360 #endif 48361 48362 return(test_ret); 48363 } 48364 48365 48366 static int 48367 test_xmlXPathNamespaceURIFunction(void) { 48368 int test_ret = 0; 48369 48370 #if defined(LIBXML_XPATH_ENABLED) 48371 int mem_base; 48372 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 48373 int n_ctxt; 48374 int nargs; /* the number of arguments */ 48375 int n_nargs; 48376 48377 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 48378 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 48379 mem_base = xmlMemBlocks(); 48380 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 48381 nargs = gen_int(n_nargs, 1); 48382 48383 xmlXPathNamespaceURIFunction(ctxt, nargs); 48384 call_tests++; 48385 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 48386 des_int(n_nargs, nargs, 1); 48387 xmlResetLastError(); 48388 if (mem_base != xmlMemBlocks()) { 48389 printf("Leak of %d blocks found in xmlXPathNamespaceURIFunction", 48390 xmlMemBlocks() - mem_base); 48391 test_ret++; 48392 printf(" %d", n_ctxt); 48393 printf(" %d", n_nargs); 48394 printf("\n"); 48395 } 48396 } 48397 } 48398 function_tests++; 48399 #endif 48400 48401 return(test_ret); 48402 } 48403 48404 48405 static int 48406 test_xmlXPathNewBoolean(void) { 48407 int test_ret = 0; 48408 48409 #if defined(LIBXML_XPATH_ENABLED) 48410 int mem_base; 48411 xmlXPathObjectPtr ret_val; 48412 int val; /* the boolean value */ 48413 int n_val; 48414 48415 for (n_val = 0;n_val < gen_nb_int;n_val++) { 48416 mem_base = xmlMemBlocks(); 48417 val = gen_int(n_val, 0); 48418 48419 ret_val = xmlXPathNewBoolean(val); 48420 desret_xmlXPathObjectPtr(ret_val); 48421 call_tests++; 48422 des_int(n_val, val, 0); 48423 xmlResetLastError(); 48424 if (mem_base != xmlMemBlocks()) { 48425 printf("Leak of %d blocks found in xmlXPathNewBoolean", 48426 xmlMemBlocks() - mem_base); 48427 test_ret++; 48428 printf(" %d", n_val); 48429 printf("\n"); 48430 } 48431 } 48432 function_tests++; 48433 #endif 48434 48435 return(test_ret); 48436 } 48437 48438 48439 static int 48440 test_xmlXPathNewCString(void) { 48441 int test_ret = 0; 48442 48443 #if defined(LIBXML_XPATH_ENABLED) 48444 int mem_base; 48445 xmlXPathObjectPtr ret_val; 48446 char * val; /* the char * value */ 48447 int n_val; 48448 48449 for (n_val = 0;n_val < gen_nb_const_char_ptr;n_val++) { 48450 mem_base = xmlMemBlocks(); 48451 val = gen_const_char_ptr(n_val, 0); 48452 48453 ret_val = xmlXPathNewCString((const char *)val); 48454 desret_xmlXPathObjectPtr(ret_val); 48455 call_tests++; 48456 des_const_char_ptr(n_val, (const char *)val, 0); 48457 xmlResetLastError(); 48458 if (mem_base != xmlMemBlocks()) { 48459 printf("Leak of %d blocks found in xmlXPathNewCString", 48460 xmlMemBlocks() - mem_base); 48461 test_ret++; 48462 printf(" %d", n_val); 48463 printf("\n"); 48464 } 48465 } 48466 function_tests++; 48467 #endif 48468 48469 return(test_ret); 48470 } 48471 48472 48473 static int 48474 test_xmlXPathNewFloat(void) { 48475 int test_ret = 0; 48476 48477 #if defined(LIBXML_XPATH_ENABLED) 48478 int mem_base; 48479 xmlXPathObjectPtr ret_val; 48480 double val; /* the double value */ 48481 int n_val; 48482 48483 for (n_val = 0;n_val < gen_nb_double;n_val++) { 48484 mem_base = xmlMemBlocks(); 48485 val = gen_double(n_val, 0); 48486 48487 ret_val = xmlXPathNewFloat(val); 48488 desret_xmlXPathObjectPtr(ret_val); 48489 call_tests++; 48490 des_double(n_val, val, 0); 48491 xmlResetLastError(); 48492 if (mem_base != xmlMemBlocks()) { 48493 printf("Leak of %d blocks found in xmlXPathNewFloat", 48494 xmlMemBlocks() - mem_base); 48495 test_ret++; 48496 printf(" %d", n_val); 48497 printf("\n"); 48498 } 48499 } 48500 function_tests++; 48501 #endif 48502 48503 return(test_ret); 48504 } 48505 48506 48507 static int 48508 test_xmlXPathNewNodeSet(void) { 48509 int test_ret = 0; 48510 48511 #if defined(LIBXML_XPATH_ENABLED) 48512 int mem_base; 48513 xmlXPathObjectPtr ret_val; 48514 xmlNodePtr val; /* the NodePtr value */ 48515 int n_val; 48516 48517 for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) { 48518 mem_base = xmlMemBlocks(); 48519 val = gen_xmlNodePtr(n_val, 0); 48520 48521 ret_val = xmlXPathNewNodeSet(val); 48522 desret_xmlXPathObjectPtr(ret_val); 48523 call_tests++; 48524 des_xmlNodePtr(n_val, val, 0); 48525 xmlResetLastError(); 48526 if (mem_base != xmlMemBlocks()) { 48527 printf("Leak of %d blocks found in xmlXPathNewNodeSet", 48528 xmlMemBlocks() - mem_base); 48529 test_ret++; 48530 printf(" %d", n_val); 48531 printf("\n"); 48532 } 48533 } 48534 function_tests++; 48535 #endif 48536 48537 return(test_ret); 48538 } 48539 48540 48541 static int 48542 test_xmlXPathNewNodeSetList(void) { 48543 int test_ret = 0; 48544 48545 #if defined(LIBXML_XPATH_ENABLED) 48546 int mem_base; 48547 xmlXPathObjectPtr ret_val; 48548 xmlNodeSetPtr val; /* an existing NodeSet */ 48549 int n_val; 48550 48551 for (n_val = 0;n_val < gen_nb_xmlNodeSetPtr;n_val++) { 48552 mem_base = xmlMemBlocks(); 48553 val = gen_xmlNodeSetPtr(n_val, 0); 48554 48555 ret_val = xmlXPathNewNodeSetList(val); 48556 desret_xmlXPathObjectPtr(ret_val); 48557 call_tests++; 48558 des_xmlNodeSetPtr(n_val, val, 0); 48559 xmlResetLastError(); 48560 if (mem_base != xmlMemBlocks()) { 48561 printf("Leak of %d blocks found in xmlXPathNewNodeSetList", 48562 xmlMemBlocks() - mem_base); 48563 test_ret++; 48564 printf(" %d", n_val); 48565 printf("\n"); 48566 } 48567 } 48568 function_tests++; 48569 #endif 48570 48571 return(test_ret); 48572 } 48573 48574 48575 static int 48576 test_xmlXPathNewParserContext(void) { 48577 int test_ret = 0; 48578 48579 48580 /* missing type support */ 48581 return(test_ret); 48582 } 48583 48584 48585 static int 48586 test_xmlXPathNewString(void) { 48587 int test_ret = 0; 48588 48589 #if defined(LIBXML_XPATH_ENABLED) 48590 int mem_base; 48591 xmlXPathObjectPtr ret_val; 48592 xmlChar * val; /* the xmlChar * value */ 48593 int n_val; 48594 48595 for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) { 48596 mem_base = xmlMemBlocks(); 48597 val = gen_const_xmlChar_ptr(n_val, 0); 48598 48599 ret_val = xmlXPathNewString((const xmlChar *)val); 48600 desret_xmlXPathObjectPtr(ret_val); 48601 call_tests++; 48602 des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 0); 48603 xmlResetLastError(); 48604 if (mem_base != xmlMemBlocks()) { 48605 printf("Leak of %d blocks found in xmlXPathNewString", 48606 xmlMemBlocks() - mem_base); 48607 test_ret++; 48608 printf(" %d", n_val); 48609 printf("\n"); 48610 } 48611 } 48612 function_tests++; 48613 #endif 48614 48615 return(test_ret); 48616 } 48617 48618 48619 static int 48620 test_xmlXPathNextAncestor(void) { 48621 int test_ret = 0; 48622 48623 #if defined(LIBXML_XPATH_ENABLED) 48624 int mem_base; 48625 xmlNodePtr ret_val; 48626 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 48627 int n_ctxt; 48628 xmlNodePtr cur; /* the current node in the traversal */ 48629 int n_cur; 48630 48631 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 48632 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 48633 mem_base = xmlMemBlocks(); 48634 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 48635 cur = gen_xmlNodePtr(n_cur, 1); 48636 48637 ret_val = xmlXPathNextAncestor(ctxt, cur); 48638 desret_xmlNodePtr(ret_val); 48639 call_tests++; 48640 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 48641 des_xmlNodePtr(n_cur, cur, 1); 48642 xmlResetLastError(); 48643 if (mem_base != xmlMemBlocks()) { 48644 printf("Leak of %d blocks found in xmlXPathNextAncestor", 48645 xmlMemBlocks() - mem_base); 48646 test_ret++; 48647 printf(" %d", n_ctxt); 48648 printf(" %d", n_cur); 48649 printf("\n"); 48650 } 48651 } 48652 } 48653 function_tests++; 48654 #endif 48655 48656 return(test_ret); 48657 } 48658 48659 48660 static int 48661 test_xmlXPathNextAncestorOrSelf(void) { 48662 int test_ret = 0; 48663 48664 #if defined(LIBXML_XPATH_ENABLED) 48665 int mem_base; 48666 xmlNodePtr ret_val; 48667 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 48668 int n_ctxt; 48669 xmlNodePtr cur; /* the current node in the traversal */ 48670 int n_cur; 48671 48672 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 48673 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 48674 mem_base = xmlMemBlocks(); 48675 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 48676 cur = gen_xmlNodePtr(n_cur, 1); 48677 48678 ret_val = xmlXPathNextAncestorOrSelf(ctxt, cur); 48679 desret_xmlNodePtr(ret_val); 48680 call_tests++; 48681 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 48682 des_xmlNodePtr(n_cur, cur, 1); 48683 xmlResetLastError(); 48684 if (mem_base != xmlMemBlocks()) { 48685 printf("Leak of %d blocks found in xmlXPathNextAncestorOrSelf", 48686 xmlMemBlocks() - mem_base); 48687 test_ret++; 48688 printf(" %d", n_ctxt); 48689 printf(" %d", n_cur); 48690 printf("\n"); 48691 } 48692 } 48693 } 48694 function_tests++; 48695 #endif 48696 48697 return(test_ret); 48698 } 48699 48700 48701 static int 48702 test_xmlXPathNextAttribute(void) { 48703 int test_ret = 0; 48704 48705 #if defined(LIBXML_XPATH_ENABLED) 48706 int mem_base; 48707 xmlNodePtr ret_val; 48708 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 48709 int n_ctxt; 48710 xmlNodePtr cur; /* the current attribute in the traversal */ 48711 int n_cur; 48712 48713 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 48714 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 48715 mem_base = xmlMemBlocks(); 48716 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 48717 cur = gen_xmlNodePtr(n_cur, 1); 48718 48719 ret_val = xmlXPathNextAttribute(ctxt, cur); 48720 desret_xmlNodePtr(ret_val); 48721 call_tests++; 48722 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 48723 des_xmlNodePtr(n_cur, cur, 1); 48724 xmlResetLastError(); 48725 if (mem_base != xmlMemBlocks()) { 48726 printf("Leak of %d blocks found in xmlXPathNextAttribute", 48727 xmlMemBlocks() - mem_base); 48728 test_ret++; 48729 printf(" %d", n_ctxt); 48730 printf(" %d", n_cur); 48731 printf("\n"); 48732 } 48733 } 48734 } 48735 function_tests++; 48736 #endif 48737 48738 return(test_ret); 48739 } 48740 48741 48742 static int 48743 test_xmlXPathNextChild(void) { 48744 int test_ret = 0; 48745 48746 #if defined(LIBXML_XPATH_ENABLED) 48747 int mem_base; 48748 xmlNodePtr ret_val; 48749 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 48750 int n_ctxt; 48751 xmlNodePtr cur; /* the current node in the traversal */ 48752 int n_cur; 48753 48754 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 48755 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 48756 mem_base = xmlMemBlocks(); 48757 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 48758 cur = gen_xmlNodePtr(n_cur, 1); 48759 48760 ret_val = xmlXPathNextChild(ctxt, cur); 48761 desret_xmlNodePtr(ret_val); 48762 call_tests++; 48763 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 48764 des_xmlNodePtr(n_cur, cur, 1); 48765 xmlResetLastError(); 48766 if (mem_base != xmlMemBlocks()) { 48767 printf("Leak of %d blocks found in xmlXPathNextChild", 48768 xmlMemBlocks() - mem_base); 48769 test_ret++; 48770 printf(" %d", n_ctxt); 48771 printf(" %d", n_cur); 48772 printf("\n"); 48773 } 48774 } 48775 } 48776 function_tests++; 48777 #endif 48778 48779 return(test_ret); 48780 } 48781 48782 48783 static int 48784 test_xmlXPathNextDescendant(void) { 48785 int test_ret = 0; 48786 48787 #if defined(LIBXML_XPATH_ENABLED) 48788 int mem_base; 48789 xmlNodePtr ret_val; 48790 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 48791 int n_ctxt; 48792 xmlNodePtr cur; /* the current node in the traversal */ 48793 int n_cur; 48794 48795 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 48796 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 48797 mem_base = xmlMemBlocks(); 48798 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 48799 cur = gen_xmlNodePtr(n_cur, 1); 48800 48801 ret_val = xmlXPathNextDescendant(ctxt, cur); 48802 desret_xmlNodePtr(ret_val); 48803 call_tests++; 48804 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 48805 des_xmlNodePtr(n_cur, cur, 1); 48806 xmlResetLastError(); 48807 if (mem_base != xmlMemBlocks()) { 48808 printf("Leak of %d blocks found in xmlXPathNextDescendant", 48809 xmlMemBlocks() - mem_base); 48810 test_ret++; 48811 printf(" %d", n_ctxt); 48812 printf(" %d", n_cur); 48813 printf("\n"); 48814 } 48815 } 48816 } 48817 function_tests++; 48818 #endif 48819 48820 return(test_ret); 48821 } 48822 48823 48824 static int 48825 test_xmlXPathNextDescendantOrSelf(void) { 48826 int test_ret = 0; 48827 48828 #if defined(LIBXML_XPATH_ENABLED) 48829 int mem_base; 48830 xmlNodePtr ret_val; 48831 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 48832 int n_ctxt; 48833 xmlNodePtr cur; /* the current node in the traversal */ 48834 int n_cur; 48835 48836 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 48837 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 48838 mem_base = xmlMemBlocks(); 48839 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 48840 cur = gen_xmlNodePtr(n_cur, 1); 48841 48842 ret_val = xmlXPathNextDescendantOrSelf(ctxt, cur); 48843 desret_xmlNodePtr(ret_val); 48844 call_tests++; 48845 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 48846 des_xmlNodePtr(n_cur, cur, 1); 48847 xmlResetLastError(); 48848 if (mem_base != xmlMemBlocks()) { 48849 printf("Leak of %d blocks found in xmlXPathNextDescendantOrSelf", 48850 xmlMemBlocks() - mem_base); 48851 test_ret++; 48852 printf(" %d", n_ctxt); 48853 printf(" %d", n_cur); 48854 printf("\n"); 48855 } 48856 } 48857 } 48858 function_tests++; 48859 #endif 48860 48861 return(test_ret); 48862 } 48863 48864 48865 static int 48866 test_xmlXPathNextFollowing(void) { 48867 int test_ret = 0; 48868 48869 #if defined(LIBXML_XPATH_ENABLED) 48870 int mem_base; 48871 xmlNodePtr ret_val; 48872 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 48873 int n_ctxt; 48874 xmlNodePtr cur; /* the current node in the traversal */ 48875 int n_cur; 48876 48877 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 48878 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 48879 mem_base = xmlMemBlocks(); 48880 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 48881 cur = gen_xmlNodePtr(n_cur, 1); 48882 48883 ret_val = xmlXPathNextFollowing(ctxt, cur); 48884 desret_xmlNodePtr(ret_val); 48885 call_tests++; 48886 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 48887 des_xmlNodePtr(n_cur, cur, 1); 48888 xmlResetLastError(); 48889 if (mem_base != xmlMemBlocks()) { 48890 printf("Leak of %d blocks found in xmlXPathNextFollowing", 48891 xmlMemBlocks() - mem_base); 48892 test_ret++; 48893 printf(" %d", n_ctxt); 48894 printf(" %d", n_cur); 48895 printf("\n"); 48896 } 48897 } 48898 } 48899 function_tests++; 48900 #endif 48901 48902 return(test_ret); 48903 } 48904 48905 48906 static int 48907 test_xmlXPathNextFollowingSibling(void) { 48908 int test_ret = 0; 48909 48910 #if defined(LIBXML_XPATH_ENABLED) 48911 int mem_base; 48912 xmlNodePtr ret_val; 48913 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 48914 int n_ctxt; 48915 xmlNodePtr cur; /* the current node in the traversal */ 48916 int n_cur; 48917 48918 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 48919 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 48920 mem_base = xmlMemBlocks(); 48921 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 48922 cur = gen_xmlNodePtr(n_cur, 1); 48923 48924 ret_val = xmlXPathNextFollowingSibling(ctxt, cur); 48925 desret_xmlNodePtr(ret_val); 48926 call_tests++; 48927 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 48928 des_xmlNodePtr(n_cur, cur, 1); 48929 xmlResetLastError(); 48930 if (mem_base != xmlMemBlocks()) { 48931 printf("Leak of %d blocks found in xmlXPathNextFollowingSibling", 48932 xmlMemBlocks() - mem_base); 48933 test_ret++; 48934 printf(" %d", n_ctxt); 48935 printf(" %d", n_cur); 48936 printf("\n"); 48937 } 48938 } 48939 } 48940 function_tests++; 48941 #endif 48942 48943 return(test_ret); 48944 } 48945 48946 48947 static int 48948 test_xmlXPathNextNamespace(void) { 48949 int test_ret = 0; 48950 48951 #if defined(LIBXML_XPATH_ENABLED) 48952 int mem_base; 48953 xmlNodePtr ret_val; 48954 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 48955 int n_ctxt; 48956 xmlNodePtr cur; /* the current attribute in the traversal */ 48957 int n_cur; 48958 48959 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 48960 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 48961 mem_base = xmlMemBlocks(); 48962 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 48963 cur = gen_xmlNodePtr(n_cur, 1); 48964 48965 ret_val = xmlXPathNextNamespace(ctxt, cur); 48966 desret_xmlNodePtr(ret_val); 48967 call_tests++; 48968 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 48969 des_xmlNodePtr(n_cur, cur, 1); 48970 xmlResetLastError(); 48971 if (mem_base != xmlMemBlocks()) { 48972 printf("Leak of %d blocks found in xmlXPathNextNamespace", 48973 xmlMemBlocks() - mem_base); 48974 test_ret++; 48975 printf(" %d", n_ctxt); 48976 printf(" %d", n_cur); 48977 printf("\n"); 48978 } 48979 } 48980 } 48981 function_tests++; 48982 #endif 48983 48984 return(test_ret); 48985 } 48986 48987 48988 static int 48989 test_xmlXPathNextParent(void) { 48990 int test_ret = 0; 48991 48992 #if defined(LIBXML_XPATH_ENABLED) 48993 int mem_base; 48994 xmlNodePtr ret_val; 48995 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 48996 int n_ctxt; 48997 xmlNodePtr cur; /* the current node in the traversal */ 48998 int n_cur; 48999 49000 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 49001 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 49002 mem_base = xmlMemBlocks(); 49003 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 49004 cur = gen_xmlNodePtr(n_cur, 1); 49005 49006 ret_val = xmlXPathNextParent(ctxt, cur); 49007 desret_xmlNodePtr(ret_val); 49008 call_tests++; 49009 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 49010 des_xmlNodePtr(n_cur, cur, 1); 49011 xmlResetLastError(); 49012 if (mem_base != xmlMemBlocks()) { 49013 printf("Leak of %d blocks found in xmlXPathNextParent", 49014 xmlMemBlocks() - mem_base); 49015 test_ret++; 49016 printf(" %d", n_ctxt); 49017 printf(" %d", n_cur); 49018 printf("\n"); 49019 } 49020 } 49021 } 49022 function_tests++; 49023 #endif 49024 49025 return(test_ret); 49026 } 49027 49028 49029 static int 49030 test_xmlXPathNextPreceding(void) { 49031 int test_ret = 0; 49032 49033 #if defined(LIBXML_XPATH_ENABLED) 49034 int mem_base; 49035 xmlNodePtr ret_val; 49036 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 49037 int n_ctxt; 49038 xmlNodePtr cur; /* the current node in the traversal */ 49039 int n_cur; 49040 49041 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 49042 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 49043 mem_base = xmlMemBlocks(); 49044 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 49045 cur = gen_xmlNodePtr(n_cur, 1); 49046 49047 ret_val = xmlXPathNextPreceding(ctxt, cur); 49048 desret_xmlNodePtr(ret_val); 49049 call_tests++; 49050 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 49051 des_xmlNodePtr(n_cur, cur, 1); 49052 xmlResetLastError(); 49053 if (mem_base != xmlMemBlocks()) { 49054 printf("Leak of %d blocks found in xmlXPathNextPreceding", 49055 xmlMemBlocks() - mem_base); 49056 test_ret++; 49057 printf(" %d", n_ctxt); 49058 printf(" %d", n_cur); 49059 printf("\n"); 49060 } 49061 } 49062 } 49063 function_tests++; 49064 #endif 49065 49066 return(test_ret); 49067 } 49068 49069 49070 static int 49071 test_xmlXPathNextPrecedingSibling(void) { 49072 int test_ret = 0; 49073 49074 #if defined(LIBXML_XPATH_ENABLED) 49075 int mem_base; 49076 xmlNodePtr ret_val; 49077 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 49078 int n_ctxt; 49079 xmlNodePtr cur; /* the current node in the traversal */ 49080 int n_cur; 49081 49082 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 49083 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 49084 mem_base = xmlMemBlocks(); 49085 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 49086 cur = gen_xmlNodePtr(n_cur, 1); 49087 49088 ret_val = xmlXPathNextPrecedingSibling(ctxt, cur); 49089 desret_xmlNodePtr(ret_val); 49090 call_tests++; 49091 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 49092 des_xmlNodePtr(n_cur, cur, 1); 49093 xmlResetLastError(); 49094 if (mem_base != xmlMemBlocks()) { 49095 printf("Leak of %d blocks found in xmlXPathNextPrecedingSibling", 49096 xmlMemBlocks() - mem_base); 49097 test_ret++; 49098 printf(" %d", n_ctxt); 49099 printf(" %d", n_cur); 49100 printf("\n"); 49101 } 49102 } 49103 } 49104 function_tests++; 49105 #endif 49106 49107 return(test_ret); 49108 } 49109 49110 49111 static int 49112 test_xmlXPathNextSelf(void) { 49113 int test_ret = 0; 49114 49115 #if defined(LIBXML_XPATH_ENABLED) 49116 int mem_base; 49117 xmlNodePtr ret_val; 49118 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 49119 int n_ctxt; 49120 xmlNodePtr cur; /* the current node in the traversal */ 49121 int n_cur; 49122 49123 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 49124 for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { 49125 mem_base = xmlMemBlocks(); 49126 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 49127 cur = gen_xmlNodePtr(n_cur, 1); 49128 49129 ret_val = xmlXPathNextSelf(ctxt, cur); 49130 desret_xmlNodePtr(ret_val); 49131 call_tests++; 49132 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 49133 des_xmlNodePtr(n_cur, cur, 1); 49134 xmlResetLastError(); 49135 if (mem_base != xmlMemBlocks()) { 49136 printf("Leak of %d blocks found in xmlXPathNextSelf", 49137 xmlMemBlocks() - mem_base); 49138 test_ret++; 49139 printf(" %d", n_ctxt); 49140 printf(" %d", n_cur); 49141 printf("\n"); 49142 } 49143 } 49144 } 49145 function_tests++; 49146 #endif 49147 49148 return(test_ret); 49149 } 49150 49151 49152 static int 49153 test_xmlXPathNodeLeading(void) { 49154 int test_ret = 0; 49155 49156 #if defined(LIBXML_XPATH_ENABLED) 49157 int mem_base; 49158 xmlNodeSetPtr ret_val; 49159 xmlNodeSetPtr nodes; /* a node-set */ 49160 int n_nodes; 49161 xmlNodePtr node; /* a node */ 49162 int n_node; 49163 49164 for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) { 49165 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 49166 mem_base = xmlMemBlocks(); 49167 nodes = gen_xmlNodeSetPtr(n_nodes, 0); 49168 node = gen_xmlNodePtr(n_node, 1); 49169 49170 ret_val = xmlXPathNodeLeading(nodes, node); 49171 desret_xmlNodeSetPtr(ret_val); 49172 call_tests++; 49173 des_xmlNodeSetPtr(n_nodes, nodes, 0); 49174 des_xmlNodePtr(n_node, node, 1); 49175 xmlResetLastError(); 49176 if (mem_base != xmlMemBlocks()) { 49177 printf("Leak of %d blocks found in xmlXPathNodeLeading", 49178 xmlMemBlocks() - mem_base); 49179 test_ret++; 49180 printf(" %d", n_nodes); 49181 printf(" %d", n_node); 49182 printf("\n"); 49183 } 49184 } 49185 } 49186 function_tests++; 49187 #endif 49188 49189 return(test_ret); 49190 } 49191 49192 49193 static int 49194 test_xmlXPathNodeLeadingSorted(void) { 49195 int test_ret = 0; 49196 49197 #if defined(LIBXML_XPATH_ENABLED) 49198 int mem_base; 49199 xmlNodeSetPtr ret_val; 49200 xmlNodeSetPtr nodes; /* a node-set, sorted by document order */ 49201 int n_nodes; 49202 xmlNodePtr node; /* a node */ 49203 int n_node; 49204 49205 for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) { 49206 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 49207 mem_base = xmlMemBlocks(); 49208 nodes = gen_xmlNodeSetPtr(n_nodes, 0); 49209 node = gen_xmlNodePtr(n_node, 1); 49210 49211 ret_val = xmlXPathNodeLeadingSorted(nodes, node); 49212 desret_xmlNodeSetPtr(ret_val); 49213 call_tests++; 49214 des_xmlNodeSetPtr(n_nodes, nodes, 0); 49215 des_xmlNodePtr(n_node, node, 1); 49216 xmlResetLastError(); 49217 if (mem_base != xmlMemBlocks()) { 49218 printf("Leak of %d blocks found in xmlXPathNodeLeadingSorted", 49219 xmlMemBlocks() - mem_base); 49220 test_ret++; 49221 printf(" %d", n_nodes); 49222 printf(" %d", n_node); 49223 printf("\n"); 49224 } 49225 } 49226 } 49227 function_tests++; 49228 #endif 49229 49230 return(test_ret); 49231 } 49232 49233 49234 static int 49235 test_xmlXPathNodeSetAdd(void) { 49236 int test_ret = 0; 49237 49238 #if defined(LIBXML_XPATH_ENABLED) 49239 int mem_base; 49240 int ret_val; 49241 xmlNodeSetPtr cur; /* the initial node set */ 49242 int n_cur; 49243 xmlNodePtr val; /* a new xmlNodePtr */ 49244 int n_val; 49245 49246 for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) { 49247 for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) { 49248 mem_base = xmlMemBlocks(); 49249 cur = gen_xmlNodeSetPtr(n_cur, 0); 49250 val = gen_xmlNodePtr(n_val, 1); 49251 49252 ret_val = xmlXPathNodeSetAdd(cur, val); 49253 desret_int(ret_val); 49254 call_tests++; 49255 des_xmlNodeSetPtr(n_cur, cur, 0); 49256 des_xmlNodePtr(n_val, val, 1); 49257 xmlResetLastError(); 49258 if (mem_base != xmlMemBlocks()) { 49259 printf("Leak of %d blocks found in xmlXPathNodeSetAdd", 49260 xmlMemBlocks() - mem_base); 49261 test_ret++; 49262 printf(" %d", n_cur); 49263 printf(" %d", n_val); 49264 printf("\n"); 49265 } 49266 } 49267 } 49268 function_tests++; 49269 #endif 49270 49271 return(test_ret); 49272 } 49273 49274 49275 static int 49276 test_xmlXPathNodeSetAddNs(void) { 49277 int test_ret = 0; 49278 49279 #if defined(LIBXML_XPATH_ENABLED) 49280 int mem_base; 49281 int ret_val; 49282 xmlNodeSetPtr cur; /* the initial node set */ 49283 int n_cur; 49284 xmlNodePtr node; /* the hosting node */ 49285 int n_node; 49286 xmlNsPtr ns; /* a the namespace node */ 49287 int n_ns; 49288 49289 for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) { 49290 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 49291 for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) { 49292 mem_base = xmlMemBlocks(); 49293 cur = gen_xmlNodeSetPtr(n_cur, 0); 49294 node = gen_xmlNodePtr(n_node, 1); 49295 ns = gen_xmlNsPtr(n_ns, 2); 49296 49297 ret_val = xmlXPathNodeSetAddNs(cur, node, ns); 49298 desret_int(ret_val); 49299 call_tests++; 49300 des_xmlNodeSetPtr(n_cur, cur, 0); 49301 des_xmlNodePtr(n_node, node, 1); 49302 des_xmlNsPtr(n_ns, ns, 2); 49303 xmlResetLastError(); 49304 if (mem_base != xmlMemBlocks()) { 49305 printf("Leak of %d blocks found in xmlXPathNodeSetAddNs", 49306 xmlMemBlocks() - mem_base); 49307 test_ret++; 49308 printf(" %d", n_cur); 49309 printf(" %d", n_node); 49310 printf(" %d", n_ns); 49311 printf("\n"); 49312 } 49313 } 49314 } 49315 } 49316 function_tests++; 49317 #endif 49318 49319 return(test_ret); 49320 } 49321 49322 49323 static int 49324 test_xmlXPathNodeSetAddUnique(void) { 49325 int test_ret = 0; 49326 49327 #if defined(LIBXML_XPATH_ENABLED) 49328 int mem_base; 49329 int ret_val; 49330 xmlNodeSetPtr cur; /* the initial node set */ 49331 int n_cur; 49332 xmlNodePtr val; /* a new xmlNodePtr */ 49333 int n_val; 49334 49335 for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) { 49336 for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) { 49337 mem_base = xmlMemBlocks(); 49338 cur = gen_xmlNodeSetPtr(n_cur, 0); 49339 val = gen_xmlNodePtr(n_val, 1); 49340 49341 ret_val = xmlXPathNodeSetAddUnique(cur, val); 49342 desret_int(ret_val); 49343 call_tests++; 49344 des_xmlNodeSetPtr(n_cur, cur, 0); 49345 des_xmlNodePtr(n_val, val, 1); 49346 xmlResetLastError(); 49347 if (mem_base != xmlMemBlocks()) { 49348 printf("Leak of %d blocks found in xmlXPathNodeSetAddUnique", 49349 xmlMemBlocks() - mem_base); 49350 test_ret++; 49351 printf(" %d", n_cur); 49352 printf(" %d", n_val); 49353 printf("\n"); 49354 } 49355 } 49356 } 49357 function_tests++; 49358 #endif 49359 49360 return(test_ret); 49361 } 49362 49363 49364 static int 49365 test_xmlXPathNodeSetContains(void) { 49366 int test_ret = 0; 49367 49368 #if defined(LIBXML_XPATH_ENABLED) 49369 int mem_base; 49370 int ret_val; 49371 xmlNodeSetPtr cur; /* the node-set */ 49372 int n_cur; 49373 xmlNodePtr val; /* the node */ 49374 int n_val; 49375 49376 for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) { 49377 for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) { 49378 mem_base = xmlMemBlocks(); 49379 cur = gen_xmlNodeSetPtr(n_cur, 0); 49380 val = gen_xmlNodePtr(n_val, 1); 49381 49382 ret_val = xmlXPathNodeSetContains(cur, val); 49383 desret_int(ret_val); 49384 call_tests++; 49385 des_xmlNodeSetPtr(n_cur, cur, 0); 49386 des_xmlNodePtr(n_val, val, 1); 49387 xmlResetLastError(); 49388 if (mem_base != xmlMemBlocks()) { 49389 printf("Leak of %d blocks found in xmlXPathNodeSetContains", 49390 xmlMemBlocks() - mem_base); 49391 test_ret++; 49392 printf(" %d", n_cur); 49393 printf(" %d", n_val); 49394 printf("\n"); 49395 } 49396 } 49397 } 49398 function_tests++; 49399 #endif 49400 49401 return(test_ret); 49402 } 49403 49404 49405 static int 49406 test_xmlXPathNodeSetDel(void) { 49407 int test_ret = 0; 49408 49409 #if defined(LIBXML_XPATH_ENABLED) 49410 int mem_base; 49411 xmlNodeSetPtr cur; /* the initial node set */ 49412 int n_cur; 49413 xmlNodePtr val; /* an xmlNodePtr */ 49414 int n_val; 49415 49416 for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) { 49417 for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) { 49418 mem_base = xmlMemBlocks(); 49419 cur = gen_xmlNodeSetPtr(n_cur, 0); 49420 val = gen_xmlNodePtr(n_val, 1); 49421 49422 xmlXPathNodeSetDel(cur, val); 49423 call_tests++; 49424 des_xmlNodeSetPtr(n_cur, cur, 0); 49425 des_xmlNodePtr(n_val, val, 1); 49426 xmlResetLastError(); 49427 if (mem_base != xmlMemBlocks()) { 49428 printf("Leak of %d blocks found in xmlXPathNodeSetDel", 49429 xmlMemBlocks() - mem_base); 49430 test_ret++; 49431 printf(" %d", n_cur); 49432 printf(" %d", n_val); 49433 printf("\n"); 49434 } 49435 } 49436 } 49437 function_tests++; 49438 #endif 49439 49440 return(test_ret); 49441 } 49442 49443 49444 static int 49445 test_xmlXPathNodeSetMerge(void) { 49446 int test_ret = 0; 49447 49448 #if defined(LIBXML_XPATH_ENABLED) 49449 int mem_base; 49450 xmlNodeSetPtr ret_val; 49451 xmlNodeSetPtr val1; /* the first NodeSet or NULL */ 49452 int n_val1; 49453 xmlNodeSetPtr val2; /* the second NodeSet */ 49454 int n_val2; 49455 49456 for (n_val1 = 0;n_val1 < gen_nb_xmlNodeSetPtr;n_val1++) { 49457 for (n_val2 = 0;n_val2 < gen_nb_xmlNodeSetPtr;n_val2++) { 49458 mem_base = xmlMemBlocks(); 49459 val1 = gen_xmlNodeSetPtr(n_val1, 0); 49460 val2 = gen_xmlNodeSetPtr(n_val2, 1); 49461 49462 ret_val = xmlXPathNodeSetMerge(val1, val2); 49463 desret_xmlNodeSetPtr(ret_val); 49464 call_tests++; 49465 des_xmlNodeSetPtr(n_val1, val1, 0); 49466 des_xmlNodeSetPtr(n_val2, val2, 1); 49467 xmlResetLastError(); 49468 if (mem_base != xmlMemBlocks()) { 49469 printf("Leak of %d blocks found in xmlXPathNodeSetMerge", 49470 xmlMemBlocks() - mem_base); 49471 test_ret++; 49472 printf(" %d", n_val1); 49473 printf(" %d", n_val2); 49474 printf("\n"); 49475 } 49476 } 49477 } 49478 function_tests++; 49479 #endif 49480 49481 return(test_ret); 49482 } 49483 49484 49485 static int 49486 test_xmlXPathNodeSetRemove(void) { 49487 int test_ret = 0; 49488 49489 #if defined(LIBXML_XPATH_ENABLED) 49490 int mem_base; 49491 xmlNodeSetPtr cur; /* the initial node set */ 49492 int n_cur; 49493 int val; /* the index to remove */ 49494 int n_val; 49495 49496 for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) { 49497 for (n_val = 0;n_val < gen_nb_int;n_val++) { 49498 mem_base = xmlMemBlocks(); 49499 cur = gen_xmlNodeSetPtr(n_cur, 0); 49500 val = gen_int(n_val, 1); 49501 49502 xmlXPathNodeSetRemove(cur, val); 49503 call_tests++; 49504 des_xmlNodeSetPtr(n_cur, cur, 0); 49505 des_int(n_val, val, 1); 49506 xmlResetLastError(); 49507 if (mem_base != xmlMemBlocks()) { 49508 printf("Leak of %d blocks found in xmlXPathNodeSetRemove", 49509 xmlMemBlocks() - mem_base); 49510 test_ret++; 49511 printf(" %d", n_cur); 49512 printf(" %d", n_val); 49513 printf("\n"); 49514 } 49515 } 49516 } 49517 function_tests++; 49518 #endif 49519 49520 return(test_ret); 49521 } 49522 49523 49524 static int 49525 test_xmlXPathNodeSetSort(void) { 49526 int test_ret = 0; 49527 49528 #if defined(LIBXML_XPATH_ENABLED) 49529 int mem_base; 49530 xmlNodeSetPtr set; /* the node set */ 49531 int n_set; 49532 49533 for (n_set = 0;n_set < gen_nb_xmlNodeSetPtr;n_set++) { 49534 mem_base = xmlMemBlocks(); 49535 set = gen_xmlNodeSetPtr(n_set, 0); 49536 49537 xmlXPathNodeSetSort(set); 49538 call_tests++; 49539 des_xmlNodeSetPtr(n_set, set, 0); 49540 xmlResetLastError(); 49541 if (mem_base != xmlMemBlocks()) { 49542 printf("Leak of %d blocks found in xmlXPathNodeSetSort", 49543 xmlMemBlocks() - mem_base); 49544 test_ret++; 49545 printf(" %d", n_set); 49546 printf("\n"); 49547 } 49548 } 49549 function_tests++; 49550 #endif 49551 49552 return(test_ret); 49553 } 49554 49555 49556 static int 49557 test_xmlXPathNodeTrailing(void) { 49558 int test_ret = 0; 49559 49560 #if defined(LIBXML_XPATH_ENABLED) 49561 int mem_base; 49562 xmlNodeSetPtr ret_val; 49563 xmlNodeSetPtr nodes; /* a node-set */ 49564 int n_nodes; 49565 xmlNodePtr node; /* a node */ 49566 int n_node; 49567 49568 for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) { 49569 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 49570 mem_base = xmlMemBlocks(); 49571 nodes = gen_xmlNodeSetPtr(n_nodes, 0); 49572 node = gen_xmlNodePtr(n_node, 1); 49573 49574 ret_val = xmlXPathNodeTrailing(nodes, node); 49575 desret_xmlNodeSetPtr(ret_val); 49576 call_tests++; 49577 des_xmlNodeSetPtr(n_nodes, nodes, 0); 49578 des_xmlNodePtr(n_node, node, 1); 49579 xmlResetLastError(); 49580 if (mem_base != xmlMemBlocks()) { 49581 printf("Leak of %d blocks found in xmlXPathNodeTrailing", 49582 xmlMemBlocks() - mem_base); 49583 test_ret++; 49584 printf(" %d", n_nodes); 49585 printf(" %d", n_node); 49586 printf("\n"); 49587 } 49588 } 49589 } 49590 function_tests++; 49591 #endif 49592 49593 return(test_ret); 49594 } 49595 49596 49597 static int 49598 test_xmlXPathNodeTrailingSorted(void) { 49599 int test_ret = 0; 49600 49601 #if defined(LIBXML_XPATH_ENABLED) 49602 int mem_base; 49603 xmlNodeSetPtr ret_val; 49604 xmlNodeSetPtr nodes; /* a node-set, sorted by document order */ 49605 int n_nodes; 49606 xmlNodePtr node; /* a node */ 49607 int n_node; 49608 49609 for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) { 49610 for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { 49611 mem_base = xmlMemBlocks(); 49612 nodes = gen_xmlNodeSetPtr(n_nodes, 0); 49613 node = gen_xmlNodePtr(n_node, 1); 49614 49615 ret_val = xmlXPathNodeTrailingSorted(nodes, node); 49616 desret_xmlNodeSetPtr(ret_val); 49617 call_tests++; 49618 des_xmlNodeSetPtr(n_nodes, nodes, 0); 49619 des_xmlNodePtr(n_node, node, 1); 49620 xmlResetLastError(); 49621 if (mem_base != xmlMemBlocks()) { 49622 printf("Leak of %d blocks found in xmlXPathNodeTrailingSorted", 49623 xmlMemBlocks() - mem_base); 49624 test_ret++; 49625 printf(" %d", n_nodes); 49626 printf(" %d", n_node); 49627 printf("\n"); 49628 } 49629 } 49630 } 49631 function_tests++; 49632 #endif 49633 49634 return(test_ret); 49635 } 49636 49637 49638 static int 49639 test_xmlXPathNormalizeFunction(void) { 49640 int test_ret = 0; 49641 49642 #if defined(LIBXML_XPATH_ENABLED) 49643 int mem_base; 49644 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 49645 int n_ctxt; 49646 int nargs; /* the number of arguments */ 49647 int n_nargs; 49648 49649 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 49650 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 49651 mem_base = xmlMemBlocks(); 49652 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 49653 nargs = gen_int(n_nargs, 1); 49654 49655 xmlXPathNormalizeFunction(ctxt, nargs); 49656 call_tests++; 49657 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 49658 des_int(n_nargs, nargs, 1); 49659 xmlResetLastError(); 49660 if (mem_base != xmlMemBlocks()) { 49661 printf("Leak of %d blocks found in xmlXPathNormalizeFunction", 49662 xmlMemBlocks() - mem_base); 49663 test_ret++; 49664 printf(" %d", n_ctxt); 49665 printf(" %d", n_nargs); 49666 printf("\n"); 49667 } 49668 } 49669 } 49670 function_tests++; 49671 #endif 49672 49673 return(test_ret); 49674 } 49675 49676 49677 static int 49678 test_xmlXPathNotEqualValues(void) { 49679 int test_ret = 0; 49680 49681 #if defined(LIBXML_XPATH_ENABLED) 49682 int mem_base; 49683 int ret_val; 49684 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 49685 int n_ctxt; 49686 49687 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 49688 mem_base = xmlMemBlocks(); 49689 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 49690 49691 ret_val = xmlXPathNotEqualValues(ctxt); 49692 desret_int(ret_val); 49693 call_tests++; 49694 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 49695 xmlResetLastError(); 49696 if (mem_base != xmlMemBlocks()) { 49697 printf("Leak of %d blocks found in xmlXPathNotEqualValues", 49698 xmlMemBlocks() - mem_base); 49699 test_ret++; 49700 printf(" %d", n_ctxt); 49701 printf("\n"); 49702 } 49703 } 49704 function_tests++; 49705 #endif 49706 49707 return(test_ret); 49708 } 49709 49710 49711 static int 49712 test_xmlXPathNotFunction(void) { 49713 int test_ret = 0; 49714 49715 #if defined(LIBXML_XPATH_ENABLED) 49716 int mem_base; 49717 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 49718 int n_ctxt; 49719 int nargs; /* the number of arguments */ 49720 int n_nargs; 49721 49722 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 49723 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 49724 mem_base = xmlMemBlocks(); 49725 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 49726 nargs = gen_int(n_nargs, 1); 49727 49728 xmlXPathNotFunction(ctxt, nargs); 49729 call_tests++; 49730 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 49731 des_int(n_nargs, nargs, 1); 49732 xmlResetLastError(); 49733 if (mem_base != xmlMemBlocks()) { 49734 printf("Leak of %d blocks found in xmlXPathNotFunction", 49735 xmlMemBlocks() - mem_base); 49736 test_ret++; 49737 printf(" %d", n_ctxt); 49738 printf(" %d", n_nargs); 49739 printf("\n"); 49740 } 49741 } 49742 } 49743 function_tests++; 49744 #endif 49745 49746 return(test_ret); 49747 } 49748 49749 49750 static int 49751 test_xmlXPathNsLookup(void) { 49752 int test_ret = 0; 49753 49754 #if defined(LIBXML_XPATH_ENABLED) 49755 int mem_base; 49756 const xmlChar * ret_val; 49757 xmlXPathContextPtr ctxt; /* the XPath context */ 49758 int n_ctxt; 49759 xmlChar * prefix; /* the namespace prefix value */ 49760 int n_prefix; 49761 49762 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) { 49763 for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) { 49764 mem_base = xmlMemBlocks(); 49765 ctxt = gen_xmlXPathContextPtr(n_ctxt, 0); 49766 prefix = gen_const_xmlChar_ptr(n_prefix, 1); 49767 49768 ret_val = xmlXPathNsLookup(ctxt, (const xmlChar *)prefix); 49769 desret_const_xmlChar_ptr(ret_val); 49770 call_tests++; 49771 des_xmlXPathContextPtr(n_ctxt, ctxt, 0); 49772 des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1); 49773 xmlResetLastError(); 49774 if (mem_base != xmlMemBlocks()) { 49775 printf("Leak of %d blocks found in xmlXPathNsLookup", 49776 xmlMemBlocks() - mem_base); 49777 test_ret++; 49778 printf(" %d", n_ctxt); 49779 printf(" %d", n_prefix); 49780 printf("\n"); 49781 } 49782 } 49783 } 49784 function_tests++; 49785 #endif 49786 49787 return(test_ret); 49788 } 49789 49790 49791 static int 49792 test_xmlXPathNumberFunction(void) { 49793 int test_ret = 0; 49794 49795 #if defined(LIBXML_XPATH_ENABLED) 49796 int mem_base; 49797 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 49798 int n_ctxt; 49799 int nargs; /* the number of arguments */ 49800 int n_nargs; 49801 49802 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 49803 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 49804 mem_base = xmlMemBlocks(); 49805 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 49806 nargs = gen_int(n_nargs, 1); 49807 49808 xmlXPathNumberFunction(ctxt, nargs); 49809 call_tests++; 49810 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 49811 des_int(n_nargs, nargs, 1); 49812 xmlResetLastError(); 49813 if (mem_base != xmlMemBlocks()) { 49814 printf("Leak of %d blocks found in xmlXPathNumberFunction", 49815 xmlMemBlocks() - mem_base); 49816 test_ret++; 49817 printf(" %d", n_ctxt); 49818 printf(" %d", n_nargs); 49819 printf("\n"); 49820 } 49821 } 49822 } 49823 function_tests++; 49824 #endif 49825 49826 return(test_ret); 49827 } 49828 49829 49830 static int 49831 test_xmlXPathParseNCName(void) { 49832 int test_ret = 0; 49833 49834 #if defined(LIBXML_XPATH_ENABLED) 49835 int mem_base; 49836 xmlChar * ret_val; 49837 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 49838 int n_ctxt; 49839 49840 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 49841 mem_base = xmlMemBlocks(); 49842 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 49843 49844 ret_val = xmlXPathParseNCName(ctxt); 49845 desret_xmlChar_ptr(ret_val); 49846 call_tests++; 49847 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 49848 xmlResetLastError(); 49849 if (mem_base != xmlMemBlocks()) { 49850 printf("Leak of %d blocks found in xmlXPathParseNCName", 49851 xmlMemBlocks() - mem_base); 49852 test_ret++; 49853 printf(" %d", n_ctxt); 49854 printf("\n"); 49855 } 49856 } 49857 function_tests++; 49858 #endif 49859 49860 return(test_ret); 49861 } 49862 49863 49864 static int 49865 test_xmlXPathParseName(void) { 49866 int test_ret = 0; 49867 49868 #if defined(LIBXML_XPATH_ENABLED) 49869 int mem_base; 49870 xmlChar * ret_val; 49871 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 49872 int n_ctxt; 49873 49874 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 49875 mem_base = xmlMemBlocks(); 49876 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 49877 49878 ret_val = xmlXPathParseName(ctxt); 49879 desret_xmlChar_ptr(ret_val); 49880 call_tests++; 49881 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 49882 xmlResetLastError(); 49883 if (mem_base != xmlMemBlocks()) { 49884 printf("Leak of %d blocks found in xmlXPathParseName", 49885 xmlMemBlocks() - mem_base); 49886 test_ret++; 49887 printf(" %d", n_ctxt); 49888 printf("\n"); 49889 } 49890 } 49891 function_tests++; 49892 #endif 49893 49894 return(test_ret); 49895 } 49896 49897 49898 static int 49899 test_xmlXPathPopBoolean(void) { 49900 int test_ret = 0; 49901 49902 #if defined(LIBXML_XPATH_ENABLED) 49903 int mem_base; 49904 int ret_val; 49905 xmlXPathParserContextPtr ctxt; /* an XPath parser context */ 49906 int n_ctxt; 49907 49908 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 49909 mem_base = xmlMemBlocks(); 49910 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 49911 49912 ret_val = xmlXPathPopBoolean(ctxt); 49913 desret_int(ret_val); 49914 call_tests++; 49915 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 49916 xmlResetLastError(); 49917 if (mem_base != xmlMemBlocks()) { 49918 printf("Leak of %d blocks found in xmlXPathPopBoolean", 49919 xmlMemBlocks() - mem_base); 49920 test_ret++; 49921 printf(" %d", n_ctxt); 49922 printf("\n"); 49923 } 49924 } 49925 function_tests++; 49926 #endif 49927 49928 return(test_ret); 49929 } 49930 49931 49932 static int 49933 test_xmlXPathPopExternal(void) { 49934 int test_ret = 0; 49935 49936 #if defined(LIBXML_XPATH_ENABLED) 49937 int mem_base; 49938 void * ret_val; 49939 xmlXPathParserContextPtr ctxt; /* an XPath parser context */ 49940 int n_ctxt; 49941 49942 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 49943 mem_base = xmlMemBlocks(); 49944 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 49945 49946 ret_val = xmlXPathPopExternal(ctxt); 49947 desret_void_ptr(ret_val); 49948 call_tests++; 49949 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 49950 xmlResetLastError(); 49951 if (mem_base != xmlMemBlocks()) { 49952 printf("Leak of %d blocks found in xmlXPathPopExternal", 49953 xmlMemBlocks() - mem_base); 49954 test_ret++; 49955 printf(" %d", n_ctxt); 49956 printf("\n"); 49957 } 49958 } 49959 function_tests++; 49960 #endif 49961 49962 return(test_ret); 49963 } 49964 49965 49966 static int 49967 test_xmlXPathPopNodeSet(void) { 49968 int test_ret = 0; 49969 49970 #if defined(LIBXML_XPATH_ENABLED) 49971 int mem_base; 49972 xmlNodeSetPtr ret_val; 49973 xmlXPathParserContextPtr ctxt; /* an XPath parser context */ 49974 int n_ctxt; 49975 49976 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 49977 mem_base = xmlMemBlocks(); 49978 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 49979 49980 ret_val = xmlXPathPopNodeSet(ctxt); 49981 desret_xmlNodeSetPtr(ret_val); 49982 call_tests++; 49983 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 49984 xmlResetLastError(); 49985 if (mem_base != xmlMemBlocks()) { 49986 printf("Leak of %d blocks found in xmlXPathPopNodeSet", 49987 xmlMemBlocks() - mem_base); 49988 test_ret++; 49989 printf(" %d", n_ctxt); 49990 printf("\n"); 49991 } 49992 } 49993 function_tests++; 49994 #endif 49995 49996 return(test_ret); 49997 } 49998 49999 50000 static int 50001 test_xmlXPathPopNumber(void) { 50002 int test_ret = 0; 50003 50004 #if defined(LIBXML_XPATH_ENABLED) 50005 int mem_base; 50006 double ret_val; 50007 xmlXPathParserContextPtr ctxt; /* an XPath parser context */ 50008 int n_ctxt; 50009 50010 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 50011 mem_base = xmlMemBlocks(); 50012 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 50013 50014 ret_val = xmlXPathPopNumber(ctxt); 50015 desret_double(ret_val); 50016 call_tests++; 50017 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 50018 xmlResetLastError(); 50019 if (mem_base != xmlMemBlocks()) { 50020 printf("Leak of %d blocks found in xmlXPathPopNumber", 50021 xmlMemBlocks() - mem_base); 50022 test_ret++; 50023 printf(" %d", n_ctxt); 50024 printf("\n"); 50025 } 50026 } 50027 function_tests++; 50028 #endif 50029 50030 return(test_ret); 50031 } 50032 50033 50034 static int 50035 test_xmlXPathPopString(void) { 50036 int test_ret = 0; 50037 50038 #if defined(LIBXML_XPATH_ENABLED) 50039 int mem_base; 50040 xmlChar * ret_val; 50041 xmlXPathParserContextPtr ctxt; /* an XPath parser context */ 50042 int n_ctxt; 50043 50044 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 50045 mem_base = xmlMemBlocks(); 50046 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 50047 50048 ret_val = xmlXPathPopString(ctxt); 50049 desret_xmlChar_ptr(ret_val); 50050 call_tests++; 50051 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 50052 xmlResetLastError(); 50053 if (mem_base != xmlMemBlocks()) { 50054 printf("Leak of %d blocks found in xmlXPathPopString", 50055 xmlMemBlocks() - mem_base); 50056 test_ret++; 50057 printf(" %d", n_ctxt); 50058 printf("\n"); 50059 } 50060 } 50061 function_tests++; 50062 #endif 50063 50064 return(test_ret); 50065 } 50066 50067 50068 static int 50069 test_xmlXPathPositionFunction(void) { 50070 int test_ret = 0; 50071 50072 #if defined(LIBXML_XPATH_ENABLED) 50073 int mem_base; 50074 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 50075 int n_ctxt; 50076 int nargs; /* the number of arguments */ 50077 int n_nargs; 50078 50079 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 50080 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 50081 mem_base = xmlMemBlocks(); 50082 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 50083 nargs = gen_int(n_nargs, 1); 50084 50085 xmlXPathPositionFunction(ctxt, nargs); 50086 call_tests++; 50087 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 50088 des_int(n_nargs, nargs, 1); 50089 xmlResetLastError(); 50090 if (mem_base != xmlMemBlocks()) { 50091 printf("Leak of %d blocks found in xmlXPathPositionFunction", 50092 xmlMemBlocks() - mem_base); 50093 test_ret++; 50094 printf(" %d", n_ctxt); 50095 printf(" %d", n_nargs); 50096 printf("\n"); 50097 } 50098 } 50099 } 50100 function_tests++; 50101 #endif 50102 50103 return(test_ret); 50104 } 50105 50106 50107 static int 50108 test_xmlXPathRegisterAllFunctions(void) { 50109 int test_ret = 0; 50110 50111 #if defined(LIBXML_XPATH_ENABLED) 50112 int mem_base; 50113 xmlXPathContextPtr ctxt; /* the XPath context */ 50114 int n_ctxt; 50115 50116 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) { 50117 mem_base = xmlMemBlocks(); 50118 ctxt = gen_xmlXPathContextPtr(n_ctxt, 0); 50119 50120 xmlXPathRegisterAllFunctions(ctxt); 50121 call_tests++; 50122 des_xmlXPathContextPtr(n_ctxt, ctxt, 0); 50123 xmlResetLastError(); 50124 if (mem_base != xmlMemBlocks()) { 50125 printf("Leak of %d blocks found in xmlXPathRegisterAllFunctions", 50126 xmlMemBlocks() - mem_base); 50127 test_ret++; 50128 printf(" %d", n_ctxt); 50129 printf("\n"); 50130 } 50131 } 50132 function_tests++; 50133 #endif 50134 50135 return(test_ret); 50136 } 50137 50138 50139 static int 50140 test_xmlXPathRegisterFunc(void) { 50141 int test_ret = 0; 50142 50143 50144 /* missing type support */ 50145 return(test_ret); 50146 } 50147 50148 50149 static int 50150 test_xmlXPathRegisterFuncLookup(void) { 50151 int test_ret = 0; 50152 50153 50154 /* missing type support */ 50155 return(test_ret); 50156 } 50157 50158 50159 static int 50160 test_xmlXPathRegisterFuncNS(void) { 50161 int test_ret = 0; 50162 50163 50164 /* missing type support */ 50165 return(test_ret); 50166 } 50167 50168 50169 static int 50170 test_xmlXPathRegisterNs(void) { 50171 int test_ret = 0; 50172 50173 #if defined(LIBXML_XPATH_ENABLED) 50174 int mem_base; 50175 int ret_val; 50176 xmlXPathContextPtr ctxt; /* the XPath context */ 50177 int n_ctxt; 50178 xmlChar * prefix; /* the namespace prefix cannot be NULL or empty string */ 50179 int n_prefix; 50180 xmlChar * ns_uri; /* the namespace name */ 50181 int n_ns_uri; 50182 50183 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) { 50184 for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) { 50185 for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) { 50186 mem_base = xmlMemBlocks(); 50187 ctxt = gen_xmlXPathContextPtr(n_ctxt, 0); 50188 prefix = gen_const_xmlChar_ptr(n_prefix, 1); 50189 ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2); 50190 50191 ret_val = xmlXPathRegisterNs(ctxt, (const xmlChar *)prefix, (const xmlChar *)ns_uri); 50192 desret_int(ret_val); 50193 call_tests++; 50194 des_xmlXPathContextPtr(n_ctxt, ctxt, 0); 50195 des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1); 50196 des_const_xmlChar_ptr(n_ns_uri, (const xmlChar *)ns_uri, 2); 50197 xmlResetLastError(); 50198 if (mem_base != xmlMemBlocks()) { 50199 printf("Leak of %d blocks found in xmlXPathRegisterNs", 50200 xmlMemBlocks() - mem_base); 50201 test_ret++; 50202 printf(" %d", n_ctxt); 50203 printf(" %d", n_prefix); 50204 printf(" %d", n_ns_uri); 50205 printf("\n"); 50206 } 50207 } 50208 } 50209 } 50210 function_tests++; 50211 #endif 50212 50213 return(test_ret); 50214 } 50215 50216 50217 static int 50218 test_xmlXPathRegisterVariable(void) { 50219 int test_ret = 0; 50220 50221 #if defined(LIBXML_XPATH_ENABLED) 50222 int mem_base; 50223 int ret_val; 50224 xmlXPathContextPtr ctxt; /* the XPath context */ 50225 int n_ctxt; 50226 xmlChar * name; /* the variable name */ 50227 int n_name; 50228 xmlXPathObjectPtr value; /* the variable value or NULL */ 50229 int n_value; 50230 50231 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) { 50232 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 50233 for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) { 50234 mem_base = xmlMemBlocks(); 50235 ctxt = gen_xmlXPathContextPtr(n_ctxt, 0); 50236 name = gen_const_xmlChar_ptr(n_name, 1); 50237 value = gen_xmlXPathObjectPtr(n_value, 2); 50238 50239 ret_val = xmlXPathRegisterVariable(ctxt, (const xmlChar *)name, value); 50240 desret_int(ret_val); 50241 call_tests++; 50242 des_xmlXPathContextPtr(n_ctxt, ctxt, 0); 50243 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 50244 des_xmlXPathObjectPtr(n_value, value, 2); 50245 xmlResetLastError(); 50246 if (mem_base != xmlMemBlocks()) { 50247 printf("Leak of %d blocks found in xmlXPathRegisterVariable", 50248 xmlMemBlocks() - mem_base); 50249 test_ret++; 50250 printf(" %d", n_ctxt); 50251 printf(" %d", n_name); 50252 printf(" %d", n_value); 50253 printf("\n"); 50254 } 50255 } 50256 } 50257 } 50258 function_tests++; 50259 #endif 50260 50261 return(test_ret); 50262 } 50263 50264 50265 static int 50266 test_xmlXPathRegisterVariableLookup(void) { 50267 int test_ret = 0; 50268 50269 50270 /* missing type support */ 50271 return(test_ret); 50272 } 50273 50274 50275 static int 50276 test_xmlXPathRegisterVariableNS(void) { 50277 int test_ret = 0; 50278 50279 #if defined(LIBXML_XPATH_ENABLED) 50280 int mem_base; 50281 int ret_val; 50282 xmlXPathContextPtr ctxt; /* the XPath context */ 50283 int n_ctxt; 50284 xmlChar * name; /* the variable name */ 50285 int n_name; 50286 xmlChar * ns_uri; /* the variable namespace URI */ 50287 int n_ns_uri; 50288 xmlXPathObjectPtr value; /* the variable value or NULL */ 50289 int n_value; 50290 50291 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) { 50292 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 50293 for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) { 50294 for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) { 50295 mem_base = xmlMemBlocks(); 50296 ctxt = gen_xmlXPathContextPtr(n_ctxt, 0); 50297 name = gen_const_xmlChar_ptr(n_name, 1); 50298 ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2); 50299 value = gen_xmlXPathObjectPtr(n_value, 3); 50300 50301 ret_val = xmlXPathRegisterVariableNS(ctxt, (const xmlChar *)name, (const xmlChar *)ns_uri, value); 50302 desret_int(ret_val); 50303 call_tests++; 50304 des_xmlXPathContextPtr(n_ctxt, ctxt, 0); 50305 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 50306 des_const_xmlChar_ptr(n_ns_uri, (const xmlChar *)ns_uri, 2); 50307 des_xmlXPathObjectPtr(n_value, value, 3); 50308 xmlResetLastError(); 50309 if (mem_base != xmlMemBlocks()) { 50310 printf("Leak of %d blocks found in xmlXPathRegisterVariableNS", 50311 xmlMemBlocks() - mem_base); 50312 test_ret++; 50313 printf(" %d", n_ctxt); 50314 printf(" %d", n_name); 50315 printf(" %d", n_ns_uri); 50316 printf(" %d", n_value); 50317 printf("\n"); 50318 } 50319 } 50320 } 50321 } 50322 } 50323 function_tests++; 50324 #endif 50325 50326 return(test_ret); 50327 } 50328 50329 50330 static int 50331 test_xmlXPathRegisteredFuncsCleanup(void) { 50332 int test_ret = 0; 50333 50334 #if defined(LIBXML_XPATH_ENABLED) 50335 int mem_base; 50336 xmlXPathContextPtr ctxt; /* the XPath context */ 50337 int n_ctxt; 50338 50339 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) { 50340 mem_base = xmlMemBlocks(); 50341 ctxt = gen_xmlXPathContextPtr(n_ctxt, 0); 50342 50343 xmlXPathRegisteredFuncsCleanup(ctxt); 50344 call_tests++; 50345 des_xmlXPathContextPtr(n_ctxt, ctxt, 0); 50346 xmlResetLastError(); 50347 if (mem_base != xmlMemBlocks()) { 50348 printf("Leak of %d blocks found in xmlXPathRegisteredFuncsCleanup", 50349 xmlMemBlocks() - mem_base); 50350 test_ret++; 50351 printf(" %d", n_ctxt); 50352 printf("\n"); 50353 } 50354 } 50355 function_tests++; 50356 #endif 50357 50358 return(test_ret); 50359 } 50360 50361 50362 static int 50363 test_xmlXPathRegisteredNsCleanup(void) { 50364 int test_ret = 0; 50365 50366 #if defined(LIBXML_XPATH_ENABLED) 50367 int mem_base; 50368 xmlXPathContextPtr ctxt; /* the XPath context */ 50369 int n_ctxt; 50370 50371 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) { 50372 mem_base = xmlMemBlocks(); 50373 ctxt = gen_xmlXPathContextPtr(n_ctxt, 0); 50374 50375 xmlXPathRegisteredNsCleanup(ctxt); 50376 call_tests++; 50377 des_xmlXPathContextPtr(n_ctxt, ctxt, 0); 50378 xmlResetLastError(); 50379 if (mem_base != xmlMemBlocks()) { 50380 printf("Leak of %d blocks found in xmlXPathRegisteredNsCleanup", 50381 xmlMemBlocks() - mem_base); 50382 test_ret++; 50383 printf(" %d", n_ctxt); 50384 printf("\n"); 50385 } 50386 } 50387 function_tests++; 50388 #endif 50389 50390 return(test_ret); 50391 } 50392 50393 50394 static int 50395 test_xmlXPathRegisteredVariablesCleanup(void) { 50396 int test_ret = 0; 50397 50398 #if defined(LIBXML_XPATH_ENABLED) 50399 int mem_base; 50400 xmlXPathContextPtr ctxt; /* the XPath context */ 50401 int n_ctxt; 50402 50403 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) { 50404 mem_base = xmlMemBlocks(); 50405 ctxt = gen_xmlXPathContextPtr(n_ctxt, 0); 50406 50407 xmlXPathRegisteredVariablesCleanup(ctxt); 50408 call_tests++; 50409 des_xmlXPathContextPtr(n_ctxt, ctxt, 0); 50410 xmlResetLastError(); 50411 if (mem_base != xmlMemBlocks()) { 50412 printf("Leak of %d blocks found in xmlXPathRegisteredVariablesCleanup", 50413 xmlMemBlocks() - mem_base); 50414 test_ret++; 50415 printf(" %d", n_ctxt); 50416 printf("\n"); 50417 } 50418 } 50419 function_tests++; 50420 #endif 50421 50422 return(test_ret); 50423 } 50424 50425 50426 static int 50427 test_xmlXPathRoot(void) { 50428 int test_ret = 0; 50429 50430 #if defined(LIBXML_XPATH_ENABLED) 50431 int mem_base; 50432 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 50433 int n_ctxt; 50434 50435 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 50436 mem_base = xmlMemBlocks(); 50437 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 50438 50439 xmlXPathRoot(ctxt); 50440 call_tests++; 50441 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 50442 xmlResetLastError(); 50443 if (mem_base != xmlMemBlocks()) { 50444 printf("Leak of %d blocks found in xmlXPathRoot", 50445 xmlMemBlocks() - mem_base); 50446 test_ret++; 50447 printf(" %d", n_ctxt); 50448 printf("\n"); 50449 } 50450 } 50451 function_tests++; 50452 #endif 50453 50454 return(test_ret); 50455 } 50456 50457 50458 static int 50459 test_xmlXPathRoundFunction(void) { 50460 int test_ret = 0; 50461 50462 #if defined(LIBXML_XPATH_ENABLED) 50463 int mem_base; 50464 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 50465 int n_ctxt; 50466 int nargs; /* the number of arguments */ 50467 int n_nargs; 50468 50469 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 50470 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 50471 mem_base = xmlMemBlocks(); 50472 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 50473 nargs = gen_int(n_nargs, 1); 50474 50475 xmlXPathRoundFunction(ctxt, nargs); 50476 call_tests++; 50477 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 50478 des_int(n_nargs, nargs, 1); 50479 xmlResetLastError(); 50480 if (mem_base != xmlMemBlocks()) { 50481 printf("Leak of %d blocks found in xmlXPathRoundFunction", 50482 xmlMemBlocks() - mem_base); 50483 test_ret++; 50484 printf(" %d", n_ctxt); 50485 printf(" %d", n_nargs); 50486 printf("\n"); 50487 } 50488 } 50489 } 50490 function_tests++; 50491 #endif 50492 50493 return(test_ret); 50494 } 50495 50496 50497 static int 50498 test_xmlXPathStartsWithFunction(void) { 50499 int test_ret = 0; 50500 50501 #if defined(LIBXML_XPATH_ENABLED) 50502 int mem_base; 50503 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 50504 int n_ctxt; 50505 int nargs; /* the number of arguments */ 50506 int n_nargs; 50507 50508 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 50509 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 50510 mem_base = xmlMemBlocks(); 50511 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 50512 nargs = gen_int(n_nargs, 1); 50513 50514 xmlXPathStartsWithFunction(ctxt, nargs); 50515 call_tests++; 50516 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 50517 des_int(n_nargs, nargs, 1); 50518 xmlResetLastError(); 50519 if (mem_base != xmlMemBlocks()) { 50520 printf("Leak of %d blocks found in xmlXPathStartsWithFunction", 50521 xmlMemBlocks() - mem_base); 50522 test_ret++; 50523 printf(" %d", n_ctxt); 50524 printf(" %d", n_nargs); 50525 printf("\n"); 50526 } 50527 } 50528 } 50529 function_tests++; 50530 #endif 50531 50532 return(test_ret); 50533 } 50534 50535 50536 static int 50537 test_xmlXPathStringEvalNumber(void) { 50538 int test_ret = 0; 50539 50540 #if defined(LIBXML_XPATH_ENABLED) 50541 int mem_base; 50542 double ret_val; 50543 xmlChar * str; /* A string to scan */ 50544 int n_str; 50545 50546 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 50547 mem_base = xmlMemBlocks(); 50548 str = gen_const_xmlChar_ptr(n_str, 0); 50549 50550 ret_val = xmlXPathStringEvalNumber((const xmlChar *)str); 50551 desret_double(ret_val); 50552 call_tests++; 50553 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); 50554 xmlResetLastError(); 50555 if (mem_base != xmlMemBlocks()) { 50556 printf("Leak of %d blocks found in xmlXPathStringEvalNumber", 50557 xmlMemBlocks() - mem_base); 50558 test_ret++; 50559 printf(" %d", n_str); 50560 printf("\n"); 50561 } 50562 } 50563 function_tests++; 50564 #endif 50565 50566 return(test_ret); 50567 } 50568 50569 50570 static int 50571 test_xmlXPathStringFunction(void) { 50572 int test_ret = 0; 50573 50574 #if defined(LIBXML_XPATH_ENABLED) 50575 int mem_base; 50576 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 50577 int n_ctxt; 50578 int nargs; /* the number of arguments */ 50579 int n_nargs; 50580 50581 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 50582 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 50583 mem_base = xmlMemBlocks(); 50584 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 50585 nargs = gen_int(n_nargs, 1); 50586 50587 xmlXPathStringFunction(ctxt, nargs); 50588 call_tests++; 50589 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 50590 des_int(n_nargs, nargs, 1); 50591 xmlResetLastError(); 50592 if (mem_base != xmlMemBlocks()) { 50593 printf("Leak of %d blocks found in xmlXPathStringFunction", 50594 xmlMemBlocks() - mem_base); 50595 test_ret++; 50596 printf(" %d", n_ctxt); 50597 printf(" %d", n_nargs); 50598 printf("\n"); 50599 } 50600 } 50601 } 50602 function_tests++; 50603 #endif 50604 50605 return(test_ret); 50606 } 50607 50608 50609 static int 50610 test_xmlXPathStringLengthFunction(void) { 50611 int test_ret = 0; 50612 50613 #if defined(LIBXML_XPATH_ENABLED) 50614 int mem_base; 50615 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 50616 int n_ctxt; 50617 int nargs; /* the number of arguments */ 50618 int n_nargs; 50619 50620 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 50621 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 50622 mem_base = xmlMemBlocks(); 50623 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 50624 nargs = gen_int(n_nargs, 1); 50625 50626 xmlXPathStringLengthFunction(ctxt, nargs); 50627 call_tests++; 50628 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 50629 des_int(n_nargs, nargs, 1); 50630 xmlResetLastError(); 50631 if (mem_base != xmlMemBlocks()) { 50632 printf("Leak of %d blocks found in xmlXPathStringLengthFunction", 50633 xmlMemBlocks() - mem_base); 50634 test_ret++; 50635 printf(" %d", n_ctxt); 50636 printf(" %d", n_nargs); 50637 printf("\n"); 50638 } 50639 } 50640 } 50641 function_tests++; 50642 #endif 50643 50644 return(test_ret); 50645 } 50646 50647 50648 static int 50649 test_xmlXPathSubValues(void) { 50650 int test_ret = 0; 50651 50652 #if defined(LIBXML_XPATH_ENABLED) 50653 int mem_base; 50654 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 50655 int n_ctxt; 50656 50657 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 50658 mem_base = xmlMemBlocks(); 50659 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 50660 50661 xmlXPathSubValues(ctxt); 50662 call_tests++; 50663 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 50664 xmlResetLastError(); 50665 if (mem_base != xmlMemBlocks()) { 50666 printf("Leak of %d blocks found in xmlXPathSubValues", 50667 xmlMemBlocks() - mem_base); 50668 test_ret++; 50669 printf(" %d", n_ctxt); 50670 printf("\n"); 50671 } 50672 } 50673 function_tests++; 50674 #endif 50675 50676 return(test_ret); 50677 } 50678 50679 50680 static int 50681 test_xmlXPathSubstringAfterFunction(void) { 50682 int test_ret = 0; 50683 50684 #if defined(LIBXML_XPATH_ENABLED) 50685 int mem_base; 50686 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 50687 int n_ctxt; 50688 int nargs; /* the number of arguments */ 50689 int n_nargs; 50690 50691 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 50692 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 50693 mem_base = xmlMemBlocks(); 50694 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 50695 nargs = gen_int(n_nargs, 1); 50696 50697 xmlXPathSubstringAfterFunction(ctxt, nargs); 50698 call_tests++; 50699 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 50700 des_int(n_nargs, nargs, 1); 50701 xmlResetLastError(); 50702 if (mem_base != xmlMemBlocks()) { 50703 printf("Leak of %d blocks found in xmlXPathSubstringAfterFunction", 50704 xmlMemBlocks() - mem_base); 50705 test_ret++; 50706 printf(" %d", n_ctxt); 50707 printf(" %d", n_nargs); 50708 printf("\n"); 50709 } 50710 } 50711 } 50712 function_tests++; 50713 #endif 50714 50715 return(test_ret); 50716 } 50717 50718 50719 static int 50720 test_xmlXPathSubstringBeforeFunction(void) { 50721 int test_ret = 0; 50722 50723 #if defined(LIBXML_XPATH_ENABLED) 50724 int mem_base; 50725 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 50726 int n_ctxt; 50727 int nargs; /* the number of arguments */ 50728 int n_nargs; 50729 50730 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 50731 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 50732 mem_base = xmlMemBlocks(); 50733 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 50734 nargs = gen_int(n_nargs, 1); 50735 50736 xmlXPathSubstringBeforeFunction(ctxt, nargs); 50737 call_tests++; 50738 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 50739 des_int(n_nargs, nargs, 1); 50740 xmlResetLastError(); 50741 if (mem_base != xmlMemBlocks()) { 50742 printf("Leak of %d blocks found in xmlXPathSubstringBeforeFunction", 50743 xmlMemBlocks() - mem_base); 50744 test_ret++; 50745 printf(" %d", n_ctxt); 50746 printf(" %d", n_nargs); 50747 printf("\n"); 50748 } 50749 } 50750 } 50751 function_tests++; 50752 #endif 50753 50754 return(test_ret); 50755 } 50756 50757 50758 static int 50759 test_xmlXPathSubstringFunction(void) { 50760 int test_ret = 0; 50761 50762 #if defined(LIBXML_XPATH_ENABLED) 50763 int mem_base; 50764 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 50765 int n_ctxt; 50766 int nargs; /* the number of arguments */ 50767 int n_nargs; 50768 50769 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 50770 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 50771 mem_base = xmlMemBlocks(); 50772 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 50773 nargs = gen_int(n_nargs, 1); 50774 50775 xmlXPathSubstringFunction(ctxt, nargs); 50776 call_tests++; 50777 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 50778 des_int(n_nargs, nargs, 1); 50779 xmlResetLastError(); 50780 if (mem_base != xmlMemBlocks()) { 50781 printf("Leak of %d blocks found in xmlXPathSubstringFunction", 50782 xmlMemBlocks() - mem_base); 50783 test_ret++; 50784 printf(" %d", n_ctxt); 50785 printf(" %d", n_nargs); 50786 printf("\n"); 50787 } 50788 } 50789 } 50790 function_tests++; 50791 #endif 50792 50793 return(test_ret); 50794 } 50795 50796 50797 static int 50798 test_xmlXPathSumFunction(void) { 50799 int test_ret = 0; 50800 50801 #if defined(LIBXML_XPATH_ENABLED) 50802 int mem_base; 50803 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 50804 int n_ctxt; 50805 int nargs; /* the number of arguments */ 50806 int n_nargs; 50807 50808 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 50809 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 50810 mem_base = xmlMemBlocks(); 50811 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 50812 nargs = gen_int(n_nargs, 1); 50813 50814 xmlXPathSumFunction(ctxt, nargs); 50815 call_tests++; 50816 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 50817 des_int(n_nargs, nargs, 1); 50818 xmlResetLastError(); 50819 if (mem_base != xmlMemBlocks()) { 50820 printf("Leak of %d blocks found in xmlXPathSumFunction", 50821 xmlMemBlocks() - mem_base); 50822 test_ret++; 50823 printf(" %d", n_ctxt); 50824 printf(" %d", n_nargs); 50825 printf("\n"); 50826 } 50827 } 50828 } 50829 function_tests++; 50830 #endif 50831 50832 return(test_ret); 50833 } 50834 50835 50836 static int 50837 test_xmlXPathTrailing(void) { 50838 int test_ret = 0; 50839 50840 #if defined(LIBXML_XPATH_ENABLED) 50841 int mem_base; 50842 xmlNodeSetPtr ret_val; 50843 xmlNodeSetPtr nodes1; /* a node-set */ 50844 int n_nodes1; 50845 xmlNodeSetPtr nodes2; /* a node-set */ 50846 int n_nodes2; 50847 50848 for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) { 50849 for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) { 50850 mem_base = xmlMemBlocks(); 50851 nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0); 50852 nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1); 50853 50854 ret_val = xmlXPathTrailing(nodes1, nodes2); 50855 desret_xmlNodeSetPtr(ret_val); 50856 call_tests++; 50857 des_xmlNodeSetPtr(n_nodes1, nodes1, 0); 50858 des_xmlNodeSetPtr(n_nodes2, nodes2, 1); 50859 xmlResetLastError(); 50860 if (mem_base != xmlMemBlocks()) { 50861 printf("Leak of %d blocks found in xmlXPathTrailing", 50862 xmlMemBlocks() - mem_base); 50863 test_ret++; 50864 printf(" %d", n_nodes1); 50865 printf(" %d", n_nodes2); 50866 printf("\n"); 50867 } 50868 } 50869 } 50870 function_tests++; 50871 #endif 50872 50873 return(test_ret); 50874 } 50875 50876 50877 static int 50878 test_xmlXPathTrailingSorted(void) { 50879 int test_ret = 0; 50880 50881 #if defined(LIBXML_XPATH_ENABLED) 50882 int mem_base; 50883 xmlNodeSetPtr ret_val; 50884 xmlNodeSetPtr nodes1; /* a node-set, sorted by document order */ 50885 int n_nodes1; 50886 xmlNodeSetPtr nodes2; /* a node-set, sorted by document order */ 50887 int n_nodes2; 50888 50889 for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) { 50890 for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) { 50891 mem_base = xmlMemBlocks(); 50892 nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0); 50893 nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1); 50894 50895 ret_val = xmlXPathTrailingSorted(nodes1, nodes2); 50896 desret_xmlNodeSetPtr(ret_val); 50897 call_tests++; 50898 des_xmlNodeSetPtr(n_nodes1, nodes1, 0); 50899 des_xmlNodeSetPtr(n_nodes2, nodes2, 1); 50900 xmlResetLastError(); 50901 if (mem_base != xmlMemBlocks()) { 50902 printf("Leak of %d blocks found in xmlXPathTrailingSorted", 50903 xmlMemBlocks() - mem_base); 50904 test_ret++; 50905 printf(" %d", n_nodes1); 50906 printf(" %d", n_nodes2); 50907 printf("\n"); 50908 } 50909 } 50910 } 50911 function_tests++; 50912 #endif 50913 50914 return(test_ret); 50915 } 50916 50917 50918 static int 50919 test_xmlXPathTranslateFunction(void) { 50920 int test_ret = 0; 50921 50922 #if defined(LIBXML_XPATH_ENABLED) 50923 int mem_base; 50924 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 50925 int n_ctxt; 50926 int nargs; /* the number of arguments */ 50927 int n_nargs; 50928 50929 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 50930 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 50931 mem_base = xmlMemBlocks(); 50932 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 50933 nargs = gen_int(n_nargs, 1); 50934 50935 xmlXPathTranslateFunction(ctxt, nargs); 50936 call_tests++; 50937 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 50938 des_int(n_nargs, nargs, 1); 50939 xmlResetLastError(); 50940 if (mem_base != xmlMemBlocks()) { 50941 printf("Leak of %d blocks found in xmlXPathTranslateFunction", 50942 xmlMemBlocks() - mem_base); 50943 test_ret++; 50944 printf(" %d", n_ctxt); 50945 printf(" %d", n_nargs); 50946 printf("\n"); 50947 } 50948 } 50949 } 50950 function_tests++; 50951 #endif 50952 50953 return(test_ret); 50954 } 50955 50956 50957 static int 50958 test_xmlXPathTrueFunction(void) { 50959 int test_ret = 0; 50960 50961 #if defined(LIBXML_XPATH_ENABLED) 50962 int mem_base; 50963 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 50964 int n_ctxt; 50965 int nargs; /* the number of arguments */ 50966 int n_nargs; 50967 50968 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 50969 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 50970 mem_base = xmlMemBlocks(); 50971 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 50972 nargs = gen_int(n_nargs, 1); 50973 50974 xmlXPathTrueFunction(ctxt, nargs); 50975 call_tests++; 50976 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 50977 des_int(n_nargs, nargs, 1); 50978 xmlResetLastError(); 50979 if (mem_base != xmlMemBlocks()) { 50980 printf("Leak of %d blocks found in xmlXPathTrueFunction", 50981 xmlMemBlocks() - mem_base); 50982 test_ret++; 50983 printf(" %d", n_ctxt); 50984 printf(" %d", n_nargs); 50985 printf("\n"); 50986 } 50987 } 50988 } 50989 function_tests++; 50990 #endif 50991 50992 return(test_ret); 50993 } 50994 50995 50996 static int 50997 test_xmlXPathValueFlipSign(void) { 50998 int test_ret = 0; 50999 51000 #if defined(LIBXML_XPATH_ENABLED) 51001 int mem_base; 51002 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 51003 int n_ctxt; 51004 51005 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 51006 mem_base = xmlMemBlocks(); 51007 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 51008 51009 xmlXPathValueFlipSign(ctxt); 51010 call_tests++; 51011 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 51012 xmlResetLastError(); 51013 if (mem_base != xmlMemBlocks()) { 51014 printf("Leak of %d blocks found in xmlXPathValueFlipSign", 51015 xmlMemBlocks() - mem_base); 51016 test_ret++; 51017 printf(" %d", n_ctxt); 51018 printf("\n"); 51019 } 51020 } 51021 function_tests++; 51022 #endif 51023 51024 return(test_ret); 51025 } 51026 51027 51028 static int 51029 test_xmlXPathVariableLookup(void) { 51030 int test_ret = 0; 51031 51032 #if defined(LIBXML_XPATH_ENABLED) 51033 int mem_base; 51034 xmlXPathObjectPtr ret_val; 51035 xmlXPathContextPtr ctxt; /* the XPath context */ 51036 int n_ctxt; 51037 xmlChar * name; /* the variable name */ 51038 int n_name; 51039 51040 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) { 51041 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 51042 mem_base = xmlMemBlocks(); 51043 ctxt = gen_xmlXPathContextPtr(n_ctxt, 0); 51044 name = gen_const_xmlChar_ptr(n_name, 1); 51045 51046 ret_val = xmlXPathVariableLookup(ctxt, (const xmlChar *)name); 51047 desret_xmlXPathObjectPtr(ret_val); 51048 call_tests++; 51049 des_xmlXPathContextPtr(n_ctxt, ctxt, 0); 51050 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 51051 xmlResetLastError(); 51052 if (mem_base != xmlMemBlocks()) { 51053 printf("Leak of %d blocks found in xmlXPathVariableLookup", 51054 xmlMemBlocks() - mem_base); 51055 test_ret++; 51056 printf(" %d", n_ctxt); 51057 printf(" %d", n_name); 51058 printf("\n"); 51059 } 51060 } 51061 } 51062 function_tests++; 51063 #endif 51064 51065 return(test_ret); 51066 } 51067 51068 51069 static int 51070 test_xmlXPathVariableLookupNS(void) { 51071 int test_ret = 0; 51072 51073 #if defined(LIBXML_XPATH_ENABLED) 51074 int mem_base; 51075 xmlXPathObjectPtr ret_val; 51076 xmlXPathContextPtr ctxt; /* the XPath context */ 51077 int n_ctxt; 51078 xmlChar * name; /* the variable name */ 51079 int n_name; 51080 xmlChar * ns_uri; /* the variable namespace URI */ 51081 int n_ns_uri; 51082 51083 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) { 51084 for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) { 51085 for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) { 51086 mem_base = xmlMemBlocks(); 51087 ctxt = gen_xmlXPathContextPtr(n_ctxt, 0); 51088 name = gen_const_xmlChar_ptr(n_name, 1); 51089 ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2); 51090 51091 ret_val = xmlXPathVariableLookupNS(ctxt, (const xmlChar *)name, (const xmlChar *)ns_uri); 51092 desret_xmlXPathObjectPtr(ret_val); 51093 call_tests++; 51094 des_xmlXPathContextPtr(n_ctxt, ctxt, 0); 51095 des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1); 51096 des_const_xmlChar_ptr(n_ns_uri, (const xmlChar *)ns_uri, 2); 51097 xmlResetLastError(); 51098 if (mem_base != xmlMemBlocks()) { 51099 printf("Leak of %d blocks found in xmlXPathVariableLookupNS", 51100 xmlMemBlocks() - mem_base); 51101 test_ret++; 51102 printf(" %d", n_ctxt); 51103 printf(" %d", n_name); 51104 printf(" %d", n_ns_uri); 51105 printf("\n"); 51106 } 51107 } 51108 } 51109 } 51110 function_tests++; 51111 #endif 51112 51113 return(test_ret); 51114 } 51115 51116 51117 static int 51118 test_xmlXPathWrapCString(void) { 51119 int test_ret = 0; 51120 51121 #if defined(LIBXML_XPATH_ENABLED) 51122 int mem_base; 51123 xmlXPathObjectPtr ret_val; 51124 char * val; /* the char * value */ 51125 int n_val; 51126 51127 for (n_val = 0;n_val < gen_nb_char_ptr;n_val++) { 51128 mem_base = xmlMemBlocks(); 51129 val = gen_char_ptr(n_val, 0); 51130 51131 ret_val = xmlXPathWrapCString(val); 51132 desret_xmlXPathObjectPtr(ret_val); 51133 call_tests++; 51134 des_char_ptr(n_val, val, 0); 51135 xmlResetLastError(); 51136 if (mem_base != xmlMemBlocks()) { 51137 printf("Leak of %d blocks found in xmlXPathWrapCString", 51138 xmlMemBlocks() - mem_base); 51139 test_ret++; 51140 printf(" %d", n_val); 51141 printf("\n"); 51142 } 51143 } 51144 function_tests++; 51145 #endif 51146 51147 return(test_ret); 51148 } 51149 51150 51151 static int 51152 test_xmlXPathWrapExternal(void) { 51153 int test_ret = 0; 51154 51155 #if defined(LIBXML_XPATH_ENABLED) 51156 int mem_base; 51157 xmlXPathObjectPtr ret_val; 51158 void * val; /* the user data */ 51159 int n_val; 51160 51161 for (n_val = 0;n_val < gen_nb_void_ptr;n_val++) { 51162 mem_base = xmlMemBlocks(); 51163 val = gen_void_ptr(n_val, 0); 51164 51165 ret_val = xmlXPathWrapExternal(val); 51166 desret_xmlXPathObjectPtr(ret_val); 51167 call_tests++; 51168 des_void_ptr(n_val, val, 0); 51169 xmlResetLastError(); 51170 if (mem_base != xmlMemBlocks()) { 51171 printf("Leak of %d blocks found in xmlXPathWrapExternal", 51172 xmlMemBlocks() - mem_base); 51173 test_ret++; 51174 printf(" %d", n_val); 51175 printf("\n"); 51176 } 51177 } 51178 function_tests++; 51179 #endif 51180 51181 return(test_ret); 51182 } 51183 51184 51185 static int 51186 test_xmlXPathWrapNodeSet(void) { 51187 int test_ret = 0; 51188 51189 #if defined(LIBXML_XPATH_ENABLED) 51190 int mem_base; 51191 xmlXPathObjectPtr ret_val; 51192 xmlNodeSetPtr val; /* the NodePtr value */ 51193 int n_val; 51194 51195 for (n_val = 0;n_val < gen_nb_xmlNodeSetPtr;n_val++) { 51196 mem_base = xmlMemBlocks(); 51197 val = gen_xmlNodeSetPtr(n_val, 0); 51198 51199 ret_val = xmlXPathWrapNodeSet(val); 51200 desret_xmlXPathObjectPtr(ret_val); 51201 call_tests++; 51202 des_xmlNodeSetPtr(n_val, val, 0); 51203 xmlResetLastError(); 51204 if (mem_base != xmlMemBlocks()) { 51205 printf("Leak of %d blocks found in xmlXPathWrapNodeSet", 51206 xmlMemBlocks() - mem_base); 51207 test_ret++; 51208 printf(" %d", n_val); 51209 printf("\n"); 51210 } 51211 } 51212 function_tests++; 51213 #endif 51214 51215 return(test_ret); 51216 } 51217 51218 51219 static int 51220 test_xmlXPatherror(void) { 51221 int test_ret = 0; 51222 51223 #if defined(LIBXML_XPATH_ENABLED) 51224 int mem_base; 51225 xmlXPathParserContextPtr ctxt; /* the XPath Parser context */ 51226 int n_ctxt; 51227 const char * file; /* the file name */ 51228 int n_file; 51229 int line; /* the line number */ 51230 int n_line; 51231 int no; /* the error number */ 51232 int n_no; 51233 51234 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 51235 for (n_file = 0;n_file < gen_nb_filepath;n_file++) { 51236 for (n_line = 0;n_line < gen_nb_int;n_line++) { 51237 for (n_no = 0;n_no < gen_nb_int;n_no++) { 51238 mem_base = xmlMemBlocks(); 51239 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 51240 file = gen_filepath(n_file, 1); 51241 line = gen_int(n_line, 2); 51242 no = gen_int(n_no, 3); 51243 51244 xmlXPatherror(ctxt, file, line, no); 51245 call_tests++; 51246 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 51247 des_filepath(n_file, file, 1); 51248 des_int(n_line, line, 2); 51249 des_int(n_no, no, 3); 51250 xmlResetLastError(); 51251 if (mem_base != xmlMemBlocks()) { 51252 printf("Leak of %d blocks found in xmlXPatherror", 51253 xmlMemBlocks() - mem_base); 51254 test_ret++; 51255 printf(" %d", n_ctxt); 51256 printf(" %d", n_file); 51257 printf(" %d", n_line); 51258 printf(" %d", n_no); 51259 printf("\n"); 51260 } 51261 } 51262 } 51263 } 51264 } 51265 function_tests++; 51266 #endif 51267 51268 return(test_ret); 51269 } 51270 51271 static int 51272 test_xpathInternals(void) { 51273 int test_ret = 0; 51274 51275 if (quiet == 0) printf("Testing xpathInternals : 106 of 117 functions ...\n"); 51276 test_ret += test_valuePop(); 51277 test_ret += test_valuePush(); 51278 test_ret += test_xmlXPathAddValues(); 51279 test_ret += test_xmlXPathBooleanFunction(); 51280 test_ret += test_xmlXPathCeilingFunction(); 51281 test_ret += test_xmlXPathCompareValues(); 51282 test_ret += test_xmlXPathConcatFunction(); 51283 test_ret += test_xmlXPathContainsFunction(); 51284 test_ret += test_xmlXPathCountFunction(); 51285 test_ret += test_xmlXPathDebugDumpCompExpr(); 51286 test_ret += test_xmlXPathDebugDumpObject(); 51287 test_ret += test_xmlXPathDifference(); 51288 test_ret += test_xmlXPathDistinct(); 51289 test_ret += test_xmlXPathDistinctSorted(); 51290 test_ret += test_xmlXPathDivValues(); 51291 test_ret += test_xmlXPathEqualValues(); 51292 test_ret += test_xmlXPathErr(); 51293 test_ret += test_xmlXPathEvalExpr(); 51294 test_ret += test_xmlXPathEvaluatePredicateResult(); 51295 test_ret += test_xmlXPathFalseFunction(); 51296 test_ret += test_xmlXPathFloorFunction(); 51297 test_ret += test_xmlXPathFunctionLookup(); 51298 test_ret += test_xmlXPathFunctionLookupNS(); 51299 test_ret += test_xmlXPathHasSameNodes(); 51300 test_ret += test_xmlXPathIdFunction(); 51301 test_ret += test_xmlXPathIntersection(); 51302 test_ret += test_xmlXPathIsNodeType(); 51303 test_ret += test_xmlXPathLangFunction(); 51304 test_ret += test_xmlXPathLastFunction(); 51305 test_ret += test_xmlXPathLeading(); 51306 test_ret += test_xmlXPathLeadingSorted(); 51307 test_ret += test_xmlXPathLocalNameFunction(); 51308 test_ret += test_xmlXPathModValues(); 51309 test_ret += test_xmlXPathMultValues(); 51310 test_ret += test_xmlXPathNamespaceURIFunction(); 51311 test_ret += test_xmlXPathNewBoolean(); 51312 test_ret += test_xmlXPathNewCString(); 51313 test_ret += test_xmlXPathNewFloat(); 51314 test_ret += test_xmlXPathNewNodeSet(); 51315 test_ret += test_xmlXPathNewNodeSetList(); 51316 test_ret += test_xmlXPathNewParserContext(); 51317 test_ret += test_xmlXPathNewString(); 51318 test_ret += test_xmlXPathNextAncestor(); 51319 test_ret += test_xmlXPathNextAncestorOrSelf(); 51320 test_ret += test_xmlXPathNextAttribute(); 51321 test_ret += test_xmlXPathNextChild(); 51322 test_ret += test_xmlXPathNextDescendant(); 51323 test_ret += test_xmlXPathNextDescendantOrSelf(); 51324 test_ret += test_xmlXPathNextFollowing(); 51325 test_ret += test_xmlXPathNextFollowingSibling(); 51326 test_ret += test_xmlXPathNextNamespace(); 51327 test_ret += test_xmlXPathNextParent(); 51328 test_ret += test_xmlXPathNextPreceding(); 51329 test_ret += test_xmlXPathNextPrecedingSibling(); 51330 test_ret += test_xmlXPathNextSelf(); 51331 test_ret += test_xmlXPathNodeLeading(); 51332 test_ret += test_xmlXPathNodeLeadingSorted(); 51333 test_ret += test_xmlXPathNodeSetAdd(); 51334 test_ret += test_xmlXPathNodeSetAddNs(); 51335 test_ret += test_xmlXPathNodeSetAddUnique(); 51336 test_ret += test_xmlXPathNodeSetContains(); 51337 test_ret += test_xmlXPathNodeSetDel(); 51338 test_ret += test_xmlXPathNodeSetMerge(); 51339 test_ret += test_xmlXPathNodeSetRemove(); 51340 test_ret += test_xmlXPathNodeSetSort(); 51341 test_ret += test_xmlXPathNodeTrailing(); 51342 test_ret += test_xmlXPathNodeTrailingSorted(); 51343 test_ret += test_xmlXPathNormalizeFunction(); 51344 test_ret += test_xmlXPathNotEqualValues(); 51345 test_ret += test_xmlXPathNotFunction(); 51346 test_ret += test_xmlXPathNsLookup(); 51347 test_ret += test_xmlXPathNumberFunction(); 51348 test_ret += test_xmlXPathParseNCName(); 51349 test_ret += test_xmlXPathParseName(); 51350 test_ret += test_xmlXPathPopBoolean(); 51351 test_ret += test_xmlXPathPopExternal(); 51352 test_ret += test_xmlXPathPopNodeSet(); 51353 test_ret += test_xmlXPathPopNumber(); 51354 test_ret += test_xmlXPathPopString(); 51355 test_ret += test_xmlXPathPositionFunction(); 51356 test_ret += test_xmlXPathRegisterAllFunctions(); 51357 test_ret += test_xmlXPathRegisterFunc(); 51358 test_ret += test_xmlXPathRegisterFuncLookup(); 51359 test_ret += test_xmlXPathRegisterFuncNS(); 51360 test_ret += test_xmlXPathRegisterNs(); 51361 test_ret += test_xmlXPathRegisterVariable(); 51362 test_ret += test_xmlXPathRegisterVariableLookup(); 51363 test_ret += test_xmlXPathRegisterVariableNS(); 51364 test_ret += test_xmlXPathRegisteredFuncsCleanup(); 51365 test_ret += test_xmlXPathRegisteredNsCleanup(); 51366 test_ret += test_xmlXPathRegisteredVariablesCleanup(); 51367 test_ret += test_xmlXPathRoot(); 51368 test_ret += test_xmlXPathRoundFunction(); 51369 test_ret += test_xmlXPathStartsWithFunction(); 51370 test_ret += test_xmlXPathStringEvalNumber(); 51371 test_ret += test_xmlXPathStringFunction(); 51372 test_ret += test_xmlXPathStringLengthFunction(); 51373 test_ret += test_xmlXPathSubValues(); 51374 test_ret += test_xmlXPathSubstringAfterFunction(); 51375 test_ret += test_xmlXPathSubstringBeforeFunction(); 51376 test_ret += test_xmlXPathSubstringFunction(); 51377 test_ret += test_xmlXPathSumFunction(); 51378 test_ret += test_xmlXPathTrailing(); 51379 test_ret += test_xmlXPathTrailingSorted(); 51380 test_ret += test_xmlXPathTranslateFunction(); 51381 test_ret += test_xmlXPathTrueFunction(); 51382 test_ret += test_xmlXPathValueFlipSign(); 51383 test_ret += test_xmlXPathVariableLookup(); 51384 test_ret += test_xmlXPathVariableLookupNS(); 51385 test_ret += test_xmlXPathWrapCString(); 51386 test_ret += test_xmlXPathWrapExternal(); 51387 test_ret += test_xmlXPathWrapNodeSet(); 51388 test_ret += test_xmlXPatherror(); 51389 51390 if (test_ret != 0) 51391 printf("Module xpathInternals: %d errors\n", test_ret); 51392 return(test_ret); 51393 } 51394 51395 static int 51396 test_xmlXPtrBuildNodeList(void) { 51397 int test_ret = 0; 51398 51399 #if defined(LIBXML_XPTR_ENABLED) 51400 int mem_base; 51401 xmlNodePtr ret_val; 51402 xmlXPathObjectPtr obj; /* the XPointer result from the evaluation. */ 51403 int n_obj; 51404 51405 for (n_obj = 0;n_obj < gen_nb_xmlXPathObjectPtr;n_obj++) { 51406 mem_base = xmlMemBlocks(); 51407 obj = gen_xmlXPathObjectPtr(n_obj, 0); 51408 51409 ret_val = xmlXPtrBuildNodeList(obj); 51410 desret_xmlNodePtr(ret_val); 51411 call_tests++; 51412 des_xmlXPathObjectPtr(n_obj, obj, 0); 51413 xmlResetLastError(); 51414 if (mem_base != xmlMemBlocks()) { 51415 printf("Leak of %d blocks found in xmlXPtrBuildNodeList", 51416 xmlMemBlocks() - mem_base); 51417 test_ret++; 51418 printf(" %d", n_obj); 51419 printf("\n"); 51420 } 51421 } 51422 function_tests++; 51423 #endif 51424 51425 return(test_ret); 51426 } 51427 51428 51429 static int 51430 test_xmlXPtrEval(void) { 51431 int test_ret = 0; 51432 51433 #if defined(LIBXML_XPTR_ENABLED) 51434 int mem_base; 51435 xmlXPathObjectPtr ret_val; 51436 xmlChar * str; /* the XPointer expression */ 51437 int n_str; 51438 xmlXPathContextPtr ctx; /* the XPointer context */ 51439 int n_ctx; 51440 51441 for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { 51442 for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) { 51443 mem_base = xmlMemBlocks(); 51444 str = gen_const_xmlChar_ptr(n_str, 0); 51445 ctx = gen_xmlXPathContextPtr(n_ctx, 1); 51446 51447 ret_val = xmlXPtrEval((const xmlChar *)str, ctx); 51448 desret_xmlXPathObjectPtr(ret_val); 51449 call_tests++; 51450 des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0); 51451 des_xmlXPathContextPtr(n_ctx, ctx, 1); 51452 xmlResetLastError(); 51453 if (mem_base != xmlMemBlocks()) { 51454 printf("Leak of %d blocks found in xmlXPtrEval", 51455 xmlMemBlocks() - mem_base); 51456 test_ret++; 51457 printf(" %d", n_str); 51458 printf(" %d", n_ctx); 51459 printf("\n"); 51460 } 51461 } 51462 } 51463 function_tests++; 51464 #endif 51465 51466 return(test_ret); 51467 } 51468 51469 51470 static int 51471 test_xmlXPtrEvalRangePredicate(void) { 51472 int test_ret = 0; 51473 51474 #if defined(LIBXML_XPTR_ENABLED) 51475 int mem_base; 51476 xmlXPathParserContextPtr ctxt; /* the XPointer Parser context */ 51477 int n_ctxt; 51478 51479 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 51480 mem_base = xmlMemBlocks(); 51481 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 51482 51483 xmlXPtrEvalRangePredicate(ctxt); 51484 call_tests++; 51485 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 51486 xmlResetLastError(); 51487 if (mem_base != xmlMemBlocks()) { 51488 printf("Leak of %d blocks found in xmlXPtrEvalRangePredicate", 51489 xmlMemBlocks() - mem_base); 51490 test_ret++; 51491 printf(" %d", n_ctxt); 51492 printf("\n"); 51493 } 51494 } 51495 function_tests++; 51496 #endif 51497 51498 return(test_ret); 51499 } 51500 51501 #ifdef LIBXML_XPTR_ENABLED 51502 51503 #define gen_nb_xmlLocationSetPtr 1 51504 static xmlLocationSetPtr gen_xmlLocationSetPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 51505 return(NULL); 51506 } 51507 static void des_xmlLocationSetPtr(int no ATTRIBUTE_UNUSED, xmlLocationSetPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { 51508 } 51509 #endif 51510 51511 51512 static int 51513 test_xmlXPtrLocationSetAdd(void) { 51514 int test_ret = 0; 51515 51516 #if defined(LIBXML_XPTR_ENABLED) 51517 int mem_base; 51518 xmlLocationSetPtr cur; /* the initial range set */ 51519 int n_cur; 51520 xmlXPathObjectPtr val; /* a new xmlXPathObjectPtr */ 51521 int n_val; 51522 51523 for (n_cur = 0;n_cur < gen_nb_xmlLocationSetPtr;n_cur++) { 51524 for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) { 51525 mem_base = xmlMemBlocks(); 51526 cur = gen_xmlLocationSetPtr(n_cur, 0); 51527 val = gen_xmlXPathObjectPtr(n_val, 1); 51528 51529 xmlXPtrLocationSetAdd(cur, val); 51530 call_tests++; 51531 des_xmlLocationSetPtr(n_cur, cur, 0); 51532 des_xmlXPathObjectPtr(n_val, val, 1); 51533 xmlResetLastError(); 51534 if (mem_base != xmlMemBlocks()) { 51535 printf("Leak of %d blocks found in xmlXPtrLocationSetAdd", 51536 xmlMemBlocks() - mem_base); 51537 test_ret++; 51538 printf(" %d", n_cur); 51539 printf(" %d", n_val); 51540 printf("\n"); 51541 } 51542 } 51543 } 51544 function_tests++; 51545 #endif 51546 51547 return(test_ret); 51548 } 51549 51550 51551 static int 51552 test_xmlXPtrLocationSetCreate(void) { 51553 int test_ret = 0; 51554 51555 51556 /* missing type support */ 51557 return(test_ret); 51558 } 51559 51560 51561 static int 51562 test_xmlXPtrLocationSetDel(void) { 51563 int test_ret = 0; 51564 51565 #if defined(LIBXML_XPTR_ENABLED) 51566 int mem_base; 51567 xmlLocationSetPtr cur; /* the initial range set */ 51568 int n_cur; 51569 xmlXPathObjectPtr val; /* an xmlXPathObjectPtr */ 51570 int n_val; 51571 51572 for (n_cur = 0;n_cur < gen_nb_xmlLocationSetPtr;n_cur++) { 51573 for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) { 51574 mem_base = xmlMemBlocks(); 51575 cur = gen_xmlLocationSetPtr(n_cur, 0); 51576 val = gen_xmlXPathObjectPtr(n_val, 1); 51577 51578 xmlXPtrLocationSetDel(cur, val); 51579 call_tests++; 51580 des_xmlLocationSetPtr(n_cur, cur, 0); 51581 des_xmlXPathObjectPtr(n_val, val, 1); 51582 xmlResetLastError(); 51583 if (mem_base != xmlMemBlocks()) { 51584 printf("Leak of %d blocks found in xmlXPtrLocationSetDel", 51585 xmlMemBlocks() - mem_base); 51586 test_ret++; 51587 printf(" %d", n_cur); 51588 printf(" %d", n_val); 51589 printf("\n"); 51590 } 51591 } 51592 } 51593 function_tests++; 51594 #endif 51595 51596 return(test_ret); 51597 } 51598 51599 51600 static int 51601 test_xmlXPtrLocationSetMerge(void) { 51602 int test_ret = 0; 51603 51604 51605 /* missing type support */ 51606 return(test_ret); 51607 } 51608 51609 51610 static int 51611 test_xmlXPtrLocationSetRemove(void) { 51612 int test_ret = 0; 51613 51614 #if defined(LIBXML_XPTR_ENABLED) 51615 int mem_base; 51616 xmlLocationSetPtr cur; /* the initial range set */ 51617 int n_cur; 51618 int val; /* the index to remove */ 51619 int n_val; 51620 51621 for (n_cur = 0;n_cur < gen_nb_xmlLocationSetPtr;n_cur++) { 51622 for (n_val = 0;n_val < gen_nb_int;n_val++) { 51623 mem_base = xmlMemBlocks(); 51624 cur = gen_xmlLocationSetPtr(n_cur, 0); 51625 val = gen_int(n_val, 1); 51626 51627 xmlXPtrLocationSetRemove(cur, val); 51628 call_tests++; 51629 des_xmlLocationSetPtr(n_cur, cur, 0); 51630 des_int(n_val, val, 1); 51631 xmlResetLastError(); 51632 if (mem_base != xmlMemBlocks()) { 51633 printf("Leak of %d blocks found in xmlXPtrLocationSetRemove", 51634 xmlMemBlocks() - mem_base); 51635 test_ret++; 51636 printf(" %d", n_cur); 51637 printf(" %d", n_val); 51638 printf("\n"); 51639 } 51640 } 51641 } 51642 function_tests++; 51643 #endif 51644 51645 return(test_ret); 51646 } 51647 51648 51649 static int 51650 test_xmlXPtrNewCollapsedRange(void) { 51651 int test_ret = 0; 51652 51653 #if defined(LIBXML_XPTR_ENABLED) 51654 int mem_base; 51655 xmlXPathObjectPtr ret_val; 51656 xmlNodePtr start; /* the starting and ending node */ 51657 int n_start; 51658 51659 for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) { 51660 mem_base = xmlMemBlocks(); 51661 start = gen_xmlNodePtr(n_start, 0); 51662 51663 ret_val = xmlXPtrNewCollapsedRange(start); 51664 desret_xmlXPathObjectPtr(ret_val); 51665 call_tests++; 51666 des_xmlNodePtr(n_start, start, 0); 51667 xmlResetLastError(); 51668 if (mem_base != xmlMemBlocks()) { 51669 printf("Leak of %d blocks found in xmlXPtrNewCollapsedRange", 51670 xmlMemBlocks() - mem_base); 51671 test_ret++; 51672 printf(" %d", n_start); 51673 printf("\n"); 51674 } 51675 } 51676 function_tests++; 51677 #endif 51678 51679 return(test_ret); 51680 } 51681 51682 51683 static int 51684 test_xmlXPtrNewContext(void) { 51685 int test_ret = 0; 51686 51687 51688 /* missing type support */ 51689 return(test_ret); 51690 } 51691 51692 51693 static int 51694 test_xmlXPtrNewLocationSetNodeSet(void) { 51695 int test_ret = 0; 51696 51697 #if defined(LIBXML_XPTR_ENABLED) 51698 int mem_base; 51699 xmlXPathObjectPtr ret_val; 51700 xmlNodeSetPtr set; /* a node set */ 51701 int n_set; 51702 51703 for (n_set = 0;n_set < gen_nb_xmlNodeSetPtr;n_set++) { 51704 mem_base = xmlMemBlocks(); 51705 set = gen_xmlNodeSetPtr(n_set, 0); 51706 51707 ret_val = xmlXPtrNewLocationSetNodeSet(set); 51708 desret_xmlXPathObjectPtr(ret_val); 51709 call_tests++; 51710 des_xmlNodeSetPtr(n_set, set, 0); 51711 xmlResetLastError(); 51712 if (mem_base != xmlMemBlocks()) { 51713 printf("Leak of %d blocks found in xmlXPtrNewLocationSetNodeSet", 51714 xmlMemBlocks() - mem_base); 51715 test_ret++; 51716 printf(" %d", n_set); 51717 printf("\n"); 51718 } 51719 } 51720 function_tests++; 51721 #endif 51722 51723 return(test_ret); 51724 } 51725 51726 51727 static int 51728 test_xmlXPtrNewLocationSetNodes(void) { 51729 int test_ret = 0; 51730 51731 #if defined(LIBXML_XPTR_ENABLED) 51732 int mem_base; 51733 xmlXPathObjectPtr ret_val; 51734 xmlNodePtr start; /* the start NodePtr value */ 51735 int n_start; 51736 xmlNodePtr end; /* the end NodePtr value or NULL */ 51737 int n_end; 51738 51739 for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) { 51740 for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) { 51741 mem_base = xmlMemBlocks(); 51742 start = gen_xmlNodePtr(n_start, 0); 51743 end = gen_xmlNodePtr(n_end, 1); 51744 51745 ret_val = xmlXPtrNewLocationSetNodes(start, end); 51746 desret_xmlXPathObjectPtr(ret_val); 51747 call_tests++; 51748 des_xmlNodePtr(n_start, start, 0); 51749 des_xmlNodePtr(n_end, end, 1); 51750 xmlResetLastError(); 51751 if (mem_base != xmlMemBlocks()) { 51752 printf("Leak of %d blocks found in xmlXPtrNewLocationSetNodes", 51753 xmlMemBlocks() - mem_base); 51754 test_ret++; 51755 printf(" %d", n_start); 51756 printf(" %d", n_end); 51757 printf("\n"); 51758 } 51759 } 51760 } 51761 function_tests++; 51762 #endif 51763 51764 return(test_ret); 51765 } 51766 51767 51768 static int 51769 test_xmlXPtrNewRange(void) { 51770 int test_ret = 0; 51771 51772 #if defined(LIBXML_XPTR_ENABLED) 51773 int mem_base; 51774 xmlXPathObjectPtr ret_val; 51775 xmlNodePtr start; /* the starting node */ 51776 int n_start; 51777 int startindex; /* the start index */ 51778 int n_startindex; 51779 xmlNodePtr end; /* the ending point */ 51780 int n_end; 51781 int endindex; /* the ending index */ 51782 int n_endindex; 51783 51784 for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) { 51785 for (n_startindex = 0;n_startindex < gen_nb_int;n_startindex++) { 51786 for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) { 51787 for (n_endindex = 0;n_endindex < gen_nb_int;n_endindex++) { 51788 mem_base = xmlMemBlocks(); 51789 start = gen_xmlNodePtr(n_start, 0); 51790 startindex = gen_int(n_startindex, 1); 51791 end = gen_xmlNodePtr(n_end, 2); 51792 endindex = gen_int(n_endindex, 3); 51793 51794 ret_val = xmlXPtrNewRange(start, startindex, end, endindex); 51795 desret_xmlXPathObjectPtr(ret_val); 51796 call_tests++; 51797 des_xmlNodePtr(n_start, start, 0); 51798 des_int(n_startindex, startindex, 1); 51799 des_xmlNodePtr(n_end, end, 2); 51800 des_int(n_endindex, endindex, 3); 51801 xmlResetLastError(); 51802 if (mem_base != xmlMemBlocks()) { 51803 printf("Leak of %d blocks found in xmlXPtrNewRange", 51804 xmlMemBlocks() - mem_base); 51805 test_ret++; 51806 printf(" %d", n_start); 51807 printf(" %d", n_startindex); 51808 printf(" %d", n_end); 51809 printf(" %d", n_endindex); 51810 printf("\n"); 51811 } 51812 } 51813 } 51814 } 51815 } 51816 function_tests++; 51817 #endif 51818 51819 return(test_ret); 51820 } 51821 51822 51823 static int 51824 test_xmlXPtrNewRangeNodeObject(void) { 51825 int test_ret = 0; 51826 51827 #if defined(LIBXML_XPTR_ENABLED) 51828 int mem_base; 51829 xmlXPathObjectPtr ret_val; 51830 xmlNodePtr start; /* the starting node */ 51831 int n_start; 51832 xmlXPathObjectPtr end; /* the ending object */ 51833 int n_end; 51834 51835 for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) { 51836 for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) { 51837 mem_base = xmlMemBlocks(); 51838 start = gen_xmlNodePtr(n_start, 0); 51839 end = gen_xmlXPathObjectPtr(n_end, 1); 51840 51841 ret_val = xmlXPtrNewRangeNodeObject(start, end); 51842 desret_xmlXPathObjectPtr(ret_val); 51843 call_tests++; 51844 des_xmlNodePtr(n_start, start, 0); 51845 des_xmlXPathObjectPtr(n_end, end, 1); 51846 xmlResetLastError(); 51847 if (mem_base != xmlMemBlocks()) { 51848 printf("Leak of %d blocks found in xmlXPtrNewRangeNodeObject", 51849 xmlMemBlocks() - mem_base); 51850 test_ret++; 51851 printf(" %d", n_start); 51852 printf(" %d", n_end); 51853 printf("\n"); 51854 } 51855 } 51856 } 51857 function_tests++; 51858 #endif 51859 51860 return(test_ret); 51861 } 51862 51863 51864 static int 51865 test_xmlXPtrNewRangeNodePoint(void) { 51866 int test_ret = 0; 51867 51868 #if defined(LIBXML_XPTR_ENABLED) 51869 int mem_base; 51870 xmlXPathObjectPtr ret_val; 51871 xmlNodePtr start; /* the starting node */ 51872 int n_start; 51873 xmlXPathObjectPtr end; /* the ending point */ 51874 int n_end; 51875 51876 for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) { 51877 for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) { 51878 mem_base = xmlMemBlocks(); 51879 start = gen_xmlNodePtr(n_start, 0); 51880 end = gen_xmlXPathObjectPtr(n_end, 1); 51881 51882 ret_val = xmlXPtrNewRangeNodePoint(start, end); 51883 desret_xmlXPathObjectPtr(ret_val); 51884 call_tests++; 51885 des_xmlNodePtr(n_start, start, 0); 51886 des_xmlXPathObjectPtr(n_end, end, 1); 51887 xmlResetLastError(); 51888 if (mem_base != xmlMemBlocks()) { 51889 printf("Leak of %d blocks found in xmlXPtrNewRangeNodePoint", 51890 xmlMemBlocks() - mem_base); 51891 test_ret++; 51892 printf(" %d", n_start); 51893 printf(" %d", n_end); 51894 printf("\n"); 51895 } 51896 } 51897 } 51898 function_tests++; 51899 #endif 51900 51901 return(test_ret); 51902 } 51903 51904 51905 static int 51906 test_xmlXPtrNewRangeNodes(void) { 51907 int test_ret = 0; 51908 51909 #if defined(LIBXML_XPTR_ENABLED) 51910 int mem_base; 51911 xmlXPathObjectPtr ret_val; 51912 xmlNodePtr start; /* the starting node */ 51913 int n_start; 51914 xmlNodePtr end; /* the ending node */ 51915 int n_end; 51916 51917 for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) { 51918 for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) { 51919 mem_base = xmlMemBlocks(); 51920 start = gen_xmlNodePtr(n_start, 0); 51921 end = gen_xmlNodePtr(n_end, 1); 51922 51923 ret_val = xmlXPtrNewRangeNodes(start, end); 51924 desret_xmlXPathObjectPtr(ret_val); 51925 call_tests++; 51926 des_xmlNodePtr(n_start, start, 0); 51927 des_xmlNodePtr(n_end, end, 1); 51928 xmlResetLastError(); 51929 if (mem_base != xmlMemBlocks()) { 51930 printf("Leak of %d blocks found in xmlXPtrNewRangeNodes", 51931 xmlMemBlocks() - mem_base); 51932 test_ret++; 51933 printf(" %d", n_start); 51934 printf(" %d", n_end); 51935 printf("\n"); 51936 } 51937 } 51938 } 51939 function_tests++; 51940 #endif 51941 51942 return(test_ret); 51943 } 51944 51945 51946 static int 51947 test_xmlXPtrNewRangePointNode(void) { 51948 int test_ret = 0; 51949 51950 #if defined(LIBXML_XPTR_ENABLED) 51951 int mem_base; 51952 xmlXPathObjectPtr ret_val; 51953 xmlXPathObjectPtr start; /* the starting point */ 51954 int n_start; 51955 xmlNodePtr end; /* the ending node */ 51956 int n_end; 51957 51958 for (n_start = 0;n_start < gen_nb_xmlXPathObjectPtr;n_start++) { 51959 for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) { 51960 mem_base = xmlMemBlocks(); 51961 start = gen_xmlXPathObjectPtr(n_start, 0); 51962 end = gen_xmlNodePtr(n_end, 1); 51963 51964 ret_val = xmlXPtrNewRangePointNode(start, end); 51965 desret_xmlXPathObjectPtr(ret_val); 51966 call_tests++; 51967 des_xmlXPathObjectPtr(n_start, start, 0); 51968 des_xmlNodePtr(n_end, end, 1); 51969 xmlResetLastError(); 51970 if (mem_base != xmlMemBlocks()) { 51971 printf("Leak of %d blocks found in xmlXPtrNewRangePointNode", 51972 xmlMemBlocks() - mem_base); 51973 test_ret++; 51974 printf(" %d", n_start); 51975 printf(" %d", n_end); 51976 printf("\n"); 51977 } 51978 } 51979 } 51980 function_tests++; 51981 #endif 51982 51983 return(test_ret); 51984 } 51985 51986 51987 static int 51988 test_xmlXPtrNewRangePoints(void) { 51989 int test_ret = 0; 51990 51991 #if defined(LIBXML_XPTR_ENABLED) 51992 int mem_base; 51993 xmlXPathObjectPtr ret_val; 51994 xmlXPathObjectPtr start; /* the starting point */ 51995 int n_start; 51996 xmlXPathObjectPtr end; /* the ending point */ 51997 int n_end; 51998 51999 for (n_start = 0;n_start < gen_nb_xmlXPathObjectPtr;n_start++) { 52000 for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) { 52001 mem_base = xmlMemBlocks(); 52002 start = gen_xmlXPathObjectPtr(n_start, 0); 52003 end = gen_xmlXPathObjectPtr(n_end, 1); 52004 52005 ret_val = xmlXPtrNewRangePoints(start, end); 52006 desret_xmlXPathObjectPtr(ret_val); 52007 call_tests++; 52008 des_xmlXPathObjectPtr(n_start, start, 0); 52009 des_xmlXPathObjectPtr(n_end, end, 1); 52010 xmlResetLastError(); 52011 if (mem_base != xmlMemBlocks()) { 52012 printf("Leak of %d blocks found in xmlXPtrNewRangePoints", 52013 xmlMemBlocks() - mem_base); 52014 test_ret++; 52015 printf(" %d", n_start); 52016 printf(" %d", n_end); 52017 printf("\n"); 52018 } 52019 } 52020 } 52021 function_tests++; 52022 #endif 52023 52024 return(test_ret); 52025 } 52026 52027 52028 static int 52029 test_xmlXPtrRangeToFunction(void) { 52030 int test_ret = 0; 52031 52032 #if defined(LIBXML_XPTR_ENABLED) 52033 int mem_base; 52034 xmlXPathParserContextPtr ctxt; /* the XPointer Parser context */ 52035 int n_ctxt; 52036 int nargs; /* the number of args */ 52037 int n_nargs; 52038 52039 for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) { 52040 for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) { 52041 mem_base = xmlMemBlocks(); 52042 ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0); 52043 nargs = gen_int(n_nargs, 1); 52044 52045 xmlXPtrRangeToFunction(ctxt, nargs); 52046 call_tests++; 52047 des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0); 52048 des_int(n_nargs, nargs, 1); 52049 xmlResetLastError(); 52050 if (mem_base != xmlMemBlocks()) { 52051 printf("Leak of %d blocks found in xmlXPtrRangeToFunction", 52052 xmlMemBlocks() - mem_base); 52053 test_ret++; 52054 printf(" %d", n_ctxt); 52055 printf(" %d", n_nargs); 52056 printf("\n"); 52057 } 52058 } 52059 } 52060 function_tests++; 52061 #endif 52062 52063 return(test_ret); 52064 } 52065 52066 52067 static int 52068 test_xmlXPtrWrapLocationSet(void) { 52069 int test_ret = 0; 52070 52071 #if defined(LIBXML_XPTR_ENABLED) 52072 int mem_base; 52073 xmlXPathObjectPtr ret_val; 52074 xmlLocationSetPtr val; /* the LocationSet value */ 52075 int n_val; 52076 52077 for (n_val = 0;n_val < gen_nb_xmlLocationSetPtr;n_val++) { 52078 mem_base = xmlMemBlocks(); 52079 val = gen_xmlLocationSetPtr(n_val, 0); 52080 52081 ret_val = xmlXPtrWrapLocationSet(val); 52082 desret_xmlXPathObjectPtr(ret_val); 52083 call_tests++; 52084 des_xmlLocationSetPtr(n_val, val, 0); 52085 xmlResetLastError(); 52086 if (mem_base != xmlMemBlocks()) { 52087 printf("Leak of %d blocks found in xmlXPtrWrapLocationSet", 52088 xmlMemBlocks() - mem_base); 52089 test_ret++; 52090 printf(" %d", n_val); 52091 printf("\n"); 52092 } 52093 } 52094 function_tests++; 52095 #endif 52096 52097 return(test_ret); 52098 } 52099 52100 static int 52101 test_xpointer(void) { 52102 int test_ret = 0; 52103 52104 if (quiet == 0) printf("Testing xpointer : 17 of 21 functions ...\n"); 52105 test_ret += test_xmlXPtrBuildNodeList(); 52106 test_ret += test_xmlXPtrEval(); 52107 test_ret += test_xmlXPtrEvalRangePredicate(); 52108 test_ret += test_xmlXPtrLocationSetAdd(); 52109 test_ret += test_xmlXPtrLocationSetCreate(); 52110 test_ret += test_xmlXPtrLocationSetDel(); 52111 test_ret += test_xmlXPtrLocationSetMerge(); 52112 test_ret += test_xmlXPtrLocationSetRemove(); 52113 test_ret += test_xmlXPtrNewCollapsedRange(); 52114 test_ret += test_xmlXPtrNewContext(); 52115 test_ret += test_xmlXPtrNewLocationSetNodeSet(); 52116 test_ret += test_xmlXPtrNewLocationSetNodes(); 52117 test_ret += test_xmlXPtrNewRange(); 52118 test_ret += test_xmlXPtrNewRangeNodeObject(); 52119 test_ret += test_xmlXPtrNewRangeNodePoint(); 52120 test_ret += test_xmlXPtrNewRangeNodes(); 52121 test_ret += test_xmlXPtrNewRangePointNode(); 52122 test_ret += test_xmlXPtrNewRangePoints(); 52123 test_ret += test_xmlXPtrRangeToFunction(); 52124 test_ret += test_xmlXPtrWrapLocationSet(); 52125 52126 if (test_ret != 0) 52127 printf("Module xpointer: %d errors\n", test_ret); 52128 return(test_ret); 52129 } 52130 static int 52131 test_module(const char *module) { 52132 if (!strcmp(module, "HTMLparser")) return(test_HTMLparser()); 52133 if (!strcmp(module, "HTMLtree")) return(test_HTMLtree()); 52134 if (!strcmp(module, "SAX2")) return(test_SAX2()); 52135 if (!strcmp(module, "c14n")) return(test_c14n()); 52136 if (!strcmp(module, "catalog")) return(test_catalog()); 52137 if (!strcmp(module, "chvalid")) return(test_chvalid()); 52138 if (!strcmp(module, "debugXML")) return(test_debugXML()); 52139 if (!strcmp(module, "dict")) return(test_dict()); 52140 if (!strcmp(module, "encoding")) return(test_encoding()); 52141 if (!strcmp(module, "entities")) return(test_entities()); 52142 if (!strcmp(module, "hash")) return(test_hash()); 52143 if (!strcmp(module, "list")) return(test_list()); 52144 if (!strcmp(module, "nanoftp")) return(test_nanoftp()); 52145 if (!strcmp(module, "nanohttp")) return(test_nanohttp()); 52146 if (!strcmp(module, "parser")) return(test_parser()); 52147 if (!strcmp(module, "parserInternals")) return(test_parserInternals()); 52148 if (!strcmp(module, "pattern")) return(test_pattern()); 52149 if (!strcmp(module, "relaxng")) return(test_relaxng()); 52150 if (!strcmp(module, "schemasInternals")) return(test_schemasInternals()); 52151 if (!strcmp(module, "schematron")) return(test_schematron()); 52152 if (!strcmp(module, "tree")) return(test_tree()); 52153 if (!strcmp(module, "uri")) return(test_uri()); 52154 if (!strcmp(module, "valid")) return(test_valid()); 52155 if (!strcmp(module, "xinclude")) return(test_xinclude()); 52156 if (!strcmp(module, "xmlIO")) return(test_xmlIO()); 52157 if (!strcmp(module, "xmlautomata")) return(test_xmlautomata()); 52158 if (!strcmp(module, "xmlerror")) return(test_xmlerror()); 52159 if (!strcmp(module, "xmlmodule")) return(test_xmlmodule()); 52160 if (!strcmp(module, "xmlreader")) return(test_xmlreader()); 52161 if (!strcmp(module, "xmlregexp")) return(test_xmlregexp()); 52162 if (!strcmp(module, "xmlsave")) return(test_xmlsave()); 52163 if (!strcmp(module, "xmlschemas")) return(test_xmlschemas()); 52164 if (!strcmp(module, "xmlschemastypes")) return(test_xmlschemastypes()); 52165 if (!strcmp(module, "xmlstring")) return(test_xmlstring()); 52166 if (!strcmp(module, "xmlunicode")) return(test_xmlunicode()); 52167 if (!strcmp(module, "xmlwriter")) return(test_xmlwriter()); 52168 if (!strcmp(module, "xpath")) return(test_xpath()); 52169 if (!strcmp(module, "xpathInternals")) return(test_xpathInternals()); 52170 if (!strcmp(module, "xpointer")) return(test_xpointer()); 52171 return(0); 52172 } 52173