Annotation of embedaddon/libxml2/testapi.c, revision 1.1
1.1 ! misho 1: /*
! 2: * testapi.c: libxml2 API tester program.
! 3: *
! 4: * Automatically generated by gentest.py from libxml2-api.xml
! 5: *
! 6: * See Copyright for the status of this software.
! 7: *
! 8: * daniel@veillard.com
! 9: */
! 10:
! 11: #ifdef HAVE_CONFIG_H
! 12: #include "libxml.h"
! 13: #else
! 14: #include <stdio.h>
! 15: #endif
! 16:
! 17: #include <stdlib.h> /* for putenv() */
! 18: #include <string.h>
! 19: #include <libxml/xmlerror.h>
! 20: #include <libxml/relaxng.h>
! 21:
! 22: #if defined(_WIN32) && !defined(__CYGWIN__)
! 23: #define snprintf _snprintf
! 24: #endif
! 25:
! 26: static int testlibxml2(void);
! 27: static int test_module(const char *module);
! 28:
! 29: static int generic_errors = 0;
! 30: static int call_tests = 0;
! 31: static int function_tests = 0;
! 32:
! 33: static xmlChar chartab[1024];
! 34: static int inttab[1024];
! 35: static unsigned long longtab[1024];
! 36:
! 37: static xmlDocPtr api_doc = NULL;
! 38: static xmlDtdPtr api_dtd = NULL;
! 39: static xmlNodePtr api_root = NULL;
! 40: static xmlAttrPtr api_attr = NULL;
! 41: static xmlNsPtr api_ns = NULL;
! 42:
! 43: static void
! 44: structured_errors(void *userData ATTRIBUTE_UNUSED,
! 45: xmlErrorPtr error ATTRIBUTE_UNUSED) {
! 46: generic_errors++;
! 47: }
! 48:
! 49: static void
! 50: free_api_doc(void) {
! 51: xmlFreeDoc(api_doc);
! 52: api_doc = NULL;
! 53: api_dtd = NULL;
! 54: api_root = NULL;
! 55: api_attr = NULL;
! 56: api_ns = NULL;
! 57: }
! 58:
! 59: static xmlDocPtr
! 60: get_api_doc(void) {
! 61: if (api_doc == NULL) {
! 62: api_doc = xmlReadMemory("<!DOCTYPE root [<!ELEMENT root EMPTY>]><root xmlns:h='http://example.com/' h:foo='bar'/>", 88, "root_test", NULL, 0);
! 63: api_root = NULL;
! 64: api_attr = NULL;
! 65: }
! 66: return(api_doc);
! 67: }
! 68:
! 69: static xmlDtdPtr
! 70: get_api_dtd(void) {
! 71: if ((api_dtd == NULL) || (api_dtd->type != XML_DTD_NODE)) {
! 72: get_api_doc();
! 73: if ((api_doc != NULL) && (api_doc->children != NULL) &&
! 74: (api_doc->children->type == XML_DTD_NODE))
! 75: api_dtd = (xmlDtdPtr) api_doc->children;
! 76: }
! 77: return(api_dtd);
! 78: }
! 79:
! 80: static xmlNodePtr
! 81: get_api_root(void) {
! 82: if ((api_root == NULL) || (api_root->type != XML_ELEMENT_NODE)) {
! 83: get_api_doc();
! 84: if ((api_doc != NULL) && (api_doc->children != NULL) &&
! 85: (api_doc->children->next != NULL) &&
! 86: (api_doc->children->next->type == XML_ELEMENT_NODE))
! 87: api_root = api_doc->children->next;
! 88: }
! 89: return(api_root);
! 90: }
! 91:
! 92: static xmlNsPtr
! 93: get_api_ns(void) {
! 94: get_api_root();
! 95: if (api_root != NULL)
! 96: api_ns = api_root->nsDef;
! 97: return(api_ns);
! 98: }
! 99:
! 100: static xmlAttrPtr
! 101: get_api_attr(void) {
! 102: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
! 103: static int nr = 0;
! 104: xmlChar name[20];
! 105: #endif
! 106:
! 107: if ((api_root == NULL) || (api_root->type != XML_ELEMENT_NODE)) {
! 108: get_api_root();
! 109: }
! 110: if (api_root == NULL)
! 111: return(NULL);
! 112: if (api_root->properties != NULL) {
! 113: api_attr = api_root->properties;
! 114: return(api_root->properties);
! 115: }
! 116: api_attr = NULL;
! 117: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
! 118: snprintf((char *) name, 20, "foo%d", nr++);
! 119: api_attr = xmlSetProp(api_root, name, (const xmlChar *) "bar");
! 120: #endif
! 121: return(api_attr);
! 122: }
! 123:
! 124: static int quiet = 0;
! 125:
! 126: int main(int argc, char **argv) {
! 127: int ret;
! 128: int blocks, mem;
! 129:
! 130: /* access to the proxy can slow up regression tests a lot */
! 131: putenv((char *) "http_proxy=");
! 132:
! 133: memset(chartab, 0, sizeof(chartab));
! 134: strncpy((char *) chartab, " chartab\n", 20);
! 135: memset(inttab, 0, sizeof(inttab));
! 136: memset(longtab, 0, sizeof(longtab));
! 137:
! 138: xmlInitParser();
! 139: #ifdef LIBXML_SCHEMAS_ENABLED
! 140: xmlRelaxNGInitTypes();
! 141: #endif
! 142:
! 143: LIBXML_TEST_VERSION
! 144:
! 145: xmlSetStructuredErrorFunc(NULL, structured_errors);
! 146:
! 147: if (argc >= 2) {
! 148: if (!strcmp(argv[1], "-q")) {
! 149: quiet = 1;
! 150: if (argc >= 3)
! 151: ret = test_module(argv[2]);
! 152: else
! 153: ret = testlibxml2();
! 154: } else {
! 155: ret = test_module(argv[1]);
! 156: }
! 157: } else
! 158: ret = testlibxml2();
! 159:
! 160: xmlCleanupParser();
! 161: blocks = xmlMemBlocks();
! 162: mem = xmlMemUsed();
! 163: if ((blocks != 0) || (mem != 0)) {
! 164: printf("testapi leaked %d bytes in %d blocks\n", mem, blocks);
! 165: }
! 166: xmlMemoryDump();
! 167:
! 168: return (ret != 0);
! 169: }
! 170:
! 171: #include <libxml/HTMLparser.h>
! 172: #include <libxml/HTMLtree.h>
! 173: #include <libxml/catalog.h>
! 174: #include <libxml/chvalid.h>
! 175: #include <libxml/dict.h>
! 176: #include <libxml/encoding.h>
! 177: #include <libxml/entities.h>
! 178: #include <libxml/hash.h>
! 179: #include <libxml/list.h>
! 180: #include <libxml/nanoftp.h>
! 181: #include <libxml/nanohttp.h>
! 182: #include <libxml/parser.h>
! 183: #include <libxml/parserInternals.h>
! 184: #include <libxml/pattern.h>
! 185: #include <libxml/relaxng.h>
! 186: #include <libxml/schemasInternals.h>
! 187: #include <libxml/schematron.h>
! 188: #include <libxml/tree.h>
! 189: #include <libxml/uri.h>
! 190: #include <libxml/valid.h>
! 191: #include <libxml/xinclude.h>
! 192: #include <libxml/xmlIO.h>
! 193: #include <libxml/xmlerror.h>
! 194: #include <libxml/xmlreader.h>
! 195: #include <libxml/xmlsave.h>
! 196: #include <libxml/xmlschemas.h>
! 197: #include <libxml/xmlschemastypes.h>
! 198: #include <libxml/xmlstring.h>
! 199: #include <libxml/xmlwriter.h>
! 200: #include <libxml/xpath.h>
! 201: #include <libxml/xpointer.h>
! 202: #include <libxml/debugXML.h>
! 203:
! 204: /*
! 205: We manually define xmlErrMemory because it's normal declaration
! 206: is "hidden" by #ifdef IN_LIBXML
! 207: */
! 208: void xmlErrMemory(xmlParserCtxtPtr ctxt, const char *extra);
! 209:
! 210: /*
! 211: We need some "remote" addresses, but want to avoid getting into
! 212: name resolution delays, so we use these
! 213: */
! 214: #define REMOTE1GOOD "http://localhost/"
! 215: #define REMOTE1BAD "http:http://http"
! 216: #define REMOTE2GOOD "ftp://localhost/foo"
! 217:
! 218: #define gen_nb_void_ptr 2
! 219:
! 220: static void *gen_void_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 221: return(NULL);
! 222: }
! 223: static void des_void_ptr(int no ATTRIBUTE_UNUSED, void *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 224: }
! 225:
! 226: #if 0
! 227: #define gen_nb_const_void_ptr 2
! 228:
! 229: static const void *gen_const_void_ptr(int no, int nr ATTRIBUTE_UNUSED) {
! 230: if (no == 0) return((const void *) "immutable string");
! 231: return(NULL);
! 232: }
! 233: static void des_const_void_ptr(int no ATTRIBUTE_UNUSED, const void *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 234: }
! 235: #endif
! 236:
! 237: #define gen_nb_userdata 3
! 238:
! 239: static void *gen_userdata(int no, int nr ATTRIBUTE_UNUSED) {
! 240: if (no == 0) return((void *) &call_tests);
! 241: if (no == 1) return((void *) -1);
! 242: return(NULL);
! 243: }
! 244: static void des_userdata(int no ATTRIBUTE_UNUSED, void *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 245: }
! 246:
! 247:
! 248: #define gen_nb_int 4
! 249:
! 250: static int gen_int(int no, int nr ATTRIBUTE_UNUSED) {
! 251: if (no == 0) return(0);
! 252: if (no == 1) return(1);
! 253: if (no == 2) return(-1);
! 254: if (no == 3) return(122);
! 255: return(-1);
! 256: }
! 257:
! 258: static void des_int(int no ATTRIBUTE_UNUSED, int val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 259: }
! 260:
! 261: #define gen_nb_parseroptions 5
! 262:
! 263: static int gen_parseroptions(int no, int nr ATTRIBUTE_UNUSED) {
! 264: if (no == 0) return(XML_PARSE_NOBLANKS | XML_PARSE_RECOVER);
! 265: if (no == 1) return(XML_PARSE_NOENT | XML_PARSE_DTDLOAD | XML_PARSE_DTDATTR | XML_PARSE_DTDVALID | XML_PARSE_NOCDATA);
! 266: if (no == 2) return(XML_PARSE_XINCLUDE | XML_PARSE_NOXINCNODE | XML_PARSE_NSCLEAN);
! 267: if (no == 3) return(XML_PARSE_XINCLUDE | XML_PARSE_NODICT);
! 268: return(XML_PARSE_SAX1);
! 269: }
! 270:
! 271: static void des_parseroptions(int no ATTRIBUTE_UNUSED, int val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 272: }
! 273:
! 274: #if 0
! 275: #define gen_nb_long 5
! 276:
! 277: static long gen_long(int no, int nr ATTRIBUTE_UNUSED) {
! 278: if (no == 0) return(0);
! 279: if (no == 1) return(1);
! 280: if (no == 2) return(-1);
! 281: if (no == 3) return(122);
! 282: return(-1);
! 283: }
! 284:
! 285: static void des_long(int no ATTRIBUTE_UNUSED, long val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 286: }
! 287: #endif
! 288:
! 289: #define gen_nb_xmlChar 4
! 290:
! 291: static xmlChar gen_xmlChar(int no, int nr ATTRIBUTE_UNUSED) {
! 292: if (no == 0) return('a');
! 293: if (no == 1) return(' ');
! 294: if (no == 2) return((xmlChar) 'ø');
! 295: return(0);
! 296: }
! 297:
! 298: static void des_xmlChar(int no ATTRIBUTE_UNUSED, xmlChar val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 299: }
! 300:
! 301: #define gen_nb_unsigned_int 3
! 302:
! 303: static unsigned int gen_unsigned_int(int no, int nr ATTRIBUTE_UNUSED) {
! 304: if (no == 0) return(0);
! 305: if (no == 1) return(1);
! 306: if (no == 2) return(122);
! 307: return((unsigned int) -1);
! 308: }
! 309:
! 310: static void des_unsigned_int(int no ATTRIBUTE_UNUSED, unsigned int val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 311: }
! 312:
! 313: #define gen_nb_unsigned_long 4
! 314:
! 315: static unsigned long gen_unsigned_long(int no, int nr ATTRIBUTE_UNUSED) {
! 316: if (no == 0) return(0);
! 317: if (no == 1) return(1);
! 318: if (no == 2) return(122);
! 319: return((unsigned long) -1);
! 320: }
! 321:
! 322: static void des_unsigned_long(int no ATTRIBUTE_UNUSED, unsigned long val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 323: }
! 324:
! 325: #define gen_nb_double 4
! 326:
! 327: static double gen_double(int no, int nr ATTRIBUTE_UNUSED) {
! 328: if (no == 0) return(0);
! 329: if (no == 1) return(-1.1);
! 330: #if defined(LIBXML_XPATH_ENABLED)
! 331: if (no == 2) return(xmlXPathNAN);
! 332: #endif
! 333: return(-1);
! 334: }
! 335:
! 336: static void des_double(int no ATTRIBUTE_UNUSED, double val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 337: }
! 338:
! 339: #define gen_nb_unsigned_long_ptr 2
! 340:
! 341: static unsigned long *gen_unsigned_long_ptr(int no, int nr) {
! 342: if (no == 0) return(&longtab[nr]);
! 343: return(NULL);
! 344: }
! 345:
! 346: static void des_unsigned_long_ptr(int no ATTRIBUTE_UNUSED, unsigned long *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 347: }
! 348:
! 349: #define gen_nb_int_ptr 2
! 350:
! 351: static int *gen_int_ptr(int no, int nr) {
! 352: if (no == 0) return(&inttab[nr]);
! 353: return(NULL);
! 354: }
! 355:
! 356: static void des_int_ptr(int no ATTRIBUTE_UNUSED, int *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 357: }
! 358:
! 359: #define gen_nb_const_char_ptr 4
! 360:
! 361: static char *gen_const_char_ptr(int no, int nr ATTRIBUTE_UNUSED) {
! 362: if (no == 0) return((char *) "foo");
! 363: if (no == 1) return((char *) "<foo/>");
! 364: if (no == 2) return((char *) "test/ent2");
! 365: return(NULL);
! 366: }
! 367: static void des_const_char_ptr(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 368: }
! 369:
! 370: #define gen_nb_xmlChar_ptr 2
! 371:
! 372: static xmlChar *gen_xmlChar_ptr(int no, int nr ATTRIBUTE_UNUSED) {
! 373: if (no == 0) return(&chartab[0]);
! 374: return(NULL);
! 375: }
! 376: static void des_xmlChar_ptr(int no ATTRIBUTE_UNUSED, xmlChar *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 377: }
! 378:
! 379: #define gen_nb_FILE_ptr 2
! 380:
! 381: static FILE *gen_FILE_ptr(int no, int nr ATTRIBUTE_UNUSED) {
! 382: if (no == 0) return(fopen("test.out", "a+"));
! 383: return(NULL);
! 384: }
! 385: static void des_FILE_ptr(int no ATTRIBUTE_UNUSED, FILE *val, int nr ATTRIBUTE_UNUSED) {
! 386: if (val != NULL) fclose(val);
! 387: }
! 388:
! 389: #define gen_nb_debug_FILE_ptr 2
! 390: static FILE *gen_debug_FILE_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 391: return(fopen("test.out", "a+"));
! 392: }
! 393: static void des_debug_FILE_ptr(int no ATTRIBUTE_UNUSED, FILE *val, int nr ATTRIBUTE_UNUSED) {
! 394: if (val != NULL) fclose(val);
! 395: }
! 396:
! 397: #define gen_nb_const_xmlChar_ptr 5
! 398:
! 399: static xmlChar *gen_const_xmlChar_ptr(int no, int nr ATTRIBUTE_UNUSED) {
! 400: if (no == 0) return((xmlChar *) "foo");
! 401: if (no == 1) return((xmlChar *) "<foo/>");
! 402: if (no == 2) return((xmlChar *) "nøne");
! 403: if (no == 3) return((xmlChar *) " 2ab ");
! 404: return(NULL);
! 405: }
! 406: static void des_const_xmlChar_ptr(int no ATTRIBUTE_UNUSED, const xmlChar *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 407: }
! 408:
! 409: #define gen_nb_filepath 8
! 410:
! 411: static const char *gen_filepath(int no, int nr ATTRIBUTE_UNUSED) {
! 412: if (no == 0) return("missing.xml");
! 413: if (no == 1) return("<foo/>");
! 414: if (no == 2) return("test/ent2");
! 415: if (no == 3) return("test/valid/REC-xml-19980210.xml");
! 416: if (no == 4) return("test/valid/dtds/xhtml1-strict.dtd");
! 417: if (no == 5) return(REMOTE1GOOD);
! 418: if (no == 6) return(REMOTE1BAD);
! 419: return(NULL);
! 420: }
! 421: static void des_filepath(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 422: }
! 423:
! 424: #define gen_nb_eaten_name 2
! 425:
! 426: static xmlChar *gen_eaten_name(int no, int nr ATTRIBUTE_UNUSED) {
! 427: if (no == 0) return(xmlStrdup(BAD_CAST "eaten"));
! 428: return(NULL);
! 429: }
! 430: static void des_eaten_name(int no ATTRIBUTE_UNUSED, xmlChar *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 431: }
! 432:
! 433: #define gen_nb_fileoutput 6
! 434:
! 435: static const char *gen_fileoutput(int no, int nr ATTRIBUTE_UNUSED) {
! 436: if (no == 0) return("/missing.xml");
! 437: if (no == 1) return("<foo/>");
! 438: if (no == 2) return(REMOTE2GOOD);
! 439: if (no == 3) return(REMOTE1GOOD);
! 440: if (no == 4) return(REMOTE1BAD);
! 441: return(NULL);
! 442: }
! 443: static void des_fileoutput(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 444: }
! 445:
! 446: #define gen_nb_xmlParserCtxtPtr 3
! 447: static xmlParserCtxtPtr gen_xmlParserCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) {
! 448: if (no == 0) return(xmlNewParserCtxt());
! 449: if (no == 1) return(xmlCreateMemoryParserCtxt("<doc/>", 6));
! 450: return(NULL);
! 451: }
! 452: static void des_xmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlParserCtxtPtr val, int nr ATTRIBUTE_UNUSED) {
! 453: if (val != NULL)
! 454: xmlFreeParserCtxt(val);
! 455: }
! 456:
! 457: #define gen_nb_xmlSAXHandlerPtr 2
! 458: static xmlSAXHandlerPtr gen_xmlSAXHandlerPtr(int no, int nr ATTRIBUTE_UNUSED) {
! 459: #ifdef LIBXML_SAX1_ENABLED
! 460: if (no == 0) return((xmlSAXHandlerPtr) &xmlDefaultSAXHandler);
! 461: #endif
! 462: return(NULL);
! 463: }
! 464: static void des_xmlSAXHandlerPtr(int no ATTRIBUTE_UNUSED, xmlSAXHandlerPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 465: }
! 466:
! 467: #define gen_nb_xmlValidCtxtPtr 2
! 468: static xmlValidCtxtPtr gen_xmlValidCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) {
! 469: #ifdef LIBXML_VALID_ENABLED
! 470: if (no == 0) return(xmlNewValidCtxt());
! 471: #endif
! 472: return(NULL);
! 473: }
! 474: static void des_xmlValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlValidCtxtPtr val, int nr ATTRIBUTE_UNUSED) {
! 475: #ifdef LIBXML_VALID_ENABLED
! 476: if (val != NULL)
! 477: xmlFreeValidCtxt(val);
! 478: #endif
! 479: }
! 480:
! 481: #define gen_nb_xmlParserInputBufferPtr 8
! 482:
! 483: static xmlParserInputBufferPtr gen_xmlParserInputBufferPtr(int no, int nr ATTRIBUTE_UNUSED) {
! 484: if (no == 0) return(xmlParserInputBufferCreateFilename("missing.xml", XML_CHAR_ENCODING_NONE));
! 485: if (no == 1) return(xmlParserInputBufferCreateFilename("<foo/>", XML_CHAR_ENCODING_NONE));
! 486: if (no == 2) return(xmlParserInputBufferCreateFilename("test/ent2", XML_CHAR_ENCODING_NONE));
! 487: if (no == 3) return(xmlParserInputBufferCreateFilename("test/valid/REC-xml-19980210.xml", XML_CHAR_ENCODING_NONE));
! 488: if (no == 4) return(xmlParserInputBufferCreateFilename("test/valid/dtds/xhtml1-strict.dtd", XML_CHAR_ENCODING_NONE));
! 489: if (no == 5) return(xmlParserInputBufferCreateFilename(REMOTE1GOOD, XML_CHAR_ENCODING_NONE));
! 490: if (no == 6) return(xmlParserInputBufferCreateFilename(REMOTE1BAD, XML_CHAR_ENCODING_NONE));
! 491: return(NULL);
! 492: }
! 493: static void des_xmlParserInputBufferPtr(int no ATTRIBUTE_UNUSED, xmlParserInputBufferPtr val, int nr ATTRIBUTE_UNUSED) {
! 494: xmlFreeParserInputBuffer(val);
! 495: }
! 496:
! 497: #define gen_nb_xmlDocPtr 4
! 498: static xmlDocPtr gen_xmlDocPtr(int no, int nr ATTRIBUTE_UNUSED) {
! 499: if (no == 0) return(xmlNewDoc(BAD_CAST "1.0"));
! 500: if (no == 1) return(xmlReadMemory("<foo/>", 6, "test", NULL, 0));
! 501: if (no == 2) return(xmlReadMemory("<!DOCTYPE foo []> <foo/>", 24, "test", NULL, 0));
! 502: return(NULL);
! 503: }
! 504: static void des_xmlDocPtr(int no ATTRIBUTE_UNUSED, xmlDocPtr val, int nr ATTRIBUTE_UNUSED) {
! 505: if ((val != NULL) && (val != api_doc) && (val->doc != api_doc))
! 506: xmlFreeDoc(val);
! 507: }
! 508:
! 509: #define gen_nb_xmlAttrPtr 2
! 510: static xmlAttrPtr gen_xmlAttrPtr(int no, int nr ATTRIBUTE_UNUSED) {
! 511: if (no == 0) return(get_api_attr());
! 512: return(NULL);
! 513: }
! 514: static void des_xmlAttrPtr(int no, xmlAttrPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 515: if (no == 0) free_api_doc();
! 516: }
! 517:
! 518: #define gen_nb_xmlDictPtr 2
! 519: static xmlDictPtr gen_xmlDictPtr(int no, int nr ATTRIBUTE_UNUSED) {
! 520: if (no == 0) return(xmlDictCreate());
! 521: return(NULL);
! 522: }
! 523: static void des_xmlDictPtr(int no ATTRIBUTE_UNUSED, xmlDictPtr val, int nr ATTRIBUTE_UNUSED) {
! 524: if (val != NULL)
! 525: xmlDictFree(val);
! 526: }
! 527:
! 528: #define gen_nb_xmlNodePtr 3
! 529: static xmlNodePtr gen_xmlNodePtr(int no, int nr ATTRIBUTE_UNUSED) {
! 530: if (no == 0) return(xmlNewPI(BAD_CAST "test", NULL));
! 531: if (no == 1) return(get_api_root());
! 532: return(NULL);
! 533: /* if (no == 2) return((xmlNodePtr) get_api_doc()); */
! 534: }
! 535: static void des_xmlNodePtr(int no, xmlNodePtr val, int nr ATTRIBUTE_UNUSED) {
! 536: if (no == 1) {
! 537: free_api_doc();
! 538: } else if (val != NULL) {
! 539: xmlUnlinkNode(val);
! 540: xmlFreeNode(val);
! 541: }
! 542: }
! 543:
! 544: #define gen_nb_xmlDtdPtr 3
! 545: static xmlDtdPtr gen_xmlDtdPtr(int no, int nr ATTRIBUTE_UNUSED) {
! 546: if (no == 0)
! 547: return(xmlNewDtd(NULL, BAD_CAST "dtd", BAD_CAST"foo", BAD_CAST"bar"));
! 548: if (no == 1) return(get_api_dtd());
! 549: return(NULL);
! 550: }
! 551: static void des_xmlDtdPtr(int no, xmlDtdPtr val, int nr ATTRIBUTE_UNUSED) {
! 552: if (no == 1) free_api_doc();
! 553: else if (val != NULL) {
! 554: xmlUnlinkNode((xmlNodePtr) val);
! 555: xmlFreeNode((xmlNodePtr) val);
! 556: }
! 557: }
! 558:
! 559: #define gen_nb_xmlNsPtr 2
! 560: static xmlNsPtr gen_xmlNsPtr(int no, int nr ATTRIBUTE_UNUSED) {
! 561: if (no == 0) return(get_api_ns());
! 562: return(NULL);
! 563: }
! 564: static void des_xmlNsPtr(int no, xmlNsPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 565: if (no == 0) free_api_doc();
! 566: }
! 567:
! 568: #define gen_nb_xmlNodePtr_in 3
! 569: static xmlNodePtr gen_xmlNodePtr_in(int no, int nr ATTRIBUTE_UNUSED) {
! 570: if (no == 0) return(xmlNewPI(BAD_CAST "test", NULL));
! 571: if (no == 0) return(xmlNewText(BAD_CAST "text"));
! 572: return(NULL);
! 573: }
! 574: static void des_xmlNodePtr_in(int no ATTRIBUTE_UNUSED, xmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 575: }
! 576:
! 577: #ifdef LIBXML_WRITER_ENABLED
! 578: #define gen_nb_xmlTextWriterPtr 2
! 579: static xmlTextWriterPtr gen_xmlTextWriterPtr(int no, int nr ATTRIBUTE_UNUSED) {
! 580: if (no == 0) return(xmlNewTextWriterFilename("test.out", 0));
! 581: return(NULL);
! 582: }
! 583: static void des_xmlTextWriterPtr(int no ATTRIBUTE_UNUSED, xmlTextWriterPtr val, int nr ATTRIBUTE_UNUSED) {
! 584: if (val != NULL) xmlFreeTextWriter(val);
! 585: }
! 586: #endif
! 587:
! 588: #ifdef LIBXML_READER_ENABLED
! 589: #define gen_nb_xmlTextReaderPtr 4
! 590: static xmlTextReaderPtr gen_xmlTextReaderPtr(int no, int nr ATTRIBUTE_UNUSED) {
! 591: if (no == 0) return(xmlNewTextReaderFilename("test/ent2"));
! 592: if (no == 1) return(xmlNewTextReaderFilename("test/valid/REC-xml-19980210.xml"));
! 593: if (no == 2) return(xmlNewTextReaderFilename("test/valid/dtds/xhtml1-strict.dtd"));
! 594: return(NULL);
! 595: }
! 596: static void des_xmlTextReaderPtr(int no ATTRIBUTE_UNUSED, xmlTextReaderPtr val, int nr ATTRIBUTE_UNUSED) {
! 597: if (val != NULL) xmlFreeTextReader(val);
! 598: }
! 599: #endif
! 600:
! 601: #define gen_nb_xmlBufferPtr 3
! 602: static const char *static_buf_content = "a static buffer";
! 603: static xmlBufferPtr gen_xmlBufferPtr(int no, int nr ATTRIBUTE_UNUSED) {
! 604: if (no == 0) return(xmlBufferCreate());
! 605: if (no == 1) return(xmlBufferCreateStatic((void *)static_buf_content, 13));
! 606: return(NULL);
! 607: }
! 608: static void des_xmlBufferPtr(int no ATTRIBUTE_UNUSED, xmlBufferPtr val, int nr ATTRIBUTE_UNUSED) {
! 609: if (val != NULL) {
! 610: xmlBufferFree(val);
! 611: }
! 612: }
! 613:
! 614: #define gen_nb_xmlListPtr 2
! 615: static xmlListPtr gen_xmlListPtr(int no, int nr ATTRIBUTE_UNUSED) {
! 616: if (no == 0) return(xmlListCreate(NULL, NULL));
! 617: return(NULL);
! 618: }
! 619: static void des_xmlListPtr(int no ATTRIBUTE_UNUSED, xmlListPtr val, int nr ATTRIBUTE_UNUSED) {
! 620: if (val != NULL) {
! 621: xmlListDelete(val);
! 622: }
! 623: }
! 624:
! 625: #define gen_nb_xmlHashTablePtr 2
! 626: static xmlHashTablePtr gen_xmlHashTablePtr(int no, int nr ATTRIBUTE_UNUSED) {
! 627: if (no == 0) return(xmlHashCreate(10));
! 628: return(NULL);
! 629: }
! 630: static void des_xmlHashTablePtr(int no ATTRIBUTE_UNUSED, xmlHashTablePtr val, int nr ATTRIBUTE_UNUSED) {
! 631: if (val != NULL) {
! 632: xmlHashFree(val, NULL);
! 633: }
! 634: }
! 635:
! 636: #include <libxml/xpathInternals.h>
! 637:
! 638: #ifdef LIBXML_XPATH_ENABLED
! 639: #define gen_nb_xmlXPathObjectPtr 5
! 640: static xmlXPathObjectPtr gen_xmlXPathObjectPtr(int no, int nr ATTRIBUTE_UNUSED) {
! 641: if (no == 0) return(xmlXPathNewString(BAD_CAST "string object"));
! 642: if (no == 1) return(xmlXPathNewFloat(1.1));
! 643: if (no == 2) return(xmlXPathNewBoolean(1));
! 644: if (no == 3) return(xmlXPathNewNodeSet(NULL));
! 645: return(NULL);
! 646: }
! 647: static void des_xmlXPathObjectPtr(int no ATTRIBUTE_UNUSED, xmlXPathObjectPtr val, int nr ATTRIBUTE_UNUSED) {
! 648: if (val != NULL) {
! 649: xmlXPathFreeObject(val);
! 650: }
! 651: }
! 652: #endif
! 653:
! 654: #ifdef LIBXML_OUTPUT_ENABLED
! 655: #define gen_nb_xmlOutputBufferPtr 2
! 656: static xmlOutputBufferPtr gen_xmlOutputBufferPtr(int no, int nr ATTRIBUTE_UNUSED) {
! 657: if (no == 0) return(xmlOutputBufferCreateFilename("test.out", NULL, 0));
! 658: return(NULL);
! 659: }
! 660: static void des_xmlOutputBufferPtr(int no ATTRIBUTE_UNUSED, xmlOutputBufferPtr val, int nr ATTRIBUTE_UNUSED) {
! 661: if (val != NULL) {
! 662: xmlOutputBufferClose(val);
! 663: }
! 664: }
! 665: #endif
! 666:
! 667: #ifdef LIBXML_FTP_ENABLED
! 668: #define gen_nb_xmlNanoFTPCtxtPtr 4
! 669: static void *gen_xmlNanoFTPCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) {
! 670: if (no == 0) return(xmlNanoFTPNewCtxt(REMOTE2GOOD));
! 671: if (no == 1) return(xmlNanoFTPNewCtxt(REMOTE1GOOD));
! 672: if (no == 2) return(xmlNanoFTPNewCtxt("foo"));
! 673: return(NULL);
! 674: }
! 675: static void des_xmlNanoFTPCtxtPtr(int no ATTRIBUTE_UNUSED, void *val, int nr ATTRIBUTE_UNUSED) {
! 676: if (val != NULL) {
! 677: xmlNanoFTPFreeCtxt(val);
! 678: }
! 679: }
! 680: #endif
! 681:
! 682: #ifdef LIBXML_HTTP_ENABLED
! 683: #define gen_nb_xmlNanoHTTPCtxtPtr 1
! 684: static void *gen_xmlNanoHTTPCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) {
! 685: if (no == 0) return(xmlNanoHTTPOpen(REMOTE1GOOD, NULL));
! 686: if (no == 1) return(xmlNanoHTTPOpen(REMOTE2GOOD, NULL));
! 687: if (no == 2) return(xmlNanoHTTPOpen(REMOTE1BAD, NULL));
! 688: return(NULL);
! 689: }
! 690: static void des_xmlNanoHTTPCtxtPtr(int no ATTRIBUTE_UNUSED, void *val, int nr ATTRIBUTE_UNUSED) {
! 691: if (val != NULL) {
! 692: xmlNanoHTTPClose(val);
! 693: }
! 694: }
! 695: #endif
! 696:
! 697: #define gen_nb_xmlCharEncoding 4
! 698: static xmlCharEncoding gen_xmlCharEncoding(int no, int nr ATTRIBUTE_UNUSED) {
! 699: if (no == 0) return(XML_CHAR_ENCODING_UTF8);
! 700: if (no == 1) return(XML_CHAR_ENCODING_NONE);
! 701: if (no == 2) return(XML_CHAR_ENCODING_8859_1);
! 702: return(XML_CHAR_ENCODING_ERROR);
! 703: }
! 704: static void des_xmlCharEncoding(int no ATTRIBUTE_UNUSED, xmlCharEncoding val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 705: }
! 706:
! 707: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
! 708:
! 709: #define gen_nb_xmlExpCtxtPtr 1
! 710: static xmlExpCtxtPtr gen_xmlExpCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 711: return(NULL);
! 712: }
! 713: static void des_xmlExpCtxtPtr(int no ATTRIBUTE_UNUSED, xmlExpCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 714: }
! 715:
! 716: #define gen_nb_xmlExpNodePtr 1
! 717: static xmlExpNodePtr gen_xmlExpNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 718: return(NULL);
! 719: }
! 720: static void des_xmlExpNodePtr(int no ATTRIBUTE_UNUSED, xmlExpNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 721: }
! 722:
! 723: #endif
! 724:
! 725: #if defined(LIBXML_SCHEMAS_ENABLED)
! 726: #define gen_nb_xmlSchemaPtr 1
! 727: static xmlSchemaPtr gen_xmlSchemaPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 728: return(NULL);
! 729: }
! 730: static void des_xmlSchemaPtr(int no ATTRIBUTE_UNUSED, xmlSchemaPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 731: }
! 732:
! 733: #define gen_nb_xmlSchemaValidCtxtPtr 1
! 734: static xmlSchemaValidCtxtPtr gen_xmlSchemaValidCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 735: return(NULL);
! 736: }
! 737: static void des_xmlSchemaValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchemaValidCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 738: }
! 739:
! 740: #endif /* LIBXML_SCHEMAS_ENABLED */
! 741:
! 742: #define gen_nb_xmlHashDeallocator 2
! 743: static void
! 744: test_xmlHashDeallocator(void *payload ATTRIBUTE_UNUSED, xmlChar *name ATTRIBUTE_UNUSED) {
! 745: }
! 746:
! 747: static xmlHashDeallocator gen_xmlHashDeallocator(int no, int nr ATTRIBUTE_UNUSED) {
! 748: if (no == 0) return(test_xmlHashDeallocator);
! 749: return(NULL);
! 750: }
! 751: static void des_xmlHashDeallocator(int no ATTRIBUTE_UNUSED, xmlHashDeallocator val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 752: }
! 753:
! 754:
! 755: static void desret_int(int val ATTRIBUTE_UNUSED) {
! 756: }
! 757: static void desret_xmlChar(xmlChar val ATTRIBUTE_UNUSED) {
! 758: }
! 759: static void desret_long(long val ATTRIBUTE_UNUSED) {
! 760: }
! 761: static void desret_unsigned_long(unsigned long val ATTRIBUTE_UNUSED) {
! 762: }
! 763: static void desret_double(double val ATTRIBUTE_UNUSED) {
! 764: }
! 765: static void desret_xmlCharEncoding(xmlCharEncoding val ATTRIBUTE_UNUSED) {
! 766: }
! 767: #if 0
! 768: static void desret_const_void_ptr(void *val ATTRIBUTE_UNUSED) {
! 769: }
! 770: #endif
! 771: static void desret_void_ptr(void *val ATTRIBUTE_UNUSED) {
! 772: }
! 773: static void desret_const_char_ptr(const char *val ATTRIBUTE_UNUSED) {
! 774: }
! 775: static void desret_const_xmlChar_ptr(const xmlChar *val ATTRIBUTE_UNUSED) {
! 776: }
! 777: static void desret_xmlChar_ptr(xmlChar *val) {
! 778: if (val != NULL)
! 779: xmlFree(val);
! 780: }
! 781: static void desret_xmlDocPtr(xmlDocPtr val) {
! 782: if (val != api_doc)
! 783: xmlFreeDoc(val);
! 784: }
! 785: static void desret_xmlDictPtr(xmlDictPtr val) {
! 786: xmlDictFree(val);
! 787: }
! 788: #ifdef LIBXML_OUTPUT_ENABLED
! 789: static void desret_xmlOutputBufferPtr(xmlOutputBufferPtr val) {
! 790: xmlOutputBufferClose(val);
! 791: }
! 792: #endif
! 793: #ifdef LIBXML_READER_ENABLED
! 794: static void desret_xmlTextReaderPtr(xmlTextReaderPtr val) {
! 795: xmlFreeTextReader(val);
! 796: }
! 797: #endif
! 798: static void desret_xmlNodePtr(xmlNodePtr val) {
! 799: if ((val != NULL) && (val != api_root) && (val != (xmlNodePtr) api_doc)) {
! 800: xmlUnlinkNode(val);
! 801: xmlFreeNode(val);
! 802: }
! 803: }
! 804: static void desret_xmlAttrPtr(xmlAttrPtr val) {
! 805: if (val != NULL) {
! 806: xmlUnlinkNode((xmlNodePtr) val);
! 807: xmlFreeNode((xmlNodePtr) val);
! 808: }
! 809: }
! 810: static void desret_xmlEntityPtr(xmlEntityPtr val) {
! 811: if (val != NULL) {
! 812: xmlUnlinkNode((xmlNodePtr) val);
! 813: xmlFreeNode((xmlNodePtr) val);
! 814: }
! 815: }
! 816: static void desret_xmlElementPtr(xmlElementPtr val) {
! 817: if (val != NULL) {
! 818: xmlUnlinkNode((xmlNodePtr) val);
! 819: }
! 820: }
! 821: static void desret_xmlAttributePtr(xmlAttributePtr val) {
! 822: if (val != NULL) {
! 823: xmlUnlinkNode((xmlNodePtr) val);
! 824: }
! 825: }
! 826: static void desret_xmlNsPtr(xmlNsPtr val ATTRIBUTE_UNUSED) {
! 827: }
! 828: static void desret_xmlDtdPtr(xmlDtdPtr val) {
! 829: desret_xmlNodePtr((xmlNodePtr)val);
! 830: }
! 831: #ifdef LIBXML_XPATH_ENABLED
! 832: static void desret_xmlXPathObjectPtr(xmlXPathObjectPtr val) {
! 833: xmlXPathFreeObject(val);
! 834: }
! 835: static void desret_xmlNodeSetPtr(xmlNodeSetPtr val) {
! 836: xmlXPathFreeNodeSet(val);
! 837: }
! 838: #endif
! 839: static void desret_xmlParserCtxtPtr(xmlParserCtxtPtr val) {
! 840: xmlFreeParserCtxt(val);
! 841: }
! 842: static void desret_xmlParserInputBufferPtr(xmlParserInputBufferPtr val) {
! 843: xmlFreeParserInputBuffer(val);
! 844: }
! 845: static void desret_xmlParserInputPtr(xmlParserInputPtr val) {
! 846: xmlFreeInputStream(val);
! 847: }
! 848: #ifdef LIBXML_WRITER_ENABLED
! 849: static void desret_xmlTextWriterPtr(xmlTextWriterPtr val) {
! 850: xmlFreeTextWriter(val);
! 851: }
! 852: #endif
! 853: static void desret_xmlBufferPtr(xmlBufferPtr val) {
! 854: xmlBufferFree(val);
! 855: }
! 856: #ifdef LIBXML_SCHEMAS_ENABLED
! 857: static void desret_xmlSchemaParserCtxtPtr(xmlSchemaParserCtxtPtr val) {
! 858: xmlSchemaFreeParserCtxt(val);
! 859: }
! 860: static void desret_xmlSchemaTypePtr(xmlSchemaTypePtr val ATTRIBUTE_UNUSED) {
! 861: }
! 862: static void desret_xmlRelaxNGParserCtxtPtr(xmlRelaxNGParserCtxtPtr val) {
! 863: xmlRelaxNGFreeParserCtxt(val);
! 864: }
! 865: #endif
! 866: #ifdef LIBXML_HTML_ENABLED
! 867: static void desret_const_htmlEntityDesc_ptr(const htmlEntityDesc * val ATTRIBUTE_UNUSED) {
! 868: }
! 869: #endif
! 870: #ifdef LIBXML_HTTP_ENABLED
! 871: static void desret_xmlNanoHTTPCtxtPtr(void *val) {
! 872: xmlNanoHTTPClose(val);
! 873: }
! 874: #endif
! 875: #ifdef LIBXML_FTP_ENABLED
! 876: static void desret_xmlNanoFTPCtxtPtr(void *val) {
! 877: xmlNanoFTPClose(val);
! 878: }
! 879: #endif
! 880: /* cut and pasted from autogenerated to avoid troubles */
! 881: #define gen_nb_const_xmlChar_ptr_ptr 1
! 882: static xmlChar ** gen_const_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 883: return(NULL);
! 884: }
! 885: static void des_const_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, const xmlChar ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 886: }
! 887:
! 888: #define gen_nb_unsigned_char_ptr 1
! 889: static unsigned char * gen_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 890: return(NULL);
! 891: }
! 892: static void des_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, unsigned char * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 893: }
! 894:
! 895: #define gen_nb_const_unsigned_char_ptr 1
! 896: static unsigned char * gen_const_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 897: return(NULL);
! 898: }
! 899: static void des_const_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, const unsigned char * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 900: }
! 901:
! 902: #ifdef LIBXML_HTML_ENABLED
! 903: #define gen_nb_const_htmlNodePtr 1
! 904: static htmlNodePtr gen_const_htmlNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 905: return(NULL);
! 906: }
! 907: static void des_const_htmlNodePtr(int no ATTRIBUTE_UNUSED, const htmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 908: }
! 909: #endif
! 910:
! 911: #ifdef LIBXML_HTML_ENABLED
! 912: #define gen_nb_htmlDocPtr 3
! 913: static htmlDocPtr gen_htmlDocPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 914: if (no == 0) return(htmlNewDoc(NULL, NULL));
! 915: if (no == 1) return(htmlReadMemory("<html/>", 7, "test", NULL, 0));
! 916: return(NULL);
! 917: }
! 918: static void des_htmlDocPtr(int no ATTRIBUTE_UNUSED, htmlDocPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 919: if ((val != NULL) && (val != api_doc) && (val->doc != api_doc))
! 920: xmlFreeDoc(val);
! 921: }
! 922: static void desret_htmlDocPtr(htmlDocPtr val) {
! 923: if ((val != NULL) && (val != api_doc) && (val->doc != api_doc))
! 924: xmlFreeDoc(val);
! 925: }
! 926: #define gen_nb_htmlParserCtxtPtr 3
! 927: static htmlParserCtxtPtr gen_htmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 928: if (no == 0) return(xmlNewParserCtxt());
! 929: if (no == 1) return(htmlCreateMemoryParserCtxt("<html/>", 7));
! 930: return(NULL);
! 931: }
! 932: static void des_htmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, htmlParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 933: if (val != NULL)
! 934: htmlFreeParserCtxt(val);
! 935: }
! 936: static void desret_htmlParserCtxtPtr(htmlParserCtxtPtr val) {
! 937: if (val != NULL)
! 938: htmlFreeParserCtxt(val);
! 939: }
! 940: #endif
! 941:
! 942: #ifdef LIBXML_XPATH_ENABLED
! 943: #define gen_nb_xmlNodeSetPtr 1
! 944: static xmlNodeSetPtr gen_xmlNodeSetPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 945: return(NULL);
! 946: }
! 947: static void des_xmlNodeSetPtr(int no ATTRIBUTE_UNUSED, xmlNodeSetPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 948: }
! 949: #endif
! 950:
! 951: #ifdef LIBXML_DEBUG_ENABLED
! 952: #ifdef LIBXML_XPATH_ENABLED
! 953: #define gen_nb_xmlShellCtxtPtr 1
! 954: static xmlShellCtxtPtr gen_xmlShellCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 955: return(NULL);
! 956: }
! 957: static void des_xmlShellCtxtPtr(int no ATTRIBUTE_UNUSED, xmlShellCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 958: }
! 959: #endif
! 960: #endif
! 961:
! 962: #ifdef LIBXML_PATTERN_ENABLED
! 963: #define gen_nb_xmlPatternPtr 1
! 964: static xmlPatternPtr gen_xmlPatternPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 965: return(NULL);
! 966: }
! 967: static void des_xmlPatternPtr(int no ATTRIBUTE_UNUSED, xmlPatternPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 968: }
! 969: #endif
! 970:
! 971: #define gen_nb_xmlElementContentPtr 1
! 972: static xmlElementContentPtr gen_xmlElementContentPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 973: return(NULL);
! 974: }
! 975: static void des_xmlElementContentPtr(int no ATTRIBUTE_UNUSED, xmlElementContentPtr val, int nr ATTRIBUTE_UNUSED) {
! 976: if (val != NULL)
! 977: xmlFreeElementContent(val);
! 978: }
! 979: static void desret_xmlElementContentPtr(xmlElementContentPtr val) {
! 980: if (val != NULL)
! 981: xmlFreeElementContent(val);
! 982: }
! 983:
! 984: #define gen_nb_xmlParserNodeInfoSeqPtr 1
! 985: static xmlParserNodeInfoSeqPtr gen_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 986: return(NULL);
! 987: }
! 988: static void des_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, xmlParserNodeInfoSeqPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 989: }
! 990:
! 991: static void desret_const_xmlParserNodeInfo_ptr(const xmlParserNodeInfo *val ATTRIBUTE_UNUSED) {
! 992: }
! 993:
! 994: #define gen_nb_void_ptr_ptr 1
! 995: static void ** gen_void_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 996: return(NULL);
! 997: }
! 998: static void des_void_ptr_ptr(int no ATTRIBUTE_UNUSED, void ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 999: }
! 1000:
! 1001: /************************************************************************
! 1002: * *
! 1003: * WARNING: end of the manually maintained part of the test code *
! 1004: * do not remove or alter the CUT HERE line *
! 1005: * *
! 1006: ************************************************************************/
! 1007:
! 1008: /* CUT HERE: everything below that line is generated */
! 1009: #ifdef LIBXML_HTML_ENABLED
! 1010: static void desret_htmlStatus(htmlStatus val ATTRIBUTE_UNUSED) {
! 1011: }
! 1012:
! 1013: #endif
! 1014:
! 1015: #define gen_nb_xmlAttributeDefault 4
! 1016: static xmlAttributeDefault gen_xmlAttributeDefault(int no, int nr ATTRIBUTE_UNUSED) {
! 1017: if (no == 1) return(XML_ATTRIBUTE_FIXED);
! 1018: if (no == 2) return(XML_ATTRIBUTE_IMPLIED);
! 1019: if (no == 3) return(XML_ATTRIBUTE_NONE);
! 1020: if (no == 4) return(XML_ATTRIBUTE_REQUIRED);
! 1021: return(0);
! 1022: }
! 1023:
! 1024: static void des_xmlAttributeDefault(int no ATTRIBUTE_UNUSED, xmlAttributeDefault val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 1025: }
! 1026:
! 1027: #define gen_nb_xmlAttributeType 4
! 1028: static xmlAttributeType gen_xmlAttributeType(int no, int nr ATTRIBUTE_UNUSED) {
! 1029: if (no == 1) return(XML_ATTRIBUTE_CDATA);
! 1030: if (no == 2) return(XML_ATTRIBUTE_ENTITIES);
! 1031: if (no == 3) return(XML_ATTRIBUTE_ENTITY);
! 1032: if (no == 4) return(XML_ATTRIBUTE_ENUMERATION);
! 1033: return(0);
! 1034: }
! 1035:
! 1036: static void des_xmlAttributeType(int no ATTRIBUTE_UNUSED, xmlAttributeType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 1037: }
! 1038:
! 1039: #define gen_nb_xmlBufferAllocationScheme 4
! 1040: static xmlBufferAllocationScheme gen_xmlBufferAllocationScheme(int no, int nr ATTRIBUTE_UNUSED) {
! 1041: if (no == 1) return(XML_BUFFER_ALLOC_DOUBLEIT);
! 1042: if (no == 2) return(XML_BUFFER_ALLOC_EXACT);
! 1043: if (no == 3) return(XML_BUFFER_ALLOC_IMMUTABLE);
! 1044: if (no == 4) return(XML_BUFFER_ALLOC_IO);
! 1045: return(0);
! 1046: }
! 1047:
! 1048: static void des_xmlBufferAllocationScheme(int no ATTRIBUTE_UNUSED, xmlBufferAllocationScheme val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 1049: }
! 1050:
! 1051: static void desret_xmlBufferAllocationScheme(xmlBufferAllocationScheme val ATTRIBUTE_UNUSED) {
! 1052: }
! 1053:
! 1054: #ifdef LIBXML_CATALOG_ENABLED
! 1055: #define gen_nb_xmlCatalogAllow 4
! 1056: static xmlCatalogAllow gen_xmlCatalogAllow(int no, int nr ATTRIBUTE_UNUSED) {
! 1057: if (no == 1) return(XML_CATA_ALLOW_ALL);
! 1058: if (no == 2) return(XML_CATA_ALLOW_DOCUMENT);
! 1059: if (no == 3) return(XML_CATA_ALLOW_GLOBAL);
! 1060: if (no == 4) return(XML_CATA_ALLOW_NONE);
! 1061: return(0);
! 1062: }
! 1063:
! 1064: static void des_xmlCatalogAllow(int no ATTRIBUTE_UNUSED, xmlCatalogAllow val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 1065: }
! 1066:
! 1067: static void desret_xmlCatalogAllow(xmlCatalogAllow val ATTRIBUTE_UNUSED) {
! 1068: }
! 1069:
! 1070: #endif
! 1071:
! 1072: #ifdef LIBXML_CATALOG_ENABLED
! 1073: #define gen_nb_xmlCatalogPrefer 3
! 1074: static xmlCatalogPrefer gen_xmlCatalogPrefer(int no, int nr ATTRIBUTE_UNUSED) {
! 1075: if (no == 1) return(XML_CATA_PREFER_NONE);
! 1076: if (no == 2) return(XML_CATA_PREFER_PUBLIC);
! 1077: if (no == 3) return(XML_CATA_PREFER_SYSTEM);
! 1078: return(0);
! 1079: }
! 1080:
! 1081: static void des_xmlCatalogPrefer(int no ATTRIBUTE_UNUSED, xmlCatalogPrefer val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 1082: }
! 1083:
! 1084: static void desret_xmlCatalogPrefer(xmlCatalogPrefer val ATTRIBUTE_UNUSED) {
! 1085: }
! 1086:
! 1087: #endif
! 1088:
! 1089: #define gen_nb_xmlElementContentType 4
! 1090: static xmlElementContentType gen_xmlElementContentType(int no, int nr ATTRIBUTE_UNUSED) {
! 1091: if (no == 1) return(XML_ELEMENT_CONTENT_ELEMENT);
! 1092: if (no == 2) return(XML_ELEMENT_CONTENT_OR);
! 1093: if (no == 3) return(XML_ELEMENT_CONTENT_PCDATA);
! 1094: if (no == 4) return(XML_ELEMENT_CONTENT_SEQ);
! 1095: return(0);
! 1096: }
! 1097:
! 1098: static void des_xmlElementContentType(int no ATTRIBUTE_UNUSED, xmlElementContentType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 1099: }
! 1100:
! 1101: #define gen_nb_xmlElementTypeVal 4
! 1102: static xmlElementTypeVal gen_xmlElementTypeVal(int no, int nr ATTRIBUTE_UNUSED) {
! 1103: if (no == 1) return(XML_ELEMENT_TYPE_ANY);
! 1104: if (no == 2) return(XML_ELEMENT_TYPE_ELEMENT);
! 1105: if (no == 3) return(XML_ELEMENT_TYPE_EMPTY);
! 1106: if (no == 4) return(XML_ELEMENT_TYPE_MIXED);
! 1107: return(0);
! 1108: }
! 1109:
! 1110: static void des_xmlElementTypeVal(int no ATTRIBUTE_UNUSED, xmlElementTypeVal val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 1111: }
! 1112:
! 1113: #define gen_nb_xmlFeature 4
! 1114: static xmlFeature gen_xmlFeature(int no, int nr ATTRIBUTE_UNUSED) {
! 1115: if (no == 1) return(XML_WITH_AUTOMATA);
! 1116: if (no == 2) return(XML_WITH_C14N);
! 1117: if (no == 3) return(XML_WITH_CATALOG);
! 1118: if (no == 4) return(XML_WITH_DEBUG);
! 1119: return(0);
! 1120: }
! 1121:
! 1122: static void des_xmlFeature(int no ATTRIBUTE_UNUSED, xmlFeature val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 1123: }
! 1124:
! 1125: static void desret_xmlParserErrors(xmlParserErrors val ATTRIBUTE_UNUSED) {
! 1126: }
! 1127:
! 1128: #ifdef LIBXML_SCHEMAS_ENABLED
! 1129: #define gen_nb_xmlSchemaValType 4
! 1130: static xmlSchemaValType gen_xmlSchemaValType(int no, int nr ATTRIBUTE_UNUSED) {
! 1131: if (no == 1) return(XML_SCHEMAS_ANYSIMPLETYPE);
! 1132: if (no == 2) return(XML_SCHEMAS_ANYTYPE);
! 1133: if (no == 3) return(XML_SCHEMAS_ANYURI);
! 1134: if (no == 4) return(XML_SCHEMAS_BASE64BINARY);
! 1135: return(0);
! 1136: }
! 1137:
! 1138: static void des_xmlSchemaValType(int no ATTRIBUTE_UNUSED, xmlSchemaValType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 1139: }
! 1140:
! 1141: static void desret_xmlSchemaValType(xmlSchemaValType val ATTRIBUTE_UNUSED) {
! 1142: }
! 1143:
! 1144: #endif
! 1145:
! 1146: #ifdef LIBXML_SCHEMAS_ENABLED
! 1147: #define gen_nb_xmlSchemaWhitespaceValueType 4
! 1148: static xmlSchemaWhitespaceValueType gen_xmlSchemaWhitespaceValueType(int no, int nr ATTRIBUTE_UNUSED) {
! 1149: if (no == 1) return(XML_SCHEMA_WHITESPACE_COLLAPSE);
! 1150: if (no == 2) return(XML_SCHEMA_WHITESPACE_PRESERVE);
! 1151: if (no == 3) return(XML_SCHEMA_WHITESPACE_REPLACE);
! 1152: if (no == 4) return(XML_SCHEMA_WHITESPACE_UNKNOWN);
! 1153: return(0);
! 1154: }
! 1155:
! 1156: static void des_xmlSchemaWhitespaceValueType(int no ATTRIBUTE_UNUSED, xmlSchemaWhitespaceValueType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 1157: }
! 1158:
! 1159: #endif
! 1160:
! 1161: #include <libxml/HTMLparser.h>
! 1162: #include <libxml/HTMLtree.h>
! 1163: #include <libxml/SAX2.h>
! 1164: #include <libxml/c14n.h>
! 1165: #include <libxml/catalog.h>
! 1166: #include <libxml/chvalid.h>
! 1167: #include <libxml/debugXML.h>
! 1168: #include <libxml/dict.h>
! 1169: #include <libxml/encoding.h>
! 1170: #include <libxml/entities.h>
! 1171: #include <libxml/hash.h>
! 1172: #include <libxml/list.h>
! 1173: #include <libxml/nanoftp.h>
! 1174: #include <libxml/nanohttp.h>
! 1175: #include <libxml/parser.h>
! 1176: #include <libxml/parserInternals.h>
! 1177: #include <libxml/pattern.h>
! 1178: #include <libxml/relaxng.h>
! 1179: #include <libxml/schemasInternals.h>
! 1180: #include <libxml/schematron.h>
! 1181: #include <libxml/tree.h>
! 1182: #include <libxml/uri.h>
! 1183: #include <libxml/valid.h>
! 1184: #include <libxml/xinclude.h>
! 1185: #include <libxml/xmlIO.h>
! 1186: #include <libxml/xmlautomata.h>
! 1187: #include <libxml/xmlerror.h>
! 1188: #include <libxml/xmlmodule.h>
! 1189: #include <libxml/xmlreader.h>
! 1190: #include <libxml/xmlregexp.h>
! 1191: #include <libxml/xmlsave.h>
! 1192: #include <libxml/xmlschemas.h>
! 1193: #include <libxml/xmlschemastypes.h>
! 1194: #include <libxml/xmlstring.h>
! 1195: #include <libxml/xmlunicode.h>
! 1196: #include <libxml/xmlwriter.h>
! 1197: #include <libxml/xpath.h>
! 1198: #include <libxml/xpathInternals.h>
! 1199: #include <libxml/xpointer.h>
! 1200: static int test_HTMLparser(void);
! 1201: static int test_HTMLtree(void);
! 1202: static int test_SAX2(void);
! 1203: static int test_c14n(void);
! 1204: static int test_catalog(void);
! 1205: static int test_chvalid(void);
! 1206: static int test_debugXML(void);
! 1207: static int test_dict(void);
! 1208: static int test_encoding(void);
! 1209: static int test_entities(void);
! 1210: static int test_hash(void);
! 1211: static int test_list(void);
! 1212: static int test_nanoftp(void);
! 1213: static int test_nanohttp(void);
! 1214: static int test_parser(void);
! 1215: static int test_parserInternals(void);
! 1216: static int test_pattern(void);
! 1217: static int test_relaxng(void);
! 1218: static int test_schemasInternals(void);
! 1219: static int test_schematron(void);
! 1220: static int test_tree(void);
! 1221: static int test_uri(void);
! 1222: static int test_valid(void);
! 1223: static int test_xinclude(void);
! 1224: static int test_xmlIO(void);
! 1225: static int test_xmlautomata(void);
! 1226: static int test_xmlerror(void);
! 1227: static int test_xmlmodule(void);
! 1228: static int test_xmlreader(void);
! 1229: static int test_xmlregexp(void);
! 1230: static int test_xmlsave(void);
! 1231: static int test_xmlschemas(void);
! 1232: static int test_xmlschemastypes(void);
! 1233: static int test_xmlstring(void);
! 1234: static int test_xmlunicode(void);
! 1235: static int test_xmlwriter(void);
! 1236: static int test_xpath(void);
! 1237: static int test_xpathInternals(void);
! 1238: static int test_xpointer(void);
! 1239:
! 1240: /**
! 1241: * testlibxml2:
! 1242: *
! 1243: * Main entry point of the tester for the full libxml2 module,
! 1244: * it calls all the tester entry point for each module.
! 1245: *
! 1246: * Returns the number of error found
! 1247: */
! 1248: static int
! 1249: testlibxml2(void)
! 1250: {
! 1251: int test_ret = 0;
! 1252:
! 1253: test_ret += test_HTMLparser();
! 1254: test_ret += test_HTMLtree();
! 1255: test_ret += test_SAX2();
! 1256: test_ret += test_c14n();
! 1257: test_ret += test_catalog();
! 1258: test_ret += test_chvalid();
! 1259: test_ret += test_debugXML();
! 1260: test_ret += test_dict();
! 1261: test_ret += test_encoding();
! 1262: test_ret += test_entities();
! 1263: test_ret += test_hash();
! 1264: test_ret += test_list();
! 1265: test_ret += test_nanoftp();
! 1266: test_ret += test_nanohttp();
! 1267: test_ret += test_parser();
! 1268: test_ret += test_parserInternals();
! 1269: test_ret += test_pattern();
! 1270: test_ret += test_relaxng();
! 1271: test_ret += test_schemasInternals();
! 1272: test_ret += test_schematron();
! 1273: test_ret += test_tree();
! 1274: test_ret += test_uri();
! 1275: test_ret += test_valid();
! 1276: test_ret += test_xinclude();
! 1277: test_ret += test_xmlIO();
! 1278: test_ret += test_xmlautomata();
! 1279: test_ret += test_xmlerror();
! 1280: test_ret += test_xmlmodule();
! 1281: test_ret += test_xmlreader();
! 1282: test_ret += test_xmlregexp();
! 1283: test_ret += test_xmlsave();
! 1284: test_ret += test_xmlschemas();
! 1285: test_ret += test_xmlschemastypes();
! 1286: test_ret += test_xmlstring();
! 1287: test_ret += test_xmlunicode();
! 1288: test_ret += test_xmlwriter();
! 1289: test_ret += test_xpath();
! 1290: test_ret += test_xpathInternals();
! 1291: test_ret += test_xpointer();
! 1292:
! 1293: printf("Total: %d functions, %d tests, %d errors\n",
! 1294: function_tests, call_tests, test_ret);
! 1295: return(test_ret);
! 1296: }
! 1297:
! 1298:
! 1299: static int
! 1300: test_UTF8ToHtml(void) {
! 1301: int test_ret = 0;
! 1302:
! 1303: #if defined(LIBXML_HTML_ENABLED)
! 1304: int mem_base;
! 1305: int ret_val;
! 1306: unsigned char * out; /* a pointer to an array of bytes to store the result */
! 1307: int n_out;
! 1308: int * outlen; /* the length of @out */
! 1309: int n_outlen;
! 1310: unsigned char * in; /* a pointer to an array of UTF-8 chars */
! 1311: int n_in;
! 1312: int * inlen; /* the length of @in */
! 1313: int n_inlen;
! 1314:
! 1315: for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
! 1316: for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
! 1317: for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
! 1318: for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
! 1319: mem_base = xmlMemBlocks();
! 1320: out = gen_unsigned_char_ptr(n_out, 0);
! 1321: outlen = gen_int_ptr(n_outlen, 1);
! 1322: in = gen_const_unsigned_char_ptr(n_in, 2);
! 1323: inlen = gen_int_ptr(n_inlen, 3);
! 1324:
! 1325: ret_val = UTF8ToHtml(out, outlen, (const unsigned char *)in, inlen);
! 1326: desret_int(ret_val);
! 1327: call_tests++;
! 1328: des_unsigned_char_ptr(n_out, out, 0);
! 1329: des_int_ptr(n_outlen, outlen, 1);
! 1330: des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2);
! 1331: des_int_ptr(n_inlen, inlen, 3);
! 1332: xmlResetLastError();
! 1333: if (mem_base != xmlMemBlocks()) {
! 1334: printf("Leak of %d blocks found in UTF8ToHtml",
! 1335: xmlMemBlocks() - mem_base);
! 1336: test_ret++;
! 1337: printf(" %d", n_out);
! 1338: printf(" %d", n_outlen);
! 1339: printf(" %d", n_in);
! 1340: printf(" %d", n_inlen);
! 1341: printf("\n");
! 1342: }
! 1343: }
! 1344: }
! 1345: }
! 1346: }
! 1347: function_tests++;
! 1348: #endif
! 1349:
! 1350: return(test_ret);
! 1351: }
! 1352:
! 1353: #ifdef LIBXML_HTML_ENABLED
! 1354:
! 1355: #define gen_nb_const_htmlElemDesc_ptr 1
! 1356: static htmlElemDesc * gen_const_htmlElemDesc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 1357: return(NULL);
! 1358: }
! 1359: static void des_const_htmlElemDesc_ptr(int no ATTRIBUTE_UNUSED, const htmlElemDesc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 1360: }
! 1361: #endif
! 1362:
! 1363:
! 1364: static int
! 1365: test_htmlAttrAllowed(void) {
! 1366: int test_ret = 0;
! 1367:
! 1368: #if defined(LIBXML_HTML_ENABLED)
! 1369: int mem_base;
! 1370: htmlStatus ret_val;
! 1371: htmlElemDesc * elt; /* HTML element */
! 1372: int n_elt;
! 1373: xmlChar * attr; /* HTML attribute */
! 1374: int n_attr;
! 1375: int legacy; /* whether to allow deprecated attributes */
! 1376: int n_legacy;
! 1377:
! 1378: for (n_elt = 0;n_elt < gen_nb_const_htmlElemDesc_ptr;n_elt++) {
! 1379: for (n_attr = 0;n_attr < gen_nb_const_xmlChar_ptr;n_attr++) {
! 1380: for (n_legacy = 0;n_legacy < gen_nb_int;n_legacy++) {
! 1381: mem_base = xmlMemBlocks();
! 1382: elt = gen_const_htmlElemDesc_ptr(n_elt, 0);
! 1383: attr = gen_const_xmlChar_ptr(n_attr, 1);
! 1384: legacy = gen_int(n_legacy, 2);
! 1385:
! 1386: ret_val = htmlAttrAllowed((const htmlElemDesc *)elt, (const xmlChar *)attr, legacy);
! 1387: desret_htmlStatus(ret_val);
! 1388: call_tests++;
! 1389: des_const_htmlElemDesc_ptr(n_elt, (const htmlElemDesc *)elt, 0);
! 1390: des_const_xmlChar_ptr(n_attr, (const xmlChar *)attr, 1);
! 1391: des_int(n_legacy, legacy, 2);
! 1392: xmlResetLastError();
! 1393: if (mem_base != xmlMemBlocks()) {
! 1394: printf("Leak of %d blocks found in htmlAttrAllowed",
! 1395: xmlMemBlocks() - mem_base);
! 1396: test_ret++;
! 1397: printf(" %d", n_elt);
! 1398: printf(" %d", n_attr);
! 1399: printf(" %d", n_legacy);
! 1400: printf("\n");
! 1401: }
! 1402: }
! 1403: }
! 1404: }
! 1405: function_tests++;
! 1406: #endif
! 1407:
! 1408: return(test_ret);
! 1409: }
! 1410:
! 1411: #ifdef LIBXML_HTML_ENABLED
! 1412:
! 1413: #define gen_nb_htmlNodePtr 1
! 1414: static htmlNodePtr gen_htmlNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 1415: return(NULL);
! 1416: }
! 1417: static void des_htmlNodePtr(int no ATTRIBUTE_UNUSED, htmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 1418: }
! 1419: #endif
! 1420:
! 1421:
! 1422: static int
! 1423: test_htmlAutoCloseTag(void) {
! 1424: int test_ret = 0;
! 1425:
! 1426: #if defined(LIBXML_HTML_ENABLED)
! 1427: int mem_base;
! 1428: int ret_val;
! 1429: htmlDocPtr doc; /* the HTML document */
! 1430: int n_doc;
! 1431: xmlChar * name; /* The tag name */
! 1432: int n_name;
! 1433: htmlNodePtr elem; /* the HTML element */
! 1434: int n_elem;
! 1435:
! 1436: for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) {
! 1437: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 1438: for (n_elem = 0;n_elem < gen_nb_htmlNodePtr;n_elem++) {
! 1439: mem_base = xmlMemBlocks();
! 1440: doc = gen_htmlDocPtr(n_doc, 0);
! 1441: name = gen_const_xmlChar_ptr(n_name, 1);
! 1442: elem = gen_htmlNodePtr(n_elem, 2);
! 1443:
! 1444: ret_val = htmlAutoCloseTag(doc, (const xmlChar *)name, elem);
! 1445: desret_int(ret_val);
! 1446: call_tests++;
! 1447: des_htmlDocPtr(n_doc, doc, 0);
! 1448: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 1449: des_htmlNodePtr(n_elem, elem, 2);
! 1450: xmlResetLastError();
! 1451: if (mem_base != xmlMemBlocks()) {
! 1452: printf("Leak of %d blocks found in htmlAutoCloseTag",
! 1453: xmlMemBlocks() - mem_base);
! 1454: test_ret++;
! 1455: printf(" %d", n_doc);
! 1456: printf(" %d", n_name);
! 1457: printf(" %d", n_elem);
! 1458: printf("\n");
! 1459: }
! 1460: }
! 1461: }
! 1462: }
! 1463: function_tests++;
! 1464: #endif
! 1465:
! 1466: return(test_ret);
! 1467: }
! 1468:
! 1469:
! 1470: static int
! 1471: test_htmlCreateMemoryParserCtxt(void) {
! 1472: int test_ret = 0;
! 1473:
! 1474: #if defined(LIBXML_HTML_ENABLED)
! 1475: int mem_base;
! 1476: htmlParserCtxtPtr ret_val;
! 1477: char * buffer; /* a pointer to a char array */
! 1478: int n_buffer;
! 1479: int size; /* the size of the array */
! 1480: int n_size;
! 1481:
! 1482: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
! 1483: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 1484: mem_base = xmlMemBlocks();
! 1485: buffer = gen_const_char_ptr(n_buffer, 0);
! 1486: size = gen_int(n_size, 1);
! 1487:
! 1488: ret_val = htmlCreateMemoryParserCtxt((const char *)buffer, size);
! 1489: desret_htmlParserCtxtPtr(ret_val);
! 1490: call_tests++;
! 1491: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
! 1492: des_int(n_size, size, 1);
! 1493: xmlResetLastError();
! 1494: if (mem_base != xmlMemBlocks()) {
! 1495: printf("Leak of %d blocks found in htmlCreateMemoryParserCtxt",
! 1496: xmlMemBlocks() - mem_base);
! 1497: test_ret++;
! 1498: printf(" %d", n_buffer);
! 1499: printf(" %d", n_size);
! 1500: printf("\n");
! 1501: }
! 1502: }
! 1503: }
! 1504: function_tests++;
! 1505: #endif
! 1506:
! 1507: return(test_ret);
! 1508: }
! 1509:
! 1510: #ifdef LIBXML_HTML_ENABLED
! 1511:
! 1512: #define gen_nb_htmlSAXHandlerPtr 1
! 1513: static htmlSAXHandlerPtr gen_htmlSAXHandlerPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 1514: return(NULL);
! 1515: }
! 1516: static void des_htmlSAXHandlerPtr(int no ATTRIBUTE_UNUSED, htmlSAXHandlerPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 1517: }
! 1518: #endif
! 1519:
! 1520:
! 1521: static int
! 1522: test_htmlCreatePushParserCtxt(void) {
! 1523: int test_ret = 0;
! 1524:
! 1525: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_PUSH_ENABLED)
! 1526: int mem_base;
! 1527: htmlParserCtxtPtr ret_val;
! 1528: htmlSAXHandlerPtr sax; /* a SAX handler */
! 1529: int n_sax;
! 1530: void * user_data; /* The user data returned on SAX callbacks */
! 1531: int n_user_data;
! 1532: char * chunk; /* a pointer to an array of chars */
! 1533: int n_chunk;
! 1534: int size; /* number of chars in the array */
! 1535: int n_size;
! 1536: const char * filename; /* an optional file name or URI */
! 1537: int n_filename;
! 1538: xmlCharEncoding enc; /* an optional encoding */
! 1539: int n_enc;
! 1540:
! 1541: for (n_sax = 0;n_sax < gen_nb_htmlSAXHandlerPtr;n_sax++) {
! 1542: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
! 1543: for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
! 1544: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 1545: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
! 1546: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
! 1547: mem_base = xmlMemBlocks();
! 1548: sax = gen_htmlSAXHandlerPtr(n_sax, 0);
! 1549: user_data = gen_userdata(n_user_data, 1);
! 1550: chunk = gen_const_char_ptr(n_chunk, 2);
! 1551: size = gen_int(n_size, 3);
! 1552: filename = gen_fileoutput(n_filename, 4);
! 1553: enc = gen_xmlCharEncoding(n_enc, 5);
! 1554:
! 1555: ret_val = htmlCreatePushParserCtxt(sax, user_data, (const char *)chunk, size, filename, enc);
! 1556: desret_htmlParserCtxtPtr(ret_val);
! 1557: call_tests++;
! 1558: des_htmlSAXHandlerPtr(n_sax, sax, 0);
! 1559: des_userdata(n_user_data, user_data, 1);
! 1560: des_const_char_ptr(n_chunk, (const char *)chunk, 2);
! 1561: des_int(n_size, size, 3);
! 1562: des_fileoutput(n_filename, filename, 4);
! 1563: des_xmlCharEncoding(n_enc, enc, 5);
! 1564: xmlResetLastError();
! 1565: if (mem_base != xmlMemBlocks()) {
! 1566: printf("Leak of %d blocks found in htmlCreatePushParserCtxt",
! 1567: xmlMemBlocks() - mem_base);
! 1568: test_ret++;
! 1569: printf(" %d", n_sax);
! 1570: printf(" %d", n_user_data);
! 1571: printf(" %d", n_chunk);
! 1572: printf(" %d", n_size);
! 1573: printf(" %d", n_filename);
! 1574: printf(" %d", n_enc);
! 1575: printf("\n");
! 1576: }
! 1577: }
! 1578: }
! 1579: }
! 1580: }
! 1581: }
! 1582: }
! 1583: function_tests++;
! 1584: #endif
! 1585:
! 1586: return(test_ret);
! 1587: }
! 1588:
! 1589:
! 1590: static int
! 1591: test_htmlCtxtReadDoc(void) {
! 1592: int test_ret = 0;
! 1593:
! 1594: #if defined(LIBXML_HTML_ENABLED)
! 1595: int mem_base;
! 1596: htmlDocPtr ret_val;
! 1597: htmlParserCtxtPtr ctxt; /* an HTML parser context */
! 1598: int n_ctxt;
! 1599: xmlChar * cur; /* a pointer to a zero terminated string */
! 1600: int n_cur;
! 1601: const char * URL; /* the base URL to use for the document */
! 1602: int n_URL;
! 1603: char * encoding; /* the document encoding, or NULL */
! 1604: int n_encoding;
! 1605: int options; /* a combination of htmlParserOption(s) */
! 1606: int n_options;
! 1607:
! 1608: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
! 1609: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
! 1610: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 1611: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 1612: for (n_options = 0;n_options < gen_nb_int;n_options++) {
! 1613: mem_base = xmlMemBlocks();
! 1614: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
! 1615: cur = gen_const_xmlChar_ptr(n_cur, 1);
! 1616: URL = gen_filepath(n_URL, 2);
! 1617: encoding = gen_const_char_ptr(n_encoding, 3);
! 1618: options = gen_int(n_options, 4);
! 1619:
! 1620: ret_val = htmlCtxtReadDoc(ctxt, (const xmlChar *)cur, URL, (const char *)encoding, options);
! 1621: desret_htmlDocPtr(ret_val);
! 1622: call_tests++;
! 1623: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 1624: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
! 1625: des_filepath(n_URL, URL, 2);
! 1626: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
! 1627: des_int(n_options, options, 4);
! 1628: xmlResetLastError();
! 1629: if (mem_base != xmlMemBlocks()) {
! 1630: printf("Leak of %d blocks found in htmlCtxtReadDoc",
! 1631: xmlMemBlocks() - mem_base);
! 1632: test_ret++;
! 1633: printf(" %d", n_ctxt);
! 1634: printf(" %d", n_cur);
! 1635: printf(" %d", n_URL);
! 1636: printf(" %d", n_encoding);
! 1637: printf(" %d", n_options);
! 1638: printf("\n");
! 1639: }
! 1640: }
! 1641: }
! 1642: }
! 1643: }
! 1644: }
! 1645: function_tests++;
! 1646: #endif
! 1647:
! 1648: return(test_ret);
! 1649: }
! 1650:
! 1651:
! 1652: static int
! 1653: test_htmlCtxtReadFile(void) {
! 1654: int test_ret = 0;
! 1655:
! 1656: #if defined(LIBXML_HTML_ENABLED)
! 1657: htmlDocPtr ret_val;
! 1658: htmlParserCtxtPtr ctxt; /* an HTML parser context */
! 1659: int n_ctxt;
! 1660: const char * filename; /* a file or URL */
! 1661: int n_filename;
! 1662: char * encoding; /* the document encoding, or NULL */
! 1663: int n_encoding;
! 1664: int options; /* a combination of htmlParserOption(s) */
! 1665: int n_options;
! 1666:
! 1667: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
! 1668: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 1669: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 1670: for (n_options = 0;n_options < gen_nb_int;n_options++) {
! 1671: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
! 1672: filename = gen_filepath(n_filename, 1);
! 1673: encoding = gen_const_char_ptr(n_encoding, 2);
! 1674: options = gen_int(n_options, 3);
! 1675:
! 1676: ret_val = htmlCtxtReadFile(ctxt, filename, (const char *)encoding, options);
! 1677: desret_htmlDocPtr(ret_val);
! 1678: call_tests++;
! 1679: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 1680: des_filepath(n_filename, filename, 1);
! 1681: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
! 1682: des_int(n_options, options, 3);
! 1683: xmlResetLastError();
! 1684: }
! 1685: }
! 1686: }
! 1687: }
! 1688: function_tests++;
! 1689: #endif
! 1690:
! 1691: return(test_ret);
! 1692: }
! 1693:
! 1694:
! 1695: static int
! 1696: test_htmlCtxtReadMemory(void) {
! 1697: int test_ret = 0;
! 1698:
! 1699: #if defined(LIBXML_HTML_ENABLED)
! 1700: int mem_base;
! 1701: htmlDocPtr ret_val;
! 1702: htmlParserCtxtPtr ctxt; /* an HTML parser context */
! 1703: int n_ctxt;
! 1704: char * buffer; /* a pointer to a char array */
! 1705: int n_buffer;
! 1706: int size; /* the size of the array */
! 1707: int n_size;
! 1708: const char * URL; /* the base URL to use for the document */
! 1709: int n_URL;
! 1710: char * encoding; /* the document encoding, or NULL */
! 1711: int n_encoding;
! 1712: int options; /* a combination of htmlParserOption(s) */
! 1713: int n_options;
! 1714:
! 1715: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
! 1716: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
! 1717: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 1718: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 1719: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 1720: for (n_options = 0;n_options < gen_nb_int;n_options++) {
! 1721: mem_base = xmlMemBlocks();
! 1722: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
! 1723: buffer = gen_const_char_ptr(n_buffer, 1);
! 1724: size = gen_int(n_size, 2);
! 1725: URL = gen_filepath(n_URL, 3);
! 1726: encoding = gen_const_char_ptr(n_encoding, 4);
! 1727: options = gen_int(n_options, 5);
! 1728:
! 1729: ret_val = htmlCtxtReadMemory(ctxt, (const char *)buffer, size, URL, (const char *)encoding, options);
! 1730: desret_htmlDocPtr(ret_val);
! 1731: call_tests++;
! 1732: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 1733: des_const_char_ptr(n_buffer, (const char *)buffer, 1);
! 1734: des_int(n_size, size, 2);
! 1735: des_filepath(n_URL, URL, 3);
! 1736: des_const_char_ptr(n_encoding, (const char *)encoding, 4);
! 1737: des_int(n_options, options, 5);
! 1738: xmlResetLastError();
! 1739: if (mem_base != xmlMemBlocks()) {
! 1740: printf("Leak of %d blocks found in htmlCtxtReadMemory",
! 1741: xmlMemBlocks() - mem_base);
! 1742: test_ret++;
! 1743: printf(" %d", n_ctxt);
! 1744: printf(" %d", n_buffer);
! 1745: printf(" %d", n_size);
! 1746: printf(" %d", n_URL);
! 1747: printf(" %d", n_encoding);
! 1748: printf(" %d", n_options);
! 1749: printf("\n");
! 1750: }
! 1751: }
! 1752: }
! 1753: }
! 1754: }
! 1755: }
! 1756: }
! 1757: function_tests++;
! 1758: #endif
! 1759:
! 1760: return(test_ret);
! 1761: }
! 1762:
! 1763:
! 1764: static int
! 1765: test_htmlCtxtReset(void) {
! 1766: int test_ret = 0;
! 1767:
! 1768: #if defined(LIBXML_HTML_ENABLED)
! 1769: int mem_base;
! 1770: htmlParserCtxtPtr ctxt; /* an HTML parser context */
! 1771: int n_ctxt;
! 1772:
! 1773: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
! 1774: mem_base = xmlMemBlocks();
! 1775: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
! 1776:
! 1777: htmlCtxtReset(ctxt);
! 1778: call_tests++;
! 1779: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 1780: xmlResetLastError();
! 1781: if (mem_base != xmlMemBlocks()) {
! 1782: printf("Leak of %d blocks found in htmlCtxtReset",
! 1783: xmlMemBlocks() - mem_base);
! 1784: test_ret++;
! 1785: printf(" %d", n_ctxt);
! 1786: printf("\n");
! 1787: }
! 1788: }
! 1789: function_tests++;
! 1790: #endif
! 1791:
! 1792: return(test_ret);
! 1793: }
! 1794:
! 1795:
! 1796: static int
! 1797: test_htmlCtxtUseOptions(void) {
! 1798: int test_ret = 0;
! 1799:
! 1800: #if defined(LIBXML_HTML_ENABLED)
! 1801: int mem_base;
! 1802: int ret_val;
! 1803: htmlParserCtxtPtr ctxt; /* an HTML parser context */
! 1804: int n_ctxt;
! 1805: int options; /* a combination of htmlParserOption(s) */
! 1806: int n_options;
! 1807:
! 1808: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
! 1809: for (n_options = 0;n_options < gen_nb_int;n_options++) {
! 1810: mem_base = xmlMemBlocks();
! 1811: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
! 1812: options = gen_int(n_options, 1);
! 1813:
! 1814: ret_val = htmlCtxtUseOptions(ctxt, options);
! 1815: desret_int(ret_val);
! 1816: call_tests++;
! 1817: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 1818: des_int(n_options, options, 1);
! 1819: xmlResetLastError();
! 1820: if (mem_base != xmlMemBlocks()) {
! 1821: printf("Leak of %d blocks found in htmlCtxtUseOptions",
! 1822: xmlMemBlocks() - mem_base);
! 1823: test_ret++;
! 1824: printf(" %d", n_ctxt);
! 1825: printf(" %d", n_options);
! 1826: printf("\n");
! 1827: }
! 1828: }
! 1829: }
! 1830: function_tests++;
! 1831: #endif
! 1832:
! 1833: return(test_ret);
! 1834: }
! 1835:
! 1836:
! 1837: static int
! 1838: test_htmlElementAllowedHere(void) {
! 1839: int test_ret = 0;
! 1840:
! 1841: #if defined(LIBXML_HTML_ENABLED)
! 1842: int mem_base;
! 1843: int ret_val;
! 1844: htmlElemDesc * parent; /* HTML parent element */
! 1845: int n_parent;
! 1846: xmlChar * elt; /* HTML element */
! 1847: int n_elt;
! 1848:
! 1849: for (n_parent = 0;n_parent < gen_nb_const_htmlElemDesc_ptr;n_parent++) {
! 1850: for (n_elt = 0;n_elt < gen_nb_const_xmlChar_ptr;n_elt++) {
! 1851: mem_base = xmlMemBlocks();
! 1852: parent = gen_const_htmlElemDesc_ptr(n_parent, 0);
! 1853: elt = gen_const_xmlChar_ptr(n_elt, 1);
! 1854:
! 1855: ret_val = htmlElementAllowedHere((const htmlElemDesc *)parent, (const xmlChar *)elt);
! 1856: desret_int(ret_val);
! 1857: call_tests++;
! 1858: des_const_htmlElemDesc_ptr(n_parent, (const htmlElemDesc *)parent, 0);
! 1859: des_const_xmlChar_ptr(n_elt, (const xmlChar *)elt, 1);
! 1860: xmlResetLastError();
! 1861: if (mem_base != xmlMemBlocks()) {
! 1862: printf("Leak of %d blocks found in htmlElementAllowedHere",
! 1863: xmlMemBlocks() - mem_base);
! 1864: test_ret++;
! 1865: printf(" %d", n_parent);
! 1866: printf(" %d", n_elt);
! 1867: printf("\n");
! 1868: }
! 1869: }
! 1870: }
! 1871: function_tests++;
! 1872: #endif
! 1873:
! 1874: return(test_ret);
! 1875: }
! 1876:
! 1877:
! 1878: static int
! 1879: test_htmlElementStatusHere(void) {
! 1880: int test_ret = 0;
! 1881:
! 1882: #if defined(LIBXML_HTML_ENABLED)
! 1883: int mem_base;
! 1884: htmlStatus ret_val;
! 1885: htmlElemDesc * parent; /* HTML parent element */
! 1886: int n_parent;
! 1887: htmlElemDesc * elt; /* HTML element */
! 1888: int n_elt;
! 1889:
! 1890: for (n_parent = 0;n_parent < gen_nb_const_htmlElemDesc_ptr;n_parent++) {
! 1891: for (n_elt = 0;n_elt < gen_nb_const_htmlElemDesc_ptr;n_elt++) {
! 1892: mem_base = xmlMemBlocks();
! 1893: parent = gen_const_htmlElemDesc_ptr(n_parent, 0);
! 1894: elt = gen_const_htmlElemDesc_ptr(n_elt, 1);
! 1895:
! 1896: ret_val = htmlElementStatusHere((const htmlElemDesc *)parent, (const htmlElemDesc *)elt);
! 1897: desret_htmlStatus(ret_val);
! 1898: call_tests++;
! 1899: des_const_htmlElemDesc_ptr(n_parent, (const htmlElemDesc *)parent, 0);
! 1900: des_const_htmlElemDesc_ptr(n_elt, (const htmlElemDesc *)elt, 1);
! 1901: xmlResetLastError();
! 1902: if (mem_base != xmlMemBlocks()) {
! 1903: printf("Leak of %d blocks found in htmlElementStatusHere",
! 1904: xmlMemBlocks() - mem_base);
! 1905: test_ret++;
! 1906: printf(" %d", n_parent);
! 1907: printf(" %d", n_elt);
! 1908: printf("\n");
! 1909: }
! 1910: }
! 1911: }
! 1912: function_tests++;
! 1913: #endif
! 1914:
! 1915: return(test_ret);
! 1916: }
! 1917:
! 1918:
! 1919: static int
! 1920: test_htmlEncodeEntities(void) {
! 1921: int test_ret = 0;
! 1922:
! 1923: #if defined(LIBXML_HTML_ENABLED)
! 1924: int mem_base;
! 1925: int ret_val;
! 1926: unsigned char * out; /* a pointer to an array of bytes to store the result */
! 1927: int n_out;
! 1928: int * outlen; /* the length of @out */
! 1929: int n_outlen;
! 1930: unsigned char * in; /* a pointer to an array of UTF-8 chars */
! 1931: int n_in;
! 1932: int * inlen; /* the length of @in */
! 1933: int n_inlen;
! 1934: int quoteChar; /* the quote character to escape (' or ") or zero. */
! 1935: int n_quoteChar;
! 1936:
! 1937: for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
! 1938: for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
! 1939: for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
! 1940: for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
! 1941: for (n_quoteChar = 0;n_quoteChar < gen_nb_int;n_quoteChar++) {
! 1942: mem_base = xmlMemBlocks();
! 1943: out = gen_unsigned_char_ptr(n_out, 0);
! 1944: outlen = gen_int_ptr(n_outlen, 1);
! 1945: in = gen_const_unsigned_char_ptr(n_in, 2);
! 1946: inlen = gen_int_ptr(n_inlen, 3);
! 1947: quoteChar = gen_int(n_quoteChar, 4);
! 1948:
! 1949: ret_val = htmlEncodeEntities(out, outlen, (const unsigned char *)in, inlen, quoteChar);
! 1950: desret_int(ret_val);
! 1951: call_tests++;
! 1952: des_unsigned_char_ptr(n_out, out, 0);
! 1953: des_int_ptr(n_outlen, outlen, 1);
! 1954: des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2);
! 1955: des_int_ptr(n_inlen, inlen, 3);
! 1956: des_int(n_quoteChar, quoteChar, 4);
! 1957: xmlResetLastError();
! 1958: if (mem_base != xmlMemBlocks()) {
! 1959: printf("Leak of %d blocks found in htmlEncodeEntities",
! 1960: xmlMemBlocks() - mem_base);
! 1961: test_ret++;
! 1962: printf(" %d", n_out);
! 1963: printf(" %d", n_outlen);
! 1964: printf(" %d", n_in);
! 1965: printf(" %d", n_inlen);
! 1966: printf(" %d", n_quoteChar);
! 1967: printf("\n");
! 1968: }
! 1969: }
! 1970: }
! 1971: }
! 1972: }
! 1973: }
! 1974: function_tests++;
! 1975: #endif
! 1976:
! 1977: return(test_ret);
! 1978: }
! 1979:
! 1980:
! 1981: static int
! 1982: test_htmlEntityLookup(void) {
! 1983: int test_ret = 0;
! 1984:
! 1985: #if defined(LIBXML_HTML_ENABLED)
! 1986: int mem_base;
! 1987: const htmlEntityDesc * ret_val;
! 1988: xmlChar * name; /* the entity name */
! 1989: int n_name;
! 1990:
! 1991: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 1992: mem_base = xmlMemBlocks();
! 1993: name = gen_const_xmlChar_ptr(n_name, 0);
! 1994:
! 1995: ret_val = htmlEntityLookup((const xmlChar *)name);
! 1996: desret_const_htmlEntityDesc_ptr(ret_val);
! 1997: call_tests++;
! 1998: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
! 1999: xmlResetLastError();
! 2000: if (mem_base != xmlMemBlocks()) {
! 2001: printf("Leak of %d blocks found in htmlEntityLookup",
! 2002: xmlMemBlocks() - mem_base);
! 2003: test_ret++;
! 2004: printf(" %d", n_name);
! 2005: printf("\n");
! 2006: }
! 2007: }
! 2008: function_tests++;
! 2009: #endif
! 2010:
! 2011: return(test_ret);
! 2012: }
! 2013:
! 2014:
! 2015: static int
! 2016: test_htmlEntityValueLookup(void) {
! 2017: int test_ret = 0;
! 2018:
! 2019: #if defined(LIBXML_HTML_ENABLED)
! 2020: int mem_base;
! 2021: const htmlEntityDesc * ret_val;
! 2022: unsigned int value; /* the entity's unicode value */
! 2023: int n_value;
! 2024:
! 2025: for (n_value = 0;n_value < gen_nb_unsigned_int;n_value++) {
! 2026: mem_base = xmlMemBlocks();
! 2027: value = gen_unsigned_int(n_value, 0);
! 2028:
! 2029: ret_val = htmlEntityValueLookup(value);
! 2030: desret_const_htmlEntityDesc_ptr(ret_val);
! 2031: call_tests++;
! 2032: des_unsigned_int(n_value, value, 0);
! 2033: xmlResetLastError();
! 2034: if (mem_base != xmlMemBlocks()) {
! 2035: printf("Leak of %d blocks found in htmlEntityValueLookup",
! 2036: xmlMemBlocks() - mem_base);
! 2037: test_ret++;
! 2038: printf(" %d", n_value);
! 2039: printf("\n");
! 2040: }
! 2041: }
! 2042: function_tests++;
! 2043: #endif
! 2044:
! 2045: return(test_ret);
! 2046: }
! 2047:
! 2048:
! 2049: static int
! 2050: test_htmlHandleOmittedElem(void) {
! 2051: int test_ret = 0;
! 2052:
! 2053: #if defined(LIBXML_HTML_ENABLED)
! 2054: int mem_base;
! 2055: int ret_val;
! 2056: int val; /* int 0 or 1 */
! 2057: int n_val;
! 2058:
! 2059: for (n_val = 0;n_val < gen_nb_int;n_val++) {
! 2060: mem_base = xmlMemBlocks();
! 2061: val = gen_int(n_val, 0);
! 2062:
! 2063: ret_val = htmlHandleOmittedElem(val);
! 2064: desret_int(ret_val);
! 2065: call_tests++;
! 2066: des_int(n_val, val, 0);
! 2067: xmlResetLastError();
! 2068: if (mem_base != xmlMemBlocks()) {
! 2069: printf("Leak of %d blocks found in htmlHandleOmittedElem",
! 2070: xmlMemBlocks() - mem_base);
! 2071: test_ret++;
! 2072: printf(" %d", n_val);
! 2073: printf("\n");
! 2074: }
! 2075: }
! 2076: function_tests++;
! 2077: #endif
! 2078:
! 2079: return(test_ret);
! 2080: }
! 2081:
! 2082:
! 2083: static int
! 2084: test_htmlIsAutoClosed(void) {
! 2085: int test_ret = 0;
! 2086:
! 2087: #if defined(LIBXML_HTML_ENABLED)
! 2088: int mem_base;
! 2089: int ret_val;
! 2090: htmlDocPtr doc; /* the HTML document */
! 2091: int n_doc;
! 2092: htmlNodePtr elem; /* the HTML element */
! 2093: int n_elem;
! 2094:
! 2095: for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) {
! 2096: for (n_elem = 0;n_elem < gen_nb_htmlNodePtr;n_elem++) {
! 2097: mem_base = xmlMemBlocks();
! 2098: doc = gen_htmlDocPtr(n_doc, 0);
! 2099: elem = gen_htmlNodePtr(n_elem, 1);
! 2100:
! 2101: ret_val = htmlIsAutoClosed(doc, elem);
! 2102: desret_int(ret_val);
! 2103: call_tests++;
! 2104: des_htmlDocPtr(n_doc, doc, 0);
! 2105: des_htmlNodePtr(n_elem, elem, 1);
! 2106: xmlResetLastError();
! 2107: if (mem_base != xmlMemBlocks()) {
! 2108: printf("Leak of %d blocks found in htmlIsAutoClosed",
! 2109: xmlMemBlocks() - mem_base);
! 2110: test_ret++;
! 2111: printf(" %d", n_doc);
! 2112: printf(" %d", n_elem);
! 2113: printf("\n");
! 2114: }
! 2115: }
! 2116: }
! 2117: function_tests++;
! 2118: #endif
! 2119:
! 2120: return(test_ret);
! 2121: }
! 2122:
! 2123:
! 2124: static int
! 2125: test_htmlIsScriptAttribute(void) {
! 2126: int test_ret = 0;
! 2127:
! 2128: #if defined(LIBXML_HTML_ENABLED)
! 2129: int mem_base;
! 2130: int ret_val;
! 2131: xmlChar * name; /* an attribute name */
! 2132: int n_name;
! 2133:
! 2134: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 2135: mem_base = xmlMemBlocks();
! 2136: name = gen_const_xmlChar_ptr(n_name, 0);
! 2137:
! 2138: ret_val = htmlIsScriptAttribute((const xmlChar *)name);
! 2139: desret_int(ret_val);
! 2140: call_tests++;
! 2141: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
! 2142: xmlResetLastError();
! 2143: if (mem_base != xmlMemBlocks()) {
! 2144: printf("Leak of %d blocks found in htmlIsScriptAttribute",
! 2145: xmlMemBlocks() - mem_base);
! 2146: test_ret++;
! 2147: printf(" %d", n_name);
! 2148: printf("\n");
! 2149: }
! 2150: }
! 2151: function_tests++;
! 2152: #endif
! 2153:
! 2154: return(test_ret);
! 2155: }
! 2156:
! 2157:
! 2158: static int
! 2159: test_htmlNewParserCtxt(void) {
! 2160: int test_ret = 0;
! 2161:
! 2162: #if defined(LIBXML_HTML_ENABLED)
! 2163: int mem_base;
! 2164: htmlParserCtxtPtr ret_val;
! 2165:
! 2166: mem_base = xmlMemBlocks();
! 2167:
! 2168: ret_val = htmlNewParserCtxt();
! 2169: desret_htmlParserCtxtPtr(ret_val);
! 2170: call_tests++;
! 2171: xmlResetLastError();
! 2172: if (mem_base != xmlMemBlocks()) {
! 2173: printf("Leak of %d blocks found in htmlNewParserCtxt",
! 2174: xmlMemBlocks() - mem_base);
! 2175: test_ret++;
! 2176: printf("\n");
! 2177: }
! 2178: function_tests++;
! 2179: #endif
! 2180:
! 2181: return(test_ret);
! 2182: }
! 2183:
! 2184:
! 2185: static int
! 2186: test_htmlNodeStatus(void) {
! 2187: int test_ret = 0;
! 2188:
! 2189: #if defined(LIBXML_HTML_ENABLED)
! 2190: int mem_base;
! 2191: htmlStatus ret_val;
! 2192: htmlNodePtr node; /* an htmlNodePtr in a tree */
! 2193: int n_node;
! 2194: int legacy; /* whether to allow deprecated elements (YES is faster here for Element nodes) */
! 2195: int n_legacy;
! 2196:
! 2197: for (n_node = 0;n_node < gen_nb_const_htmlNodePtr;n_node++) {
! 2198: for (n_legacy = 0;n_legacy < gen_nb_int;n_legacy++) {
! 2199: mem_base = xmlMemBlocks();
! 2200: node = gen_const_htmlNodePtr(n_node, 0);
! 2201: legacy = gen_int(n_legacy, 1);
! 2202:
! 2203: ret_val = htmlNodeStatus((const htmlNodePtr)node, legacy);
! 2204: desret_htmlStatus(ret_val);
! 2205: call_tests++;
! 2206: des_const_htmlNodePtr(n_node, (const htmlNodePtr)node, 0);
! 2207: des_int(n_legacy, legacy, 1);
! 2208: xmlResetLastError();
! 2209: if (mem_base != xmlMemBlocks()) {
! 2210: printf("Leak of %d blocks found in htmlNodeStatus",
! 2211: xmlMemBlocks() - mem_base);
! 2212: test_ret++;
! 2213: printf(" %d", n_node);
! 2214: printf(" %d", n_legacy);
! 2215: printf("\n");
! 2216: }
! 2217: }
! 2218: }
! 2219: function_tests++;
! 2220: #endif
! 2221:
! 2222: return(test_ret);
! 2223: }
! 2224:
! 2225:
! 2226: static int
! 2227: test_htmlParseCharRef(void) {
! 2228: int test_ret = 0;
! 2229:
! 2230: #if defined(LIBXML_HTML_ENABLED)
! 2231: int mem_base;
! 2232: int ret_val;
! 2233: htmlParserCtxtPtr ctxt; /* an HTML parser context */
! 2234: int n_ctxt;
! 2235:
! 2236: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
! 2237: mem_base = xmlMemBlocks();
! 2238: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
! 2239:
! 2240: ret_val = htmlParseCharRef(ctxt);
! 2241: desret_int(ret_val);
! 2242: call_tests++;
! 2243: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 2244: xmlResetLastError();
! 2245: if (mem_base != xmlMemBlocks()) {
! 2246: printf("Leak of %d blocks found in htmlParseCharRef",
! 2247: xmlMemBlocks() - mem_base);
! 2248: test_ret++;
! 2249: printf(" %d", n_ctxt);
! 2250: printf("\n");
! 2251: }
! 2252: }
! 2253: function_tests++;
! 2254: #endif
! 2255:
! 2256: return(test_ret);
! 2257: }
! 2258:
! 2259:
! 2260: static int
! 2261: test_htmlParseChunk(void) {
! 2262: int test_ret = 0;
! 2263:
! 2264: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_PUSH_ENABLED)
! 2265: int mem_base;
! 2266: int ret_val;
! 2267: htmlParserCtxtPtr ctxt; /* an HTML parser context */
! 2268: int n_ctxt;
! 2269: char * chunk; /* an char array */
! 2270: int n_chunk;
! 2271: int size; /* the size in byte of the chunk */
! 2272: int n_size;
! 2273: int terminate; /* last chunk indicator */
! 2274: int n_terminate;
! 2275:
! 2276: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
! 2277: for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
! 2278: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 2279: for (n_terminate = 0;n_terminate < gen_nb_int;n_terminate++) {
! 2280: mem_base = xmlMemBlocks();
! 2281: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
! 2282: chunk = gen_const_char_ptr(n_chunk, 1);
! 2283: size = gen_int(n_size, 2);
! 2284: terminate = gen_int(n_terminate, 3);
! 2285:
! 2286: ret_val = htmlParseChunk(ctxt, (const char *)chunk, size, terminate);
! 2287: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
! 2288: desret_int(ret_val);
! 2289: call_tests++;
! 2290: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 2291: des_const_char_ptr(n_chunk, (const char *)chunk, 1);
! 2292: des_int(n_size, size, 2);
! 2293: des_int(n_terminate, terminate, 3);
! 2294: xmlResetLastError();
! 2295: if (mem_base != xmlMemBlocks()) {
! 2296: printf("Leak of %d blocks found in htmlParseChunk",
! 2297: xmlMemBlocks() - mem_base);
! 2298: test_ret++;
! 2299: printf(" %d", n_ctxt);
! 2300: printf(" %d", n_chunk);
! 2301: printf(" %d", n_size);
! 2302: printf(" %d", n_terminate);
! 2303: printf("\n");
! 2304: }
! 2305: }
! 2306: }
! 2307: }
! 2308: }
! 2309: function_tests++;
! 2310: #endif
! 2311:
! 2312: return(test_ret);
! 2313: }
! 2314:
! 2315:
! 2316: static int
! 2317: test_htmlParseDoc(void) {
! 2318: int test_ret = 0;
! 2319:
! 2320: #if defined(LIBXML_HTML_ENABLED)
! 2321: int mem_base;
! 2322: htmlDocPtr ret_val;
! 2323: xmlChar * cur; /* a pointer to an array of xmlChar */
! 2324: int n_cur;
! 2325: char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
! 2326: int n_encoding;
! 2327:
! 2328: for (n_cur = 0;n_cur < gen_nb_xmlChar_ptr;n_cur++) {
! 2329: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 2330: mem_base = xmlMemBlocks();
! 2331: cur = gen_xmlChar_ptr(n_cur, 0);
! 2332: encoding = gen_const_char_ptr(n_encoding, 1);
! 2333:
! 2334: ret_val = htmlParseDoc(cur, (const char *)encoding);
! 2335: desret_htmlDocPtr(ret_val);
! 2336: call_tests++;
! 2337: des_xmlChar_ptr(n_cur, cur, 0);
! 2338: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
! 2339: xmlResetLastError();
! 2340: if (mem_base != xmlMemBlocks()) {
! 2341: printf("Leak of %d blocks found in htmlParseDoc",
! 2342: xmlMemBlocks() - mem_base);
! 2343: test_ret++;
! 2344: printf(" %d", n_cur);
! 2345: printf(" %d", n_encoding);
! 2346: printf("\n");
! 2347: }
! 2348: }
! 2349: }
! 2350: function_tests++;
! 2351: #endif
! 2352:
! 2353: return(test_ret);
! 2354: }
! 2355:
! 2356:
! 2357: static int
! 2358: test_htmlParseDocument(void) {
! 2359: int test_ret = 0;
! 2360:
! 2361: #if defined(LIBXML_HTML_ENABLED)
! 2362: int mem_base;
! 2363: int ret_val;
! 2364: htmlParserCtxtPtr ctxt; /* an HTML parser context */
! 2365: int n_ctxt;
! 2366:
! 2367: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
! 2368: mem_base = xmlMemBlocks();
! 2369: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
! 2370:
! 2371: ret_val = htmlParseDocument(ctxt);
! 2372: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
! 2373: desret_int(ret_val);
! 2374: call_tests++;
! 2375: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 2376: xmlResetLastError();
! 2377: if (mem_base != xmlMemBlocks()) {
! 2378: printf("Leak of %d blocks found in htmlParseDocument",
! 2379: xmlMemBlocks() - mem_base);
! 2380: test_ret++;
! 2381: printf(" %d", n_ctxt);
! 2382: printf("\n");
! 2383: }
! 2384: }
! 2385: function_tests++;
! 2386: #endif
! 2387:
! 2388: return(test_ret);
! 2389: }
! 2390:
! 2391:
! 2392: static int
! 2393: test_htmlParseElement(void) {
! 2394: int test_ret = 0;
! 2395:
! 2396: #if defined(LIBXML_HTML_ENABLED)
! 2397: int mem_base;
! 2398: htmlParserCtxtPtr ctxt; /* an HTML parser context */
! 2399: int n_ctxt;
! 2400:
! 2401: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
! 2402: mem_base = xmlMemBlocks();
! 2403: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
! 2404:
! 2405: htmlParseElement(ctxt);
! 2406: call_tests++;
! 2407: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 2408: xmlResetLastError();
! 2409: if (mem_base != xmlMemBlocks()) {
! 2410: printf("Leak of %d blocks found in htmlParseElement",
! 2411: xmlMemBlocks() - mem_base);
! 2412: test_ret++;
! 2413: printf(" %d", n_ctxt);
! 2414: printf("\n");
! 2415: }
! 2416: }
! 2417: function_tests++;
! 2418: #endif
! 2419:
! 2420: return(test_ret);
! 2421: }
! 2422:
! 2423:
! 2424: static int
! 2425: test_htmlParseEntityRef(void) {
! 2426: int test_ret = 0;
! 2427:
! 2428: #if defined(LIBXML_HTML_ENABLED)
! 2429: int mem_base;
! 2430: const htmlEntityDesc * ret_val;
! 2431: htmlParserCtxtPtr ctxt; /* an HTML parser context */
! 2432: int n_ctxt;
! 2433: xmlChar ** str; /* location to store the entity name */
! 2434: int n_str;
! 2435:
! 2436: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
! 2437: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr_ptr;n_str++) {
! 2438: mem_base = xmlMemBlocks();
! 2439: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
! 2440: str = gen_const_xmlChar_ptr_ptr(n_str, 1);
! 2441:
! 2442: ret_val = htmlParseEntityRef(ctxt, (const xmlChar **)str);
! 2443: desret_const_htmlEntityDesc_ptr(ret_val);
! 2444: call_tests++;
! 2445: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 2446: des_const_xmlChar_ptr_ptr(n_str, (const xmlChar **)str, 1);
! 2447: xmlResetLastError();
! 2448: if (mem_base != xmlMemBlocks()) {
! 2449: printf("Leak of %d blocks found in htmlParseEntityRef",
! 2450: xmlMemBlocks() - mem_base);
! 2451: test_ret++;
! 2452: printf(" %d", n_ctxt);
! 2453: printf(" %d", n_str);
! 2454: printf("\n");
! 2455: }
! 2456: }
! 2457: }
! 2458: function_tests++;
! 2459: #endif
! 2460:
! 2461: return(test_ret);
! 2462: }
! 2463:
! 2464:
! 2465: static int
! 2466: test_htmlParseFile(void) {
! 2467: int test_ret = 0;
! 2468:
! 2469: #if defined(LIBXML_HTML_ENABLED)
! 2470: htmlDocPtr ret_val;
! 2471: const char * filename; /* the filename */
! 2472: int n_filename;
! 2473: char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
! 2474: int n_encoding;
! 2475:
! 2476: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 2477: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 2478: filename = gen_filepath(n_filename, 0);
! 2479: encoding = gen_const_char_ptr(n_encoding, 1);
! 2480:
! 2481: ret_val = htmlParseFile(filename, (const char *)encoding);
! 2482: desret_htmlDocPtr(ret_val);
! 2483: call_tests++;
! 2484: des_filepath(n_filename, filename, 0);
! 2485: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
! 2486: xmlResetLastError();
! 2487: }
! 2488: }
! 2489: function_tests++;
! 2490: #endif
! 2491:
! 2492: return(test_ret);
! 2493: }
! 2494:
! 2495:
! 2496: static int
! 2497: test_htmlReadDoc(void) {
! 2498: int test_ret = 0;
! 2499:
! 2500: #if defined(LIBXML_HTML_ENABLED)
! 2501: int mem_base;
! 2502: htmlDocPtr ret_val;
! 2503: xmlChar * cur; /* a pointer to a zero terminated string */
! 2504: int n_cur;
! 2505: const char * URL; /* the base URL to use for the document */
! 2506: int n_URL;
! 2507: char * encoding; /* the document encoding, or NULL */
! 2508: int n_encoding;
! 2509: int options; /* a combination of htmlParserOption(s) */
! 2510: int n_options;
! 2511:
! 2512: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
! 2513: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 2514: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 2515: for (n_options = 0;n_options < gen_nb_int;n_options++) {
! 2516: mem_base = xmlMemBlocks();
! 2517: cur = gen_const_xmlChar_ptr(n_cur, 0);
! 2518: URL = gen_filepath(n_URL, 1);
! 2519: encoding = gen_const_char_ptr(n_encoding, 2);
! 2520: options = gen_int(n_options, 3);
! 2521:
! 2522: ret_val = htmlReadDoc((const xmlChar *)cur, URL, (const char *)encoding, options);
! 2523: desret_htmlDocPtr(ret_val);
! 2524: call_tests++;
! 2525: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
! 2526: des_filepath(n_URL, URL, 1);
! 2527: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
! 2528: des_int(n_options, options, 3);
! 2529: xmlResetLastError();
! 2530: if (mem_base != xmlMemBlocks()) {
! 2531: printf("Leak of %d blocks found in htmlReadDoc",
! 2532: xmlMemBlocks() - mem_base);
! 2533: test_ret++;
! 2534: printf(" %d", n_cur);
! 2535: printf(" %d", n_URL);
! 2536: printf(" %d", n_encoding);
! 2537: printf(" %d", n_options);
! 2538: printf("\n");
! 2539: }
! 2540: }
! 2541: }
! 2542: }
! 2543: }
! 2544: function_tests++;
! 2545: #endif
! 2546:
! 2547: return(test_ret);
! 2548: }
! 2549:
! 2550:
! 2551: static int
! 2552: test_htmlReadFile(void) {
! 2553: int test_ret = 0;
! 2554:
! 2555: #if defined(LIBXML_HTML_ENABLED)
! 2556: int mem_base;
! 2557: htmlDocPtr ret_val;
! 2558: const char * filename; /* a file or URL */
! 2559: int n_filename;
! 2560: char * encoding; /* the document encoding, or NULL */
! 2561: int n_encoding;
! 2562: int options; /* a combination of htmlParserOption(s) */
! 2563: int n_options;
! 2564:
! 2565: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 2566: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 2567: for (n_options = 0;n_options < gen_nb_int;n_options++) {
! 2568: mem_base = xmlMemBlocks();
! 2569: filename = gen_filepath(n_filename, 0);
! 2570: encoding = gen_const_char_ptr(n_encoding, 1);
! 2571: options = gen_int(n_options, 2);
! 2572:
! 2573: ret_val = htmlReadFile(filename, (const char *)encoding, options);
! 2574: desret_htmlDocPtr(ret_val);
! 2575: call_tests++;
! 2576: des_filepath(n_filename, filename, 0);
! 2577: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
! 2578: des_int(n_options, options, 2);
! 2579: xmlResetLastError();
! 2580: if (mem_base != xmlMemBlocks()) {
! 2581: printf("Leak of %d blocks found in htmlReadFile",
! 2582: xmlMemBlocks() - mem_base);
! 2583: test_ret++;
! 2584: printf(" %d", n_filename);
! 2585: printf(" %d", n_encoding);
! 2586: printf(" %d", n_options);
! 2587: printf("\n");
! 2588: }
! 2589: }
! 2590: }
! 2591: }
! 2592: function_tests++;
! 2593: #endif
! 2594:
! 2595: return(test_ret);
! 2596: }
! 2597:
! 2598:
! 2599: static int
! 2600: test_htmlReadMemory(void) {
! 2601: int test_ret = 0;
! 2602:
! 2603: #if defined(LIBXML_HTML_ENABLED)
! 2604: int mem_base;
! 2605: htmlDocPtr ret_val;
! 2606: char * buffer; /* a pointer to a char array */
! 2607: int n_buffer;
! 2608: int size; /* the size of the array */
! 2609: int n_size;
! 2610: const char * URL; /* the base URL to use for the document */
! 2611: int n_URL;
! 2612: char * encoding; /* the document encoding, or NULL */
! 2613: int n_encoding;
! 2614: int options; /* a combination of htmlParserOption(s) */
! 2615: int n_options;
! 2616:
! 2617: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
! 2618: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 2619: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 2620: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 2621: for (n_options = 0;n_options < gen_nb_int;n_options++) {
! 2622: mem_base = xmlMemBlocks();
! 2623: buffer = gen_const_char_ptr(n_buffer, 0);
! 2624: size = gen_int(n_size, 1);
! 2625: URL = gen_filepath(n_URL, 2);
! 2626: encoding = gen_const_char_ptr(n_encoding, 3);
! 2627: options = gen_int(n_options, 4);
! 2628:
! 2629: ret_val = htmlReadMemory((const char *)buffer, size, URL, (const char *)encoding, options);
! 2630: desret_htmlDocPtr(ret_val);
! 2631: call_tests++;
! 2632: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
! 2633: des_int(n_size, size, 1);
! 2634: des_filepath(n_URL, URL, 2);
! 2635: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
! 2636: des_int(n_options, options, 4);
! 2637: xmlResetLastError();
! 2638: if (mem_base != xmlMemBlocks()) {
! 2639: printf("Leak of %d blocks found in htmlReadMemory",
! 2640: xmlMemBlocks() - mem_base);
! 2641: test_ret++;
! 2642: printf(" %d", n_buffer);
! 2643: printf(" %d", n_size);
! 2644: printf(" %d", n_URL);
! 2645: printf(" %d", n_encoding);
! 2646: printf(" %d", n_options);
! 2647: printf("\n");
! 2648: }
! 2649: }
! 2650: }
! 2651: }
! 2652: }
! 2653: }
! 2654: function_tests++;
! 2655: #endif
! 2656:
! 2657: return(test_ret);
! 2658: }
! 2659:
! 2660:
! 2661: static int
! 2662: test_htmlSAXParseDoc(void) {
! 2663: int test_ret = 0;
! 2664:
! 2665: #if defined(LIBXML_HTML_ENABLED)
! 2666: int mem_base;
! 2667: htmlDocPtr ret_val;
! 2668: xmlChar * cur; /* a pointer to an array of xmlChar */
! 2669: int n_cur;
! 2670: char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
! 2671: int n_encoding;
! 2672: htmlSAXHandlerPtr sax; /* the SAX handler block */
! 2673: int n_sax;
! 2674: void * userData; /* if using SAX, this pointer will be provided on callbacks. */
! 2675: int n_userData;
! 2676:
! 2677: for (n_cur = 0;n_cur < gen_nb_xmlChar_ptr;n_cur++) {
! 2678: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 2679: for (n_sax = 0;n_sax < gen_nb_htmlSAXHandlerPtr;n_sax++) {
! 2680: for (n_userData = 0;n_userData < gen_nb_userdata;n_userData++) {
! 2681: mem_base = xmlMemBlocks();
! 2682: cur = gen_xmlChar_ptr(n_cur, 0);
! 2683: encoding = gen_const_char_ptr(n_encoding, 1);
! 2684: sax = gen_htmlSAXHandlerPtr(n_sax, 2);
! 2685: userData = gen_userdata(n_userData, 3);
! 2686:
! 2687: ret_val = htmlSAXParseDoc(cur, (const char *)encoding, sax, userData);
! 2688: desret_htmlDocPtr(ret_val);
! 2689: call_tests++;
! 2690: des_xmlChar_ptr(n_cur, cur, 0);
! 2691: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
! 2692: des_htmlSAXHandlerPtr(n_sax, sax, 2);
! 2693: des_userdata(n_userData, userData, 3);
! 2694: xmlResetLastError();
! 2695: if (mem_base != xmlMemBlocks()) {
! 2696: printf("Leak of %d blocks found in htmlSAXParseDoc",
! 2697: xmlMemBlocks() - mem_base);
! 2698: test_ret++;
! 2699: printf(" %d", n_cur);
! 2700: printf(" %d", n_encoding);
! 2701: printf(" %d", n_sax);
! 2702: printf(" %d", n_userData);
! 2703: printf("\n");
! 2704: }
! 2705: }
! 2706: }
! 2707: }
! 2708: }
! 2709: function_tests++;
! 2710: #endif
! 2711:
! 2712: return(test_ret);
! 2713: }
! 2714:
! 2715:
! 2716: static int
! 2717: test_htmlSAXParseFile(void) {
! 2718: int test_ret = 0;
! 2719:
! 2720: #if defined(LIBXML_HTML_ENABLED)
! 2721: int mem_base;
! 2722: htmlDocPtr ret_val;
! 2723: const char * filename; /* the filename */
! 2724: int n_filename;
! 2725: char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
! 2726: int n_encoding;
! 2727: htmlSAXHandlerPtr sax; /* the SAX handler block */
! 2728: int n_sax;
! 2729: void * userData; /* if using SAX, this pointer will be provided on callbacks. */
! 2730: int n_userData;
! 2731:
! 2732: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 2733: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 2734: for (n_sax = 0;n_sax < gen_nb_htmlSAXHandlerPtr;n_sax++) {
! 2735: for (n_userData = 0;n_userData < gen_nb_userdata;n_userData++) {
! 2736: mem_base = xmlMemBlocks();
! 2737: filename = gen_filepath(n_filename, 0);
! 2738: encoding = gen_const_char_ptr(n_encoding, 1);
! 2739: sax = gen_htmlSAXHandlerPtr(n_sax, 2);
! 2740: userData = gen_userdata(n_userData, 3);
! 2741:
! 2742: ret_val = htmlSAXParseFile(filename, (const char *)encoding, sax, userData);
! 2743: desret_htmlDocPtr(ret_val);
! 2744: call_tests++;
! 2745: des_filepath(n_filename, filename, 0);
! 2746: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
! 2747: des_htmlSAXHandlerPtr(n_sax, sax, 2);
! 2748: des_userdata(n_userData, userData, 3);
! 2749: xmlResetLastError();
! 2750: if (mem_base != xmlMemBlocks()) {
! 2751: printf("Leak of %d blocks found in htmlSAXParseFile",
! 2752: xmlMemBlocks() - mem_base);
! 2753: test_ret++;
! 2754: printf(" %d", n_filename);
! 2755: printf(" %d", n_encoding);
! 2756: printf(" %d", n_sax);
! 2757: printf(" %d", n_userData);
! 2758: printf("\n");
! 2759: }
! 2760: }
! 2761: }
! 2762: }
! 2763: }
! 2764: function_tests++;
! 2765: #endif
! 2766:
! 2767: return(test_ret);
! 2768: }
! 2769:
! 2770:
! 2771: static int
! 2772: test_htmlTagLookup(void) {
! 2773: int test_ret = 0;
! 2774:
! 2775:
! 2776: /* missing type support */
! 2777: return(test_ret);
! 2778: }
! 2779:
! 2780: static int
! 2781: test_HTMLparser(void) {
! 2782: int test_ret = 0;
! 2783:
! 2784: if (quiet == 0) printf("Testing HTMLparser : 32 of 38 functions ...\n");
! 2785: test_ret += test_UTF8ToHtml();
! 2786: test_ret += test_htmlAttrAllowed();
! 2787: test_ret += test_htmlAutoCloseTag();
! 2788: test_ret += test_htmlCreateMemoryParserCtxt();
! 2789: test_ret += test_htmlCreatePushParserCtxt();
! 2790: test_ret += test_htmlCtxtReadDoc();
! 2791: test_ret += test_htmlCtxtReadFile();
! 2792: test_ret += test_htmlCtxtReadMemory();
! 2793: test_ret += test_htmlCtxtReset();
! 2794: test_ret += test_htmlCtxtUseOptions();
! 2795: test_ret += test_htmlElementAllowedHere();
! 2796: test_ret += test_htmlElementStatusHere();
! 2797: test_ret += test_htmlEncodeEntities();
! 2798: test_ret += test_htmlEntityLookup();
! 2799: test_ret += test_htmlEntityValueLookup();
! 2800: test_ret += test_htmlHandleOmittedElem();
! 2801: test_ret += test_htmlIsAutoClosed();
! 2802: test_ret += test_htmlIsScriptAttribute();
! 2803: test_ret += test_htmlNewParserCtxt();
! 2804: test_ret += test_htmlNodeStatus();
! 2805: test_ret += test_htmlParseCharRef();
! 2806: test_ret += test_htmlParseChunk();
! 2807: test_ret += test_htmlParseDoc();
! 2808: test_ret += test_htmlParseDocument();
! 2809: test_ret += test_htmlParseElement();
! 2810: test_ret += test_htmlParseEntityRef();
! 2811: test_ret += test_htmlParseFile();
! 2812: test_ret += test_htmlReadDoc();
! 2813: test_ret += test_htmlReadFile();
! 2814: test_ret += test_htmlReadMemory();
! 2815: test_ret += test_htmlSAXParseDoc();
! 2816: test_ret += test_htmlSAXParseFile();
! 2817: test_ret += test_htmlTagLookup();
! 2818:
! 2819: if (test_ret != 0)
! 2820: printf("Module HTMLparser: %d errors\n", test_ret);
! 2821: return(test_ret);
! 2822: }
! 2823:
! 2824: static int
! 2825: test_htmlDocContentDumpFormatOutput(void) {
! 2826: int test_ret = 0;
! 2827:
! 2828: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 2829: int mem_base;
! 2830: xmlOutputBufferPtr buf; /* the HTML buffer output */
! 2831: int n_buf;
! 2832: xmlDocPtr cur; /* the document */
! 2833: int n_cur;
! 2834: char * encoding; /* the encoding string */
! 2835: int n_encoding;
! 2836: int format; /* should formatting spaces been added */
! 2837: int n_format;
! 2838:
! 2839: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
! 2840: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
! 2841: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 2842: for (n_format = 0;n_format < gen_nb_int;n_format++) {
! 2843: mem_base = xmlMemBlocks();
! 2844: buf = gen_xmlOutputBufferPtr(n_buf, 0);
! 2845: cur = gen_xmlDocPtr(n_cur, 1);
! 2846: encoding = gen_const_char_ptr(n_encoding, 2);
! 2847: format = gen_int(n_format, 3);
! 2848:
! 2849: htmlDocContentDumpFormatOutput(buf, cur, (const char *)encoding, format);
! 2850: call_tests++;
! 2851: des_xmlOutputBufferPtr(n_buf, buf, 0);
! 2852: des_xmlDocPtr(n_cur, cur, 1);
! 2853: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
! 2854: des_int(n_format, format, 3);
! 2855: xmlResetLastError();
! 2856: if (mem_base != xmlMemBlocks()) {
! 2857: printf("Leak of %d blocks found in htmlDocContentDumpFormatOutput",
! 2858: xmlMemBlocks() - mem_base);
! 2859: test_ret++;
! 2860: printf(" %d", n_buf);
! 2861: printf(" %d", n_cur);
! 2862: printf(" %d", n_encoding);
! 2863: printf(" %d", n_format);
! 2864: printf("\n");
! 2865: }
! 2866: }
! 2867: }
! 2868: }
! 2869: }
! 2870: function_tests++;
! 2871: #endif
! 2872:
! 2873: return(test_ret);
! 2874: }
! 2875:
! 2876:
! 2877: static int
! 2878: test_htmlDocContentDumpOutput(void) {
! 2879: int test_ret = 0;
! 2880:
! 2881: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 2882: int mem_base;
! 2883: xmlOutputBufferPtr buf; /* the HTML buffer output */
! 2884: int n_buf;
! 2885: xmlDocPtr cur; /* the document */
! 2886: int n_cur;
! 2887: char * encoding; /* the encoding string */
! 2888: int n_encoding;
! 2889:
! 2890: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
! 2891: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
! 2892: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 2893: mem_base = xmlMemBlocks();
! 2894: buf = gen_xmlOutputBufferPtr(n_buf, 0);
! 2895: cur = gen_xmlDocPtr(n_cur, 1);
! 2896: encoding = gen_const_char_ptr(n_encoding, 2);
! 2897:
! 2898: htmlDocContentDumpOutput(buf, cur, (const char *)encoding);
! 2899: call_tests++;
! 2900: des_xmlOutputBufferPtr(n_buf, buf, 0);
! 2901: des_xmlDocPtr(n_cur, cur, 1);
! 2902: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
! 2903: xmlResetLastError();
! 2904: if (mem_base != xmlMemBlocks()) {
! 2905: printf("Leak of %d blocks found in htmlDocContentDumpOutput",
! 2906: xmlMemBlocks() - mem_base);
! 2907: test_ret++;
! 2908: printf(" %d", n_buf);
! 2909: printf(" %d", n_cur);
! 2910: printf(" %d", n_encoding);
! 2911: printf("\n");
! 2912: }
! 2913: }
! 2914: }
! 2915: }
! 2916: function_tests++;
! 2917: #endif
! 2918:
! 2919: return(test_ret);
! 2920: }
! 2921:
! 2922:
! 2923: static int
! 2924: test_htmlDocDump(void) {
! 2925: int test_ret = 0;
! 2926:
! 2927: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 2928: int mem_base;
! 2929: int ret_val;
! 2930: FILE * f; /* the FILE* */
! 2931: int n_f;
! 2932: xmlDocPtr cur; /* the document */
! 2933: int n_cur;
! 2934:
! 2935: for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
! 2936: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
! 2937: mem_base = xmlMemBlocks();
! 2938: f = gen_FILE_ptr(n_f, 0);
! 2939: cur = gen_xmlDocPtr(n_cur, 1);
! 2940:
! 2941: ret_val = htmlDocDump(f, cur);
! 2942: desret_int(ret_val);
! 2943: call_tests++;
! 2944: des_FILE_ptr(n_f, f, 0);
! 2945: des_xmlDocPtr(n_cur, cur, 1);
! 2946: xmlResetLastError();
! 2947: if (mem_base != xmlMemBlocks()) {
! 2948: printf("Leak of %d blocks found in htmlDocDump",
! 2949: xmlMemBlocks() - mem_base);
! 2950: test_ret++;
! 2951: printf(" %d", n_f);
! 2952: printf(" %d", n_cur);
! 2953: printf("\n");
! 2954: }
! 2955: }
! 2956: }
! 2957: function_tests++;
! 2958: #endif
! 2959:
! 2960: return(test_ret);
! 2961: }
! 2962:
! 2963:
! 2964: #define gen_nb_xmlChar_ptr_ptr 1
! 2965: static xmlChar ** gen_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 2966: return(NULL);
! 2967: }
! 2968: static void des_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, xmlChar ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 2969: }
! 2970:
! 2971: static int
! 2972: test_htmlDocDumpMemory(void) {
! 2973: int test_ret = 0;
! 2974:
! 2975: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 2976: int mem_base;
! 2977: xmlDocPtr cur; /* the document */
! 2978: int n_cur;
! 2979: xmlChar ** mem; /* OUT: the memory pointer */
! 2980: int n_mem;
! 2981: int * size; /* OUT: the memory length */
! 2982: int n_size;
! 2983:
! 2984: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
! 2985: for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
! 2986: for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
! 2987: mem_base = xmlMemBlocks();
! 2988: cur = gen_xmlDocPtr(n_cur, 0);
! 2989: mem = gen_xmlChar_ptr_ptr(n_mem, 1);
! 2990: size = gen_int_ptr(n_size, 2);
! 2991:
! 2992: htmlDocDumpMemory(cur, mem, size);
! 2993: call_tests++;
! 2994: des_xmlDocPtr(n_cur, cur, 0);
! 2995: des_xmlChar_ptr_ptr(n_mem, mem, 1);
! 2996: des_int_ptr(n_size, size, 2);
! 2997: xmlResetLastError();
! 2998: if (mem_base != xmlMemBlocks()) {
! 2999: printf("Leak of %d blocks found in htmlDocDumpMemory",
! 3000: xmlMemBlocks() - mem_base);
! 3001: test_ret++;
! 3002: printf(" %d", n_cur);
! 3003: printf(" %d", n_mem);
! 3004: printf(" %d", n_size);
! 3005: printf("\n");
! 3006: }
! 3007: }
! 3008: }
! 3009: }
! 3010: function_tests++;
! 3011: #endif
! 3012:
! 3013: return(test_ret);
! 3014: }
! 3015:
! 3016:
! 3017: static int
! 3018: test_htmlDocDumpMemoryFormat(void) {
! 3019: int test_ret = 0;
! 3020:
! 3021: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 3022: int mem_base;
! 3023: xmlDocPtr cur; /* the document */
! 3024: int n_cur;
! 3025: xmlChar ** mem; /* OUT: the memory pointer */
! 3026: int n_mem;
! 3027: int * size; /* OUT: the memory length */
! 3028: int n_size;
! 3029: int format; /* should formatting spaces been added */
! 3030: int n_format;
! 3031:
! 3032: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
! 3033: for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
! 3034: for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
! 3035: for (n_format = 0;n_format < gen_nb_int;n_format++) {
! 3036: mem_base = xmlMemBlocks();
! 3037: cur = gen_xmlDocPtr(n_cur, 0);
! 3038: mem = gen_xmlChar_ptr_ptr(n_mem, 1);
! 3039: size = gen_int_ptr(n_size, 2);
! 3040: format = gen_int(n_format, 3);
! 3041:
! 3042: htmlDocDumpMemoryFormat(cur, mem, size, format);
! 3043: call_tests++;
! 3044: des_xmlDocPtr(n_cur, cur, 0);
! 3045: des_xmlChar_ptr_ptr(n_mem, mem, 1);
! 3046: des_int_ptr(n_size, size, 2);
! 3047: des_int(n_format, format, 3);
! 3048: xmlResetLastError();
! 3049: if (mem_base != xmlMemBlocks()) {
! 3050: printf("Leak of %d blocks found in htmlDocDumpMemoryFormat",
! 3051: xmlMemBlocks() - mem_base);
! 3052: test_ret++;
! 3053: printf(" %d", n_cur);
! 3054: printf(" %d", n_mem);
! 3055: printf(" %d", n_size);
! 3056: printf(" %d", n_format);
! 3057: printf("\n");
! 3058: }
! 3059: }
! 3060: }
! 3061: }
! 3062: }
! 3063: function_tests++;
! 3064: #endif
! 3065:
! 3066: return(test_ret);
! 3067: }
! 3068:
! 3069:
! 3070: static int
! 3071: test_htmlGetMetaEncoding(void) {
! 3072: int test_ret = 0;
! 3073:
! 3074: #if defined(LIBXML_HTML_ENABLED)
! 3075: int mem_base;
! 3076: const xmlChar * ret_val;
! 3077: htmlDocPtr doc; /* the document */
! 3078: int n_doc;
! 3079:
! 3080: for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) {
! 3081: mem_base = xmlMemBlocks();
! 3082: doc = gen_htmlDocPtr(n_doc, 0);
! 3083:
! 3084: ret_val = htmlGetMetaEncoding(doc);
! 3085: desret_const_xmlChar_ptr(ret_val);
! 3086: call_tests++;
! 3087: des_htmlDocPtr(n_doc, doc, 0);
! 3088: xmlResetLastError();
! 3089: if (mem_base != xmlMemBlocks()) {
! 3090: printf("Leak of %d blocks found in htmlGetMetaEncoding",
! 3091: xmlMemBlocks() - mem_base);
! 3092: test_ret++;
! 3093: printf(" %d", n_doc);
! 3094: printf("\n");
! 3095: }
! 3096: }
! 3097: function_tests++;
! 3098: #endif
! 3099:
! 3100: return(test_ret);
! 3101: }
! 3102:
! 3103:
! 3104: static int
! 3105: test_htmlIsBooleanAttr(void) {
! 3106: int test_ret = 0;
! 3107:
! 3108: #if defined(LIBXML_HTML_ENABLED)
! 3109: int mem_base;
! 3110: int ret_val;
! 3111: xmlChar * name; /* the name of the attribute to check */
! 3112: int n_name;
! 3113:
! 3114: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 3115: mem_base = xmlMemBlocks();
! 3116: name = gen_const_xmlChar_ptr(n_name, 0);
! 3117:
! 3118: ret_val = htmlIsBooleanAttr((const xmlChar *)name);
! 3119: desret_int(ret_val);
! 3120: call_tests++;
! 3121: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
! 3122: xmlResetLastError();
! 3123: if (mem_base != xmlMemBlocks()) {
! 3124: printf("Leak of %d blocks found in htmlIsBooleanAttr",
! 3125: xmlMemBlocks() - mem_base);
! 3126: test_ret++;
! 3127: printf(" %d", n_name);
! 3128: printf("\n");
! 3129: }
! 3130: }
! 3131: function_tests++;
! 3132: #endif
! 3133:
! 3134: return(test_ret);
! 3135: }
! 3136:
! 3137:
! 3138: static int
! 3139: test_htmlNewDoc(void) {
! 3140: int test_ret = 0;
! 3141:
! 3142: #if defined(LIBXML_HTML_ENABLED)
! 3143: int mem_base;
! 3144: htmlDocPtr ret_val;
! 3145: xmlChar * URI; /* URI for the dtd, or NULL */
! 3146: int n_URI;
! 3147: xmlChar * ExternalID; /* the external ID of the DTD, or NULL */
! 3148: int n_ExternalID;
! 3149:
! 3150: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
! 3151: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
! 3152: mem_base = xmlMemBlocks();
! 3153: URI = gen_const_xmlChar_ptr(n_URI, 0);
! 3154: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 1);
! 3155:
! 3156: ret_val = htmlNewDoc((const xmlChar *)URI, (const xmlChar *)ExternalID);
! 3157: desret_htmlDocPtr(ret_val);
! 3158: call_tests++;
! 3159: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
! 3160: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 1);
! 3161: xmlResetLastError();
! 3162: if (mem_base != xmlMemBlocks()) {
! 3163: printf("Leak of %d blocks found in htmlNewDoc",
! 3164: xmlMemBlocks() - mem_base);
! 3165: test_ret++;
! 3166: printf(" %d", n_URI);
! 3167: printf(" %d", n_ExternalID);
! 3168: printf("\n");
! 3169: }
! 3170: }
! 3171: }
! 3172: function_tests++;
! 3173: #endif
! 3174:
! 3175: return(test_ret);
! 3176: }
! 3177:
! 3178:
! 3179: static int
! 3180: test_htmlNewDocNoDtD(void) {
! 3181: int test_ret = 0;
! 3182:
! 3183: #if defined(LIBXML_HTML_ENABLED)
! 3184: int mem_base;
! 3185: htmlDocPtr ret_val;
! 3186: xmlChar * URI; /* URI for the dtd, or NULL */
! 3187: int n_URI;
! 3188: xmlChar * ExternalID; /* the external ID of the DTD, or NULL */
! 3189: int n_ExternalID;
! 3190:
! 3191: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
! 3192: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
! 3193: mem_base = xmlMemBlocks();
! 3194: URI = gen_const_xmlChar_ptr(n_URI, 0);
! 3195: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 1);
! 3196:
! 3197: ret_val = htmlNewDocNoDtD((const xmlChar *)URI, (const xmlChar *)ExternalID);
! 3198: desret_htmlDocPtr(ret_val);
! 3199: call_tests++;
! 3200: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
! 3201: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 1);
! 3202: xmlResetLastError();
! 3203: if (mem_base != xmlMemBlocks()) {
! 3204: printf("Leak of %d blocks found in htmlNewDocNoDtD",
! 3205: xmlMemBlocks() - mem_base);
! 3206: test_ret++;
! 3207: printf(" %d", n_URI);
! 3208: printf(" %d", n_ExternalID);
! 3209: printf("\n");
! 3210: }
! 3211: }
! 3212: }
! 3213: function_tests++;
! 3214: #endif
! 3215:
! 3216: return(test_ret);
! 3217: }
! 3218:
! 3219:
! 3220: static int
! 3221: test_htmlNodeDump(void) {
! 3222: int test_ret = 0;
! 3223:
! 3224: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 3225: int mem_base;
! 3226: int ret_val;
! 3227: xmlBufferPtr buf; /* the HTML buffer output */
! 3228: int n_buf;
! 3229: xmlDocPtr doc; /* the document */
! 3230: int n_doc;
! 3231: xmlNodePtr cur; /* the current node */
! 3232: int n_cur;
! 3233:
! 3234: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 3235: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 3236: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 3237: mem_base = xmlMemBlocks();
! 3238: buf = gen_xmlBufferPtr(n_buf, 0);
! 3239: doc = gen_xmlDocPtr(n_doc, 1);
! 3240: cur = gen_xmlNodePtr(n_cur, 2);
! 3241:
! 3242: ret_val = htmlNodeDump(buf, doc, cur);
! 3243: desret_int(ret_val);
! 3244: call_tests++;
! 3245: des_xmlBufferPtr(n_buf, buf, 0);
! 3246: des_xmlDocPtr(n_doc, doc, 1);
! 3247: des_xmlNodePtr(n_cur, cur, 2);
! 3248: xmlResetLastError();
! 3249: if (mem_base != xmlMemBlocks()) {
! 3250: printf("Leak of %d blocks found in htmlNodeDump",
! 3251: xmlMemBlocks() - mem_base);
! 3252: test_ret++;
! 3253: printf(" %d", n_buf);
! 3254: printf(" %d", n_doc);
! 3255: printf(" %d", n_cur);
! 3256: printf("\n");
! 3257: }
! 3258: }
! 3259: }
! 3260: }
! 3261: function_tests++;
! 3262: #endif
! 3263:
! 3264: return(test_ret);
! 3265: }
! 3266:
! 3267:
! 3268: static int
! 3269: test_htmlNodeDumpFile(void) {
! 3270: int test_ret = 0;
! 3271:
! 3272: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 3273: int mem_base;
! 3274: FILE * out; /* the FILE pointer */
! 3275: int n_out;
! 3276: xmlDocPtr doc; /* the document */
! 3277: int n_doc;
! 3278: xmlNodePtr cur; /* the current node */
! 3279: int n_cur;
! 3280:
! 3281: for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) {
! 3282: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 3283: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 3284: mem_base = xmlMemBlocks();
! 3285: out = gen_FILE_ptr(n_out, 0);
! 3286: doc = gen_xmlDocPtr(n_doc, 1);
! 3287: cur = gen_xmlNodePtr(n_cur, 2);
! 3288:
! 3289: htmlNodeDumpFile(out, doc, cur);
! 3290: call_tests++;
! 3291: des_FILE_ptr(n_out, out, 0);
! 3292: des_xmlDocPtr(n_doc, doc, 1);
! 3293: des_xmlNodePtr(n_cur, cur, 2);
! 3294: xmlResetLastError();
! 3295: if (mem_base != xmlMemBlocks()) {
! 3296: printf("Leak of %d blocks found in htmlNodeDumpFile",
! 3297: xmlMemBlocks() - mem_base);
! 3298: test_ret++;
! 3299: printf(" %d", n_out);
! 3300: printf(" %d", n_doc);
! 3301: printf(" %d", n_cur);
! 3302: printf("\n");
! 3303: }
! 3304: }
! 3305: }
! 3306: }
! 3307: function_tests++;
! 3308: #endif
! 3309:
! 3310: return(test_ret);
! 3311: }
! 3312:
! 3313:
! 3314: static int
! 3315: test_htmlNodeDumpFileFormat(void) {
! 3316: int test_ret = 0;
! 3317:
! 3318: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 3319: int mem_base;
! 3320: int ret_val;
! 3321: FILE * out; /* the FILE pointer */
! 3322: int n_out;
! 3323: xmlDocPtr doc; /* the document */
! 3324: int n_doc;
! 3325: xmlNodePtr cur; /* the current node */
! 3326: int n_cur;
! 3327: char * encoding; /* the document encoding */
! 3328: int n_encoding;
! 3329: int format; /* should formatting spaces been added */
! 3330: int n_format;
! 3331:
! 3332: for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) {
! 3333: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 3334: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 3335: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 3336: for (n_format = 0;n_format < gen_nb_int;n_format++) {
! 3337: mem_base = xmlMemBlocks();
! 3338: out = gen_FILE_ptr(n_out, 0);
! 3339: doc = gen_xmlDocPtr(n_doc, 1);
! 3340: cur = gen_xmlNodePtr(n_cur, 2);
! 3341: encoding = gen_const_char_ptr(n_encoding, 3);
! 3342: format = gen_int(n_format, 4);
! 3343:
! 3344: ret_val = htmlNodeDumpFileFormat(out, doc, cur, (const char *)encoding, format);
! 3345: desret_int(ret_val);
! 3346: call_tests++;
! 3347: des_FILE_ptr(n_out, out, 0);
! 3348: des_xmlDocPtr(n_doc, doc, 1);
! 3349: des_xmlNodePtr(n_cur, cur, 2);
! 3350: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
! 3351: des_int(n_format, format, 4);
! 3352: xmlResetLastError();
! 3353: if (mem_base != xmlMemBlocks()) {
! 3354: printf("Leak of %d blocks found in htmlNodeDumpFileFormat",
! 3355: xmlMemBlocks() - mem_base);
! 3356: test_ret++;
! 3357: printf(" %d", n_out);
! 3358: printf(" %d", n_doc);
! 3359: printf(" %d", n_cur);
! 3360: printf(" %d", n_encoding);
! 3361: printf(" %d", n_format);
! 3362: printf("\n");
! 3363: }
! 3364: }
! 3365: }
! 3366: }
! 3367: }
! 3368: }
! 3369: function_tests++;
! 3370: #endif
! 3371:
! 3372: return(test_ret);
! 3373: }
! 3374:
! 3375:
! 3376: static int
! 3377: test_htmlNodeDumpFormatOutput(void) {
! 3378: int test_ret = 0;
! 3379:
! 3380: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 3381: int mem_base;
! 3382: xmlOutputBufferPtr buf; /* the HTML buffer output */
! 3383: int n_buf;
! 3384: xmlDocPtr doc; /* the document */
! 3385: int n_doc;
! 3386: xmlNodePtr cur; /* the current node */
! 3387: int n_cur;
! 3388: char * encoding; /* the encoding string */
! 3389: int n_encoding;
! 3390: int format; /* should formatting spaces been added */
! 3391: int n_format;
! 3392:
! 3393: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
! 3394: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 3395: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 3396: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 3397: for (n_format = 0;n_format < gen_nb_int;n_format++) {
! 3398: mem_base = xmlMemBlocks();
! 3399: buf = gen_xmlOutputBufferPtr(n_buf, 0);
! 3400: doc = gen_xmlDocPtr(n_doc, 1);
! 3401: cur = gen_xmlNodePtr(n_cur, 2);
! 3402: encoding = gen_const_char_ptr(n_encoding, 3);
! 3403: format = gen_int(n_format, 4);
! 3404:
! 3405: htmlNodeDumpFormatOutput(buf, doc, cur, (const char *)encoding, format);
! 3406: call_tests++;
! 3407: des_xmlOutputBufferPtr(n_buf, buf, 0);
! 3408: des_xmlDocPtr(n_doc, doc, 1);
! 3409: des_xmlNodePtr(n_cur, cur, 2);
! 3410: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
! 3411: des_int(n_format, format, 4);
! 3412: xmlResetLastError();
! 3413: if (mem_base != xmlMemBlocks()) {
! 3414: printf("Leak of %d blocks found in htmlNodeDumpFormatOutput",
! 3415: xmlMemBlocks() - mem_base);
! 3416: test_ret++;
! 3417: printf(" %d", n_buf);
! 3418: printf(" %d", n_doc);
! 3419: printf(" %d", n_cur);
! 3420: printf(" %d", n_encoding);
! 3421: printf(" %d", n_format);
! 3422: printf("\n");
! 3423: }
! 3424: }
! 3425: }
! 3426: }
! 3427: }
! 3428: }
! 3429: function_tests++;
! 3430: #endif
! 3431:
! 3432: return(test_ret);
! 3433: }
! 3434:
! 3435:
! 3436: static int
! 3437: test_htmlNodeDumpOutput(void) {
! 3438: int test_ret = 0;
! 3439:
! 3440: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 3441: int mem_base;
! 3442: xmlOutputBufferPtr buf; /* the HTML buffer output */
! 3443: int n_buf;
! 3444: xmlDocPtr doc; /* the document */
! 3445: int n_doc;
! 3446: xmlNodePtr cur; /* the current node */
! 3447: int n_cur;
! 3448: char * encoding; /* the encoding string */
! 3449: int n_encoding;
! 3450:
! 3451: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
! 3452: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 3453: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 3454: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 3455: mem_base = xmlMemBlocks();
! 3456: buf = gen_xmlOutputBufferPtr(n_buf, 0);
! 3457: doc = gen_xmlDocPtr(n_doc, 1);
! 3458: cur = gen_xmlNodePtr(n_cur, 2);
! 3459: encoding = gen_const_char_ptr(n_encoding, 3);
! 3460:
! 3461: htmlNodeDumpOutput(buf, doc, cur, (const char *)encoding);
! 3462: call_tests++;
! 3463: des_xmlOutputBufferPtr(n_buf, buf, 0);
! 3464: des_xmlDocPtr(n_doc, doc, 1);
! 3465: des_xmlNodePtr(n_cur, cur, 2);
! 3466: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
! 3467: xmlResetLastError();
! 3468: if (mem_base != xmlMemBlocks()) {
! 3469: printf("Leak of %d blocks found in htmlNodeDumpOutput",
! 3470: xmlMemBlocks() - mem_base);
! 3471: test_ret++;
! 3472: printf(" %d", n_buf);
! 3473: printf(" %d", n_doc);
! 3474: printf(" %d", n_cur);
! 3475: printf(" %d", n_encoding);
! 3476: printf("\n");
! 3477: }
! 3478: }
! 3479: }
! 3480: }
! 3481: }
! 3482: function_tests++;
! 3483: #endif
! 3484:
! 3485: return(test_ret);
! 3486: }
! 3487:
! 3488:
! 3489: static int
! 3490: test_htmlSaveFile(void) {
! 3491: int test_ret = 0;
! 3492:
! 3493: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 3494: int mem_base;
! 3495: int ret_val;
! 3496: const char * filename; /* the filename (or URL) */
! 3497: int n_filename;
! 3498: xmlDocPtr cur; /* the document */
! 3499: int n_cur;
! 3500:
! 3501: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
! 3502: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
! 3503: mem_base = xmlMemBlocks();
! 3504: filename = gen_fileoutput(n_filename, 0);
! 3505: cur = gen_xmlDocPtr(n_cur, 1);
! 3506:
! 3507: ret_val = htmlSaveFile(filename, cur);
! 3508: desret_int(ret_val);
! 3509: call_tests++;
! 3510: des_fileoutput(n_filename, filename, 0);
! 3511: des_xmlDocPtr(n_cur, cur, 1);
! 3512: xmlResetLastError();
! 3513: if (mem_base != xmlMemBlocks()) {
! 3514: printf("Leak of %d blocks found in htmlSaveFile",
! 3515: xmlMemBlocks() - mem_base);
! 3516: test_ret++;
! 3517: printf(" %d", n_filename);
! 3518: printf(" %d", n_cur);
! 3519: printf("\n");
! 3520: }
! 3521: }
! 3522: }
! 3523: function_tests++;
! 3524: #endif
! 3525:
! 3526: return(test_ret);
! 3527: }
! 3528:
! 3529:
! 3530: static int
! 3531: test_htmlSaveFileEnc(void) {
! 3532: int test_ret = 0;
! 3533:
! 3534: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 3535: int mem_base;
! 3536: int ret_val;
! 3537: const char * filename; /* the filename */
! 3538: int n_filename;
! 3539: xmlDocPtr cur; /* the document */
! 3540: int n_cur;
! 3541: char * encoding; /* the document encoding */
! 3542: int n_encoding;
! 3543:
! 3544: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
! 3545: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
! 3546: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 3547: mem_base = xmlMemBlocks();
! 3548: filename = gen_fileoutput(n_filename, 0);
! 3549: cur = gen_xmlDocPtr(n_cur, 1);
! 3550: encoding = gen_const_char_ptr(n_encoding, 2);
! 3551:
! 3552: ret_val = htmlSaveFileEnc(filename, cur, (const char *)encoding);
! 3553: desret_int(ret_val);
! 3554: call_tests++;
! 3555: des_fileoutput(n_filename, filename, 0);
! 3556: des_xmlDocPtr(n_cur, cur, 1);
! 3557: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
! 3558: xmlResetLastError();
! 3559: if (mem_base != xmlMemBlocks()) {
! 3560: printf("Leak of %d blocks found in htmlSaveFileEnc",
! 3561: xmlMemBlocks() - mem_base);
! 3562: test_ret++;
! 3563: printf(" %d", n_filename);
! 3564: printf(" %d", n_cur);
! 3565: printf(" %d", n_encoding);
! 3566: printf("\n");
! 3567: }
! 3568: }
! 3569: }
! 3570: }
! 3571: function_tests++;
! 3572: #endif
! 3573:
! 3574: return(test_ret);
! 3575: }
! 3576:
! 3577:
! 3578: static int
! 3579: test_htmlSaveFileFormat(void) {
! 3580: int test_ret = 0;
! 3581:
! 3582: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 3583: int mem_base;
! 3584: int ret_val;
! 3585: const char * filename; /* the filename */
! 3586: int n_filename;
! 3587: xmlDocPtr cur; /* the document */
! 3588: int n_cur;
! 3589: char * encoding; /* the document encoding */
! 3590: int n_encoding;
! 3591: int format; /* should formatting spaces been added */
! 3592: int n_format;
! 3593:
! 3594: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
! 3595: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
! 3596: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 3597: for (n_format = 0;n_format < gen_nb_int;n_format++) {
! 3598: mem_base = xmlMemBlocks();
! 3599: filename = gen_fileoutput(n_filename, 0);
! 3600: cur = gen_xmlDocPtr(n_cur, 1);
! 3601: encoding = gen_const_char_ptr(n_encoding, 2);
! 3602: format = gen_int(n_format, 3);
! 3603:
! 3604: ret_val = htmlSaveFileFormat(filename, cur, (const char *)encoding, format);
! 3605: desret_int(ret_val);
! 3606: call_tests++;
! 3607: des_fileoutput(n_filename, filename, 0);
! 3608: des_xmlDocPtr(n_cur, cur, 1);
! 3609: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
! 3610: des_int(n_format, format, 3);
! 3611: xmlResetLastError();
! 3612: if (mem_base != xmlMemBlocks()) {
! 3613: printf("Leak of %d blocks found in htmlSaveFileFormat",
! 3614: xmlMemBlocks() - mem_base);
! 3615: test_ret++;
! 3616: printf(" %d", n_filename);
! 3617: printf(" %d", n_cur);
! 3618: printf(" %d", n_encoding);
! 3619: printf(" %d", n_format);
! 3620: printf("\n");
! 3621: }
! 3622: }
! 3623: }
! 3624: }
! 3625: }
! 3626: function_tests++;
! 3627: #endif
! 3628:
! 3629: return(test_ret);
! 3630: }
! 3631:
! 3632:
! 3633: static int
! 3634: test_htmlSetMetaEncoding(void) {
! 3635: int test_ret = 0;
! 3636:
! 3637: #if defined(LIBXML_HTML_ENABLED)
! 3638: int mem_base;
! 3639: int ret_val;
! 3640: htmlDocPtr doc; /* the document */
! 3641: int n_doc;
! 3642: xmlChar * encoding; /* the encoding string */
! 3643: int n_encoding;
! 3644:
! 3645: for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) {
! 3646: for (n_encoding = 0;n_encoding < gen_nb_const_xmlChar_ptr;n_encoding++) {
! 3647: mem_base = xmlMemBlocks();
! 3648: doc = gen_htmlDocPtr(n_doc, 0);
! 3649: encoding = gen_const_xmlChar_ptr(n_encoding, 1);
! 3650:
! 3651: ret_val = htmlSetMetaEncoding(doc, (const xmlChar *)encoding);
! 3652: desret_int(ret_val);
! 3653: call_tests++;
! 3654: des_htmlDocPtr(n_doc, doc, 0);
! 3655: des_const_xmlChar_ptr(n_encoding, (const xmlChar *)encoding, 1);
! 3656: xmlResetLastError();
! 3657: if (mem_base != xmlMemBlocks()) {
! 3658: printf("Leak of %d blocks found in htmlSetMetaEncoding",
! 3659: xmlMemBlocks() - mem_base);
! 3660: test_ret++;
! 3661: printf(" %d", n_doc);
! 3662: printf(" %d", n_encoding);
! 3663: printf("\n");
! 3664: }
! 3665: }
! 3666: }
! 3667: function_tests++;
! 3668: #endif
! 3669:
! 3670: return(test_ret);
! 3671: }
! 3672:
! 3673: static int
! 3674: test_HTMLtree(void) {
! 3675: int test_ret = 0;
! 3676:
! 3677: if (quiet == 0) printf("Testing HTMLtree : 18 of 18 functions ...\n");
! 3678: test_ret += test_htmlDocContentDumpFormatOutput();
! 3679: test_ret += test_htmlDocContentDumpOutput();
! 3680: test_ret += test_htmlDocDump();
! 3681: test_ret += test_htmlDocDumpMemory();
! 3682: test_ret += test_htmlDocDumpMemoryFormat();
! 3683: test_ret += test_htmlGetMetaEncoding();
! 3684: test_ret += test_htmlIsBooleanAttr();
! 3685: test_ret += test_htmlNewDoc();
! 3686: test_ret += test_htmlNewDocNoDtD();
! 3687: test_ret += test_htmlNodeDump();
! 3688: test_ret += test_htmlNodeDumpFile();
! 3689: test_ret += test_htmlNodeDumpFileFormat();
! 3690: test_ret += test_htmlNodeDumpFormatOutput();
! 3691: test_ret += test_htmlNodeDumpOutput();
! 3692: test_ret += test_htmlSaveFile();
! 3693: test_ret += test_htmlSaveFileEnc();
! 3694: test_ret += test_htmlSaveFileFormat();
! 3695: test_ret += test_htmlSetMetaEncoding();
! 3696:
! 3697: if (test_ret != 0)
! 3698: printf("Module HTMLtree: %d errors\n", test_ret);
! 3699: return(test_ret);
! 3700: }
! 3701:
! 3702: static int
! 3703: test_docbDefaultSAXHandlerInit(void) {
! 3704: int test_ret = 0;
! 3705:
! 3706: #if defined(LIBXML_DOCB_ENABLED)
! 3707: #ifdef LIBXML_DOCB_ENABLED
! 3708: int mem_base;
! 3709:
! 3710: mem_base = xmlMemBlocks();
! 3711:
! 3712: docbDefaultSAXHandlerInit();
! 3713: call_tests++;
! 3714: xmlResetLastError();
! 3715: if (mem_base != xmlMemBlocks()) {
! 3716: printf("Leak of %d blocks found in docbDefaultSAXHandlerInit",
! 3717: xmlMemBlocks() - mem_base);
! 3718: test_ret++;
! 3719: printf("\n");
! 3720: }
! 3721: function_tests++;
! 3722: #endif
! 3723: #endif
! 3724:
! 3725: return(test_ret);
! 3726: }
! 3727:
! 3728:
! 3729: static int
! 3730: test_htmlDefaultSAXHandlerInit(void) {
! 3731: int test_ret = 0;
! 3732:
! 3733: #if defined(LIBXML_HTML_ENABLED)
! 3734: #ifdef LIBXML_HTML_ENABLED
! 3735: int mem_base;
! 3736:
! 3737: mem_base = xmlMemBlocks();
! 3738:
! 3739: htmlDefaultSAXHandlerInit();
! 3740: call_tests++;
! 3741: xmlResetLastError();
! 3742: if (mem_base != xmlMemBlocks()) {
! 3743: printf("Leak of %d blocks found in htmlDefaultSAXHandlerInit",
! 3744: xmlMemBlocks() - mem_base);
! 3745: test_ret++;
! 3746: printf("\n");
! 3747: }
! 3748: function_tests++;
! 3749: #endif
! 3750: #endif
! 3751:
! 3752: return(test_ret);
! 3753: }
! 3754:
! 3755:
! 3756: static int
! 3757: test_xmlDefaultSAXHandlerInit(void) {
! 3758: int test_ret = 0;
! 3759:
! 3760: int mem_base;
! 3761:
! 3762: mem_base = xmlMemBlocks();
! 3763:
! 3764: xmlDefaultSAXHandlerInit();
! 3765: call_tests++;
! 3766: xmlResetLastError();
! 3767: if (mem_base != xmlMemBlocks()) {
! 3768: printf("Leak of %d blocks found in xmlDefaultSAXHandlerInit",
! 3769: xmlMemBlocks() - mem_base);
! 3770: test_ret++;
! 3771: printf("\n");
! 3772: }
! 3773: function_tests++;
! 3774:
! 3775: return(test_ret);
! 3776: }
! 3777:
! 3778:
! 3779: #define gen_nb_xmlEnumerationPtr 1
! 3780: static xmlEnumerationPtr gen_xmlEnumerationPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 3781: return(NULL);
! 3782: }
! 3783: static void des_xmlEnumerationPtr(int no ATTRIBUTE_UNUSED, xmlEnumerationPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 3784: }
! 3785:
! 3786: static int
! 3787: test_xmlSAX2AttributeDecl(void) {
! 3788: int test_ret = 0;
! 3789:
! 3790: int mem_base;
! 3791: void * ctx; /* the user data (XML parser context) */
! 3792: int n_ctx;
! 3793: xmlChar * elem; /* the name of the element */
! 3794: int n_elem;
! 3795: xmlChar * fullname; /* the attribute name */
! 3796: int n_fullname;
! 3797: int type; /* the attribute type */
! 3798: int n_type;
! 3799: int def; /* the type of default value */
! 3800: int n_def;
! 3801: xmlChar * defaultValue; /* the attribute default value */
! 3802: int n_defaultValue;
! 3803: xmlEnumerationPtr tree; /* the tree of enumerated value set */
! 3804: int n_tree;
! 3805:
! 3806: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 3807: for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
! 3808: for (n_fullname = 0;n_fullname < gen_nb_const_xmlChar_ptr;n_fullname++) {
! 3809: for (n_type = 0;n_type < gen_nb_int;n_type++) {
! 3810: for (n_def = 0;n_def < gen_nb_int;n_def++) {
! 3811: for (n_defaultValue = 0;n_defaultValue < gen_nb_const_xmlChar_ptr;n_defaultValue++) {
! 3812: for (n_tree = 0;n_tree < gen_nb_xmlEnumerationPtr;n_tree++) {
! 3813: mem_base = xmlMemBlocks();
! 3814: ctx = gen_void_ptr(n_ctx, 0);
! 3815: elem = gen_const_xmlChar_ptr(n_elem, 1);
! 3816: fullname = gen_const_xmlChar_ptr(n_fullname, 2);
! 3817: type = gen_int(n_type, 3);
! 3818: def = gen_int(n_def, 4);
! 3819: defaultValue = gen_const_xmlChar_ptr(n_defaultValue, 5);
! 3820: tree = gen_xmlEnumerationPtr(n_tree, 6);
! 3821:
! 3822: xmlSAX2AttributeDecl(ctx, (const xmlChar *)elem, (const xmlChar *)fullname, type, def, (const xmlChar *)defaultValue, tree);
! 3823: call_tests++;
! 3824: des_void_ptr(n_ctx, ctx, 0);
! 3825: des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 1);
! 3826: des_const_xmlChar_ptr(n_fullname, (const xmlChar *)fullname, 2);
! 3827: des_int(n_type, type, 3);
! 3828: des_int(n_def, def, 4);
! 3829: des_const_xmlChar_ptr(n_defaultValue, (const xmlChar *)defaultValue, 5);
! 3830: des_xmlEnumerationPtr(n_tree, tree, 6);
! 3831: xmlResetLastError();
! 3832: if (mem_base != xmlMemBlocks()) {
! 3833: printf("Leak of %d blocks found in xmlSAX2AttributeDecl",
! 3834: xmlMemBlocks() - mem_base);
! 3835: test_ret++;
! 3836: printf(" %d", n_ctx);
! 3837: printf(" %d", n_elem);
! 3838: printf(" %d", n_fullname);
! 3839: printf(" %d", n_type);
! 3840: printf(" %d", n_def);
! 3841: printf(" %d", n_defaultValue);
! 3842: printf(" %d", n_tree);
! 3843: printf("\n");
! 3844: }
! 3845: }
! 3846: }
! 3847: }
! 3848: }
! 3849: }
! 3850: }
! 3851: }
! 3852: function_tests++;
! 3853:
! 3854: return(test_ret);
! 3855: }
! 3856:
! 3857:
! 3858: static int
! 3859: test_xmlSAX2CDataBlock(void) {
! 3860: int test_ret = 0;
! 3861:
! 3862: int mem_base;
! 3863: void * ctx; /* the user data (XML parser context) */
! 3864: int n_ctx;
! 3865: xmlChar * value; /* The pcdata content */
! 3866: int n_value;
! 3867: int len; /* the block length */
! 3868: int n_len;
! 3869:
! 3870: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 3871: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 3872: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 3873: mem_base = xmlMemBlocks();
! 3874: ctx = gen_void_ptr(n_ctx, 0);
! 3875: value = gen_const_xmlChar_ptr(n_value, 1);
! 3876: len = gen_int(n_len, 2);
! 3877:
! 3878: xmlSAX2CDataBlock(ctx, (const xmlChar *)value, len);
! 3879: call_tests++;
! 3880: des_void_ptr(n_ctx, ctx, 0);
! 3881: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
! 3882: des_int(n_len, len, 2);
! 3883: xmlResetLastError();
! 3884: if (mem_base != xmlMemBlocks()) {
! 3885: printf("Leak of %d blocks found in xmlSAX2CDataBlock",
! 3886: xmlMemBlocks() - mem_base);
! 3887: test_ret++;
! 3888: printf(" %d", n_ctx);
! 3889: printf(" %d", n_value);
! 3890: printf(" %d", n_len);
! 3891: printf("\n");
! 3892: }
! 3893: }
! 3894: }
! 3895: }
! 3896: function_tests++;
! 3897:
! 3898: return(test_ret);
! 3899: }
! 3900:
! 3901:
! 3902: static int
! 3903: test_xmlSAX2Characters(void) {
! 3904: int test_ret = 0;
! 3905:
! 3906: int mem_base;
! 3907: void * ctx; /* the user data (XML parser context) */
! 3908: int n_ctx;
! 3909: xmlChar * ch; /* a xmlChar string */
! 3910: int n_ch;
! 3911: int len; /* the number of xmlChar */
! 3912: int n_len;
! 3913:
! 3914: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 3915: for (n_ch = 0;n_ch < gen_nb_const_xmlChar_ptr;n_ch++) {
! 3916: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 3917: mem_base = xmlMemBlocks();
! 3918: ctx = gen_void_ptr(n_ctx, 0);
! 3919: ch = gen_const_xmlChar_ptr(n_ch, 1);
! 3920: len = gen_int(n_len, 2);
! 3921:
! 3922: xmlSAX2Characters(ctx, (const xmlChar *)ch, len);
! 3923: call_tests++;
! 3924: des_void_ptr(n_ctx, ctx, 0);
! 3925: des_const_xmlChar_ptr(n_ch, (const xmlChar *)ch, 1);
! 3926: des_int(n_len, len, 2);
! 3927: xmlResetLastError();
! 3928: if (mem_base != xmlMemBlocks()) {
! 3929: printf("Leak of %d blocks found in xmlSAX2Characters",
! 3930: xmlMemBlocks() - mem_base);
! 3931: test_ret++;
! 3932: printf(" %d", n_ctx);
! 3933: printf(" %d", n_ch);
! 3934: printf(" %d", n_len);
! 3935: printf("\n");
! 3936: }
! 3937: }
! 3938: }
! 3939: }
! 3940: function_tests++;
! 3941:
! 3942: return(test_ret);
! 3943: }
! 3944:
! 3945:
! 3946: static int
! 3947: test_xmlSAX2Comment(void) {
! 3948: int test_ret = 0;
! 3949:
! 3950: int mem_base;
! 3951: void * ctx; /* the user data (XML parser context) */
! 3952: int n_ctx;
! 3953: xmlChar * value; /* the xmlSAX2Comment content */
! 3954: int n_value;
! 3955:
! 3956: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 3957: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 3958: mem_base = xmlMemBlocks();
! 3959: ctx = gen_void_ptr(n_ctx, 0);
! 3960: value = gen_const_xmlChar_ptr(n_value, 1);
! 3961:
! 3962: xmlSAX2Comment(ctx, (const xmlChar *)value);
! 3963: call_tests++;
! 3964: des_void_ptr(n_ctx, ctx, 0);
! 3965: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
! 3966: xmlResetLastError();
! 3967: if (mem_base != xmlMemBlocks()) {
! 3968: printf("Leak of %d blocks found in xmlSAX2Comment",
! 3969: xmlMemBlocks() - mem_base);
! 3970: test_ret++;
! 3971: printf(" %d", n_ctx);
! 3972: printf(" %d", n_value);
! 3973: printf("\n");
! 3974: }
! 3975: }
! 3976: }
! 3977: function_tests++;
! 3978:
! 3979: return(test_ret);
! 3980: }
! 3981:
! 3982:
! 3983: static int
! 3984: test_xmlSAX2ElementDecl(void) {
! 3985: int test_ret = 0;
! 3986:
! 3987: int mem_base;
! 3988: void * ctx; /* the user data (XML parser context) */
! 3989: int n_ctx;
! 3990: xmlChar * name; /* the element name */
! 3991: int n_name;
! 3992: int type; /* the element type */
! 3993: int n_type;
! 3994: xmlElementContentPtr content; /* the element value tree */
! 3995: int n_content;
! 3996:
! 3997: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 3998: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 3999: for (n_type = 0;n_type < gen_nb_int;n_type++) {
! 4000: for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
! 4001: mem_base = xmlMemBlocks();
! 4002: ctx = gen_void_ptr(n_ctx, 0);
! 4003: name = gen_const_xmlChar_ptr(n_name, 1);
! 4004: type = gen_int(n_type, 2);
! 4005: content = gen_xmlElementContentPtr(n_content, 3);
! 4006:
! 4007: xmlSAX2ElementDecl(ctx, (const xmlChar *)name, type, content);
! 4008: call_tests++;
! 4009: des_void_ptr(n_ctx, ctx, 0);
! 4010: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 4011: des_int(n_type, type, 2);
! 4012: des_xmlElementContentPtr(n_content, content, 3);
! 4013: xmlResetLastError();
! 4014: if (mem_base != xmlMemBlocks()) {
! 4015: printf("Leak of %d blocks found in xmlSAX2ElementDecl",
! 4016: xmlMemBlocks() - mem_base);
! 4017: test_ret++;
! 4018: printf(" %d", n_ctx);
! 4019: printf(" %d", n_name);
! 4020: printf(" %d", n_type);
! 4021: printf(" %d", n_content);
! 4022: printf("\n");
! 4023: }
! 4024: }
! 4025: }
! 4026: }
! 4027: }
! 4028: function_tests++;
! 4029:
! 4030: return(test_ret);
! 4031: }
! 4032:
! 4033:
! 4034: static int
! 4035: test_xmlSAX2EndDocument(void) {
! 4036: int test_ret = 0;
! 4037:
! 4038: int mem_base;
! 4039: void * ctx; /* the user data (XML parser context) */
! 4040: int n_ctx;
! 4041:
! 4042: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4043: mem_base = xmlMemBlocks();
! 4044: ctx = gen_void_ptr(n_ctx, 0);
! 4045:
! 4046: xmlSAX2EndDocument(ctx);
! 4047: call_tests++;
! 4048: des_void_ptr(n_ctx, ctx, 0);
! 4049: xmlResetLastError();
! 4050: if (mem_base != xmlMemBlocks()) {
! 4051: printf("Leak of %d blocks found in xmlSAX2EndDocument",
! 4052: xmlMemBlocks() - mem_base);
! 4053: test_ret++;
! 4054: printf(" %d", n_ctx);
! 4055: printf("\n");
! 4056: }
! 4057: }
! 4058: function_tests++;
! 4059:
! 4060: return(test_ret);
! 4061: }
! 4062:
! 4063:
! 4064: static int
! 4065: test_xmlSAX2EndElement(void) {
! 4066: int test_ret = 0;
! 4067:
! 4068: #if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED)
! 4069: #ifdef LIBXML_SAX1_ENABLED
! 4070: int mem_base;
! 4071: void * ctx; /* the user data (XML parser context) */
! 4072: int n_ctx;
! 4073: xmlChar * name; /* The element name */
! 4074: int n_name;
! 4075:
! 4076: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4077: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 4078: mem_base = xmlMemBlocks();
! 4079: ctx = gen_void_ptr(n_ctx, 0);
! 4080: name = gen_const_xmlChar_ptr(n_name, 1);
! 4081:
! 4082: xmlSAX2EndElement(ctx, (const xmlChar *)name);
! 4083: call_tests++;
! 4084: des_void_ptr(n_ctx, ctx, 0);
! 4085: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 4086: xmlResetLastError();
! 4087: if (mem_base != xmlMemBlocks()) {
! 4088: printf("Leak of %d blocks found in xmlSAX2EndElement",
! 4089: xmlMemBlocks() - mem_base);
! 4090: test_ret++;
! 4091: printf(" %d", n_ctx);
! 4092: printf(" %d", n_name);
! 4093: printf("\n");
! 4094: }
! 4095: }
! 4096: }
! 4097: function_tests++;
! 4098: #endif
! 4099: #endif
! 4100:
! 4101: return(test_ret);
! 4102: }
! 4103:
! 4104:
! 4105: static int
! 4106: test_xmlSAX2EndElementNs(void) {
! 4107: int test_ret = 0;
! 4108:
! 4109: int mem_base;
! 4110: void * ctx; /* the user data (XML parser context) */
! 4111: int n_ctx;
! 4112: xmlChar * localname; /* the local name of the element */
! 4113: int n_localname;
! 4114: xmlChar * prefix; /* the element namespace prefix if available */
! 4115: int n_prefix;
! 4116: xmlChar * URI; /* the element namespace name if available */
! 4117: int n_URI;
! 4118:
! 4119: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4120: for (n_localname = 0;n_localname < gen_nb_const_xmlChar_ptr;n_localname++) {
! 4121: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
! 4122: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
! 4123: mem_base = xmlMemBlocks();
! 4124: ctx = gen_void_ptr(n_ctx, 0);
! 4125: localname = gen_const_xmlChar_ptr(n_localname, 1);
! 4126: prefix = gen_const_xmlChar_ptr(n_prefix, 2);
! 4127: URI = gen_const_xmlChar_ptr(n_URI, 3);
! 4128:
! 4129: xmlSAX2EndElementNs(ctx, (const xmlChar *)localname, (const xmlChar *)prefix, (const xmlChar *)URI);
! 4130: call_tests++;
! 4131: des_void_ptr(n_ctx, ctx, 0);
! 4132: des_const_xmlChar_ptr(n_localname, (const xmlChar *)localname, 1);
! 4133: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2);
! 4134: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 3);
! 4135: xmlResetLastError();
! 4136: if (mem_base != xmlMemBlocks()) {
! 4137: printf("Leak of %d blocks found in xmlSAX2EndElementNs",
! 4138: xmlMemBlocks() - mem_base);
! 4139: test_ret++;
! 4140: printf(" %d", n_ctx);
! 4141: printf(" %d", n_localname);
! 4142: printf(" %d", n_prefix);
! 4143: printf(" %d", n_URI);
! 4144: printf("\n");
! 4145: }
! 4146: }
! 4147: }
! 4148: }
! 4149: }
! 4150: function_tests++;
! 4151:
! 4152: return(test_ret);
! 4153: }
! 4154:
! 4155:
! 4156: static int
! 4157: test_xmlSAX2EntityDecl(void) {
! 4158: int test_ret = 0;
! 4159:
! 4160: int mem_base;
! 4161: void * ctx; /* the user data (XML parser context) */
! 4162: int n_ctx;
! 4163: xmlChar * name; /* the entity name */
! 4164: int n_name;
! 4165: int type; /* the entity type */
! 4166: int n_type;
! 4167: xmlChar * publicId; /* The public ID of the entity */
! 4168: int n_publicId;
! 4169: xmlChar * systemId; /* The system ID of the entity */
! 4170: int n_systemId;
! 4171: xmlChar * content; /* the entity value (without processing). */
! 4172: int n_content;
! 4173:
! 4174: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4175: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 4176: for (n_type = 0;n_type < gen_nb_int;n_type++) {
! 4177: for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) {
! 4178: for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) {
! 4179: for (n_content = 0;n_content < gen_nb_xmlChar_ptr;n_content++) {
! 4180: mem_base = xmlMemBlocks();
! 4181: ctx = gen_void_ptr(n_ctx, 0);
! 4182: name = gen_const_xmlChar_ptr(n_name, 1);
! 4183: type = gen_int(n_type, 2);
! 4184: publicId = gen_const_xmlChar_ptr(n_publicId, 3);
! 4185: systemId = gen_const_xmlChar_ptr(n_systemId, 4);
! 4186: content = gen_xmlChar_ptr(n_content, 5);
! 4187:
! 4188: xmlSAX2EntityDecl(ctx, (const xmlChar *)name, type, (const xmlChar *)publicId, (const xmlChar *)systemId, content);
! 4189: call_tests++;
! 4190: des_void_ptr(n_ctx, ctx, 0);
! 4191: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 4192: des_int(n_type, type, 2);
! 4193: des_const_xmlChar_ptr(n_publicId, (const xmlChar *)publicId, 3);
! 4194: des_const_xmlChar_ptr(n_systemId, (const xmlChar *)systemId, 4);
! 4195: des_xmlChar_ptr(n_content, content, 5);
! 4196: xmlResetLastError();
! 4197: if (mem_base != xmlMemBlocks()) {
! 4198: printf("Leak of %d blocks found in xmlSAX2EntityDecl",
! 4199: xmlMemBlocks() - mem_base);
! 4200: test_ret++;
! 4201: printf(" %d", n_ctx);
! 4202: printf(" %d", n_name);
! 4203: printf(" %d", n_type);
! 4204: printf(" %d", n_publicId);
! 4205: printf(" %d", n_systemId);
! 4206: printf(" %d", n_content);
! 4207: printf("\n");
! 4208: }
! 4209: }
! 4210: }
! 4211: }
! 4212: }
! 4213: }
! 4214: }
! 4215: function_tests++;
! 4216:
! 4217: return(test_ret);
! 4218: }
! 4219:
! 4220:
! 4221: static int
! 4222: test_xmlSAX2ExternalSubset(void) {
! 4223: int test_ret = 0;
! 4224:
! 4225: int mem_base;
! 4226: void * ctx; /* the user data (XML parser context) */
! 4227: int n_ctx;
! 4228: xmlChar * name; /* the root element name */
! 4229: int n_name;
! 4230: xmlChar * ExternalID; /* the external ID */
! 4231: int n_ExternalID;
! 4232: xmlChar * SystemID; /* the SYSTEM ID (e.g. filename or URL) */
! 4233: int n_SystemID;
! 4234:
! 4235: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4236: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 4237: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
! 4238: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
! 4239: mem_base = xmlMemBlocks();
! 4240: ctx = gen_void_ptr(n_ctx, 0);
! 4241: name = gen_const_xmlChar_ptr(n_name, 1);
! 4242: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
! 4243: SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
! 4244:
! 4245: xmlSAX2ExternalSubset(ctx, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
! 4246: call_tests++;
! 4247: des_void_ptr(n_ctx, ctx, 0);
! 4248: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 4249: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2);
! 4250: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3);
! 4251: xmlResetLastError();
! 4252: if (mem_base != xmlMemBlocks()) {
! 4253: printf("Leak of %d blocks found in xmlSAX2ExternalSubset",
! 4254: xmlMemBlocks() - mem_base);
! 4255: test_ret++;
! 4256: printf(" %d", n_ctx);
! 4257: printf(" %d", n_name);
! 4258: printf(" %d", n_ExternalID);
! 4259: printf(" %d", n_SystemID);
! 4260: printf("\n");
! 4261: }
! 4262: }
! 4263: }
! 4264: }
! 4265: }
! 4266: function_tests++;
! 4267:
! 4268: return(test_ret);
! 4269: }
! 4270:
! 4271:
! 4272: static int
! 4273: test_xmlSAX2GetColumnNumber(void) {
! 4274: int test_ret = 0;
! 4275:
! 4276: int mem_base;
! 4277: int ret_val;
! 4278: void * ctx; /* the user data (XML parser context) */
! 4279: int n_ctx;
! 4280:
! 4281: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4282: mem_base = xmlMemBlocks();
! 4283: ctx = gen_void_ptr(n_ctx, 0);
! 4284:
! 4285: ret_val = xmlSAX2GetColumnNumber(ctx);
! 4286: desret_int(ret_val);
! 4287: call_tests++;
! 4288: des_void_ptr(n_ctx, ctx, 0);
! 4289: xmlResetLastError();
! 4290: if (mem_base != xmlMemBlocks()) {
! 4291: printf("Leak of %d blocks found in xmlSAX2GetColumnNumber",
! 4292: xmlMemBlocks() - mem_base);
! 4293: test_ret++;
! 4294: printf(" %d", n_ctx);
! 4295: printf("\n");
! 4296: }
! 4297: }
! 4298: function_tests++;
! 4299:
! 4300: return(test_ret);
! 4301: }
! 4302:
! 4303:
! 4304: static int
! 4305: test_xmlSAX2GetEntity(void) {
! 4306: int test_ret = 0;
! 4307:
! 4308: int mem_base;
! 4309: xmlEntityPtr ret_val;
! 4310: void * ctx; /* the user data (XML parser context) */
! 4311: int n_ctx;
! 4312: xmlChar * name; /* The entity name */
! 4313: int n_name;
! 4314:
! 4315: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4316: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 4317: mem_base = xmlMemBlocks();
! 4318: ctx = gen_void_ptr(n_ctx, 0);
! 4319: name = gen_const_xmlChar_ptr(n_name, 1);
! 4320:
! 4321: ret_val = xmlSAX2GetEntity(ctx, (const xmlChar *)name);
! 4322: desret_xmlEntityPtr(ret_val);
! 4323: call_tests++;
! 4324: des_void_ptr(n_ctx, ctx, 0);
! 4325: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 4326: xmlResetLastError();
! 4327: if (mem_base != xmlMemBlocks()) {
! 4328: printf("Leak of %d blocks found in xmlSAX2GetEntity",
! 4329: xmlMemBlocks() - mem_base);
! 4330: test_ret++;
! 4331: printf(" %d", n_ctx);
! 4332: printf(" %d", n_name);
! 4333: printf("\n");
! 4334: }
! 4335: }
! 4336: }
! 4337: function_tests++;
! 4338:
! 4339: return(test_ret);
! 4340: }
! 4341:
! 4342:
! 4343: static int
! 4344: test_xmlSAX2GetLineNumber(void) {
! 4345: int test_ret = 0;
! 4346:
! 4347: int mem_base;
! 4348: int ret_val;
! 4349: void * ctx; /* the user data (XML parser context) */
! 4350: int n_ctx;
! 4351:
! 4352: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4353: mem_base = xmlMemBlocks();
! 4354: ctx = gen_void_ptr(n_ctx, 0);
! 4355:
! 4356: ret_val = xmlSAX2GetLineNumber(ctx);
! 4357: desret_int(ret_val);
! 4358: call_tests++;
! 4359: des_void_ptr(n_ctx, ctx, 0);
! 4360: xmlResetLastError();
! 4361: if (mem_base != xmlMemBlocks()) {
! 4362: printf("Leak of %d blocks found in xmlSAX2GetLineNumber",
! 4363: xmlMemBlocks() - mem_base);
! 4364: test_ret++;
! 4365: printf(" %d", n_ctx);
! 4366: printf("\n");
! 4367: }
! 4368: }
! 4369: function_tests++;
! 4370:
! 4371: return(test_ret);
! 4372: }
! 4373:
! 4374:
! 4375: static int
! 4376: test_xmlSAX2GetParameterEntity(void) {
! 4377: int test_ret = 0;
! 4378:
! 4379: int mem_base;
! 4380: xmlEntityPtr ret_val;
! 4381: void * ctx; /* the user data (XML parser context) */
! 4382: int n_ctx;
! 4383: xmlChar * name; /* The entity name */
! 4384: int n_name;
! 4385:
! 4386: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4387: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 4388: mem_base = xmlMemBlocks();
! 4389: ctx = gen_void_ptr(n_ctx, 0);
! 4390: name = gen_const_xmlChar_ptr(n_name, 1);
! 4391:
! 4392: ret_val = xmlSAX2GetParameterEntity(ctx, (const xmlChar *)name);
! 4393: desret_xmlEntityPtr(ret_val);
! 4394: call_tests++;
! 4395: des_void_ptr(n_ctx, ctx, 0);
! 4396: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 4397: xmlResetLastError();
! 4398: if (mem_base != xmlMemBlocks()) {
! 4399: printf("Leak of %d blocks found in xmlSAX2GetParameterEntity",
! 4400: xmlMemBlocks() - mem_base);
! 4401: test_ret++;
! 4402: printf(" %d", n_ctx);
! 4403: printf(" %d", n_name);
! 4404: printf("\n");
! 4405: }
! 4406: }
! 4407: }
! 4408: function_tests++;
! 4409:
! 4410: return(test_ret);
! 4411: }
! 4412:
! 4413:
! 4414: static int
! 4415: test_xmlSAX2GetPublicId(void) {
! 4416: int test_ret = 0;
! 4417:
! 4418: int mem_base;
! 4419: const xmlChar * ret_val;
! 4420: void * ctx; /* the user data (XML parser context) */
! 4421: int n_ctx;
! 4422:
! 4423: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4424: mem_base = xmlMemBlocks();
! 4425: ctx = gen_void_ptr(n_ctx, 0);
! 4426:
! 4427: ret_val = xmlSAX2GetPublicId(ctx);
! 4428: desret_const_xmlChar_ptr(ret_val);
! 4429: call_tests++;
! 4430: des_void_ptr(n_ctx, ctx, 0);
! 4431: xmlResetLastError();
! 4432: if (mem_base != xmlMemBlocks()) {
! 4433: printf("Leak of %d blocks found in xmlSAX2GetPublicId",
! 4434: xmlMemBlocks() - mem_base);
! 4435: test_ret++;
! 4436: printf(" %d", n_ctx);
! 4437: printf("\n");
! 4438: }
! 4439: }
! 4440: function_tests++;
! 4441:
! 4442: return(test_ret);
! 4443: }
! 4444:
! 4445:
! 4446: static int
! 4447: test_xmlSAX2GetSystemId(void) {
! 4448: int test_ret = 0;
! 4449:
! 4450: int mem_base;
! 4451: const xmlChar * ret_val;
! 4452: void * ctx; /* the user data (XML parser context) */
! 4453: int n_ctx;
! 4454:
! 4455: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4456: mem_base = xmlMemBlocks();
! 4457: ctx = gen_void_ptr(n_ctx, 0);
! 4458:
! 4459: ret_val = xmlSAX2GetSystemId(ctx);
! 4460: desret_const_xmlChar_ptr(ret_val);
! 4461: call_tests++;
! 4462: des_void_ptr(n_ctx, ctx, 0);
! 4463: xmlResetLastError();
! 4464: if (mem_base != xmlMemBlocks()) {
! 4465: printf("Leak of %d blocks found in xmlSAX2GetSystemId",
! 4466: xmlMemBlocks() - mem_base);
! 4467: test_ret++;
! 4468: printf(" %d", n_ctx);
! 4469: printf("\n");
! 4470: }
! 4471: }
! 4472: function_tests++;
! 4473:
! 4474: return(test_ret);
! 4475: }
! 4476:
! 4477:
! 4478: static int
! 4479: test_xmlSAX2HasExternalSubset(void) {
! 4480: int test_ret = 0;
! 4481:
! 4482: int mem_base;
! 4483: int ret_val;
! 4484: void * ctx; /* the user data (XML parser context) */
! 4485: int n_ctx;
! 4486:
! 4487: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4488: mem_base = xmlMemBlocks();
! 4489: ctx = gen_void_ptr(n_ctx, 0);
! 4490:
! 4491: ret_val = xmlSAX2HasExternalSubset(ctx);
! 4492: desret_int(ret_val);
! 4493: call_tests++;
! 4494: des_void_ptr(n_ctx, ctx, 0);
! 4495: xmlResetLastError();
! 4496: if (mem_base != xmlMemBlocks()) {
! 4497: printf("Leak of %d blocks found in xmlSAX2HasExternalSubset",
! 4498: xmlMemBlocks() - mem_base);
! 4499: test_ret++;
! 4500: printf(" %d", n_ctx);
! 4501: printf("\n");
! 4502: }
! 4503: }
! 4504: function_tests++;
! 4505:
! 4506: return(test_ret);
! 4507: }
! 4508:
! 4509:
! 4510: static int
! 4511: test_xmlSAX2HasInternalSubset(void) {
! 4512: int test_ret = 0;
! 4513:
! 4514: int mem_base;
! 4515: int ret_val;
! 4516: void * ctx; /* the user data (XML parser context) */
! 4517: int n_ctx;
! 4518:
! 4519: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4520: mem_base = xmlMemBlocks();
! 4521: ctx = gen_void_ptr(n_ctx, 0);
! 4522:
! 4523: ret_val = xmlSAX2HasInternalSubset(ctx);
! 4524: desret_int(ret_val);
! 4525: call_tests++;
! 4526: des_void_ptr(n_ctx, ctx, 0);
! 4527: xmlResetLastError();
! 4528: if (mem_base != xmlMemBlocks()) {
! 4529: printf("Leak of %d blocks found in xmlSAX2HasInternalSubset",
! 4530: xmlMemBlocks() - mem_base);
! 4531: test_ret++;
! 4532: printf(" %d", n_ctx);
! 4533: printf("\n");
! 4534: }
! 4535: }
! 4536: function_tests++;
! 4537:
! 4538: return(test_ret);
! 4539: }
! 4540:
! 4541:
! 4542: static int
! 4543: test_xmlSAX2IgnorableWhitespace(void) {
! 4544: int test_ret = 0;
! 4545:
! 4546: int mem_base;
! 4547: void * ctx; /* the user data (XML parser context) */
! 4548: int n_ctx;
! 4549: xmlChar * ch; /* a xmlChar string */
! 4550: int n_ch;
! 4551: int len; /* the number of xmlChar */
! 4552: int n_len;
! 4553:
! 4554: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4555: for (n_ch = 0;n_ch < gen_nb_const_xmlChar_ptr;n_ch++) {
! 4556: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 4557: mem_base = xmlMemBlocks();
! 4558: ctx = gen_void_ptr(n_ctx, 0);
! 4559: ch = gen_const_xmlChar_ptr(n_ch, 1);
! 4560: len = gen_int(n_len, 2);
! 4561:
! 4562: xmlSAX2IgnorableWhitespace(ctx, (const xmlChar *)ch, len);
! 4563: call_tests++;
! 4564: des_void_ptr(n_ctx, ctx, 0);
! 4565: des_const_xmlChar_ptr(n_ch, (const xmlChar *)ch, 1);
! 4566: des_int(n_len, len, 2);
! 4567: xmlResetLastError();
! 4568: if (mem_base != xmlMemBlocks()) {
! 4569: printf("Leak of %d blocks found in xmlSAX2IgnorableWhitespace",
! 4570: xmlMemBlocks() - mem_base);
! 4571: test_ret++;
! 4572: printf(" %d", n_ctx);
! 4573: printf(" %d", n_ch);
! 4574: printf(" %d", n_len);
! 4575: printf("\n");
! 4576: }
! 4577: }
! 4578: }
! 4579: }
! 4580: function_tests++;
! 4581:
! 4582: return(test_ret);
! 4583: }
! 4584:
! 4585:
! 4586: #define gen_nb_xmlSAXHandler_ptr 1
! 4587: static xmlSAXHandler * gen_xmlSAXHandler_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 4588: return(NULL);
! 4589: }
! 4590: static void des_xmlSAXHandler_ptr(int no ATTRIBUTE_UNUSED, xmlSAXHandler * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 4591: }
! 4592:
! 4593: static int
! 4594: test_xmlSAX2InitDefaultSAXHandler(void) {
! 4595: int test_ret = 0;
! 4596:
! 4597: int mem_base;
! 4598: xmlSAXHandler * hdlr; /* the SAX handler */
! 4599: int n_hdlr;
! 4600: int warning; /* flag if non-zero sets the handler warning procedure */
! 4601: int n_warning;
! 4602:
! 4603: for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) {
! 4604: for (n_warning = 0;n_warning < gen_nb_int;n_warning++) {
! 4605: mem_base = xmlMemBlocks();
! 4606: hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0);
! 4607: warning = gen_int(n_warning, 1);
! 4608:
! 4609: xmlSAX2InitDefaultSAXHandler(hdlr, warning);
! 4610: call_tests++;
! 4611: des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0);
! 4612: des_int(n_warning, warning, 1);
! 4613: xmlResetLastError();
! 4614: if (mem_base != xmlMemBlocks()) {
! 4615: printf("Leak of %d blocks found in xmlSAX2InitDefaultSAXHandler",
! 4616: xmlMemBlocks() - mem_base);
! 4617: test_ret++;
! 4618: printf(" %d", n_hdlr);
! 4619: printf(" %d", n_warning);
! 4620: printf("\n");
! 4621: }
! 4622: }
! 4623: }
! 4624: function_tests++;
! 4625:
! 4626: return(test_ret);
! 4627: }
! 4628:
! 4629:
! 4630: static int
! 4631: test_xmlSAX2InitDocbDefaultSAXHandler(void) {
! 4632: int test_ret = 0;
! 4633:
! 4634: #if defined(LIBXML_DOCB_ENABLED)
! 4635: int mem_base;
! 4636: xmlSAXHandler * hdlr; /* the SAX handler */
! 4637: int n_hdlr;
! 4638:
! 4639: for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) {
! 4640: mem_base = xmlMemBlocks();
! 4641: hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0);
! 4642:
! 4643: xmlSAX2InitDocbDefaultSAXHandler(hdlr);
! 4644: call_tests++;
! 4645: des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0);
! 4646: xmlResetLastError();
! 4647: if (mem_base != xmlMemBlocks()) {
! 4648: printf("Leak of %d blocks found in xmlSAX2InitDocbDefaultSAXHandler",
! 4649: xmlMemBlocks() - mem_base);
! 4650: test_ret++;
! 4651: printf(" %d", n_hdlr);
! 4652: printf("\n");
! 4653: }
! 4654: }
! 4655: function_tests++;
! 4656: #endif
! 4657:
! 4658: return(test_ret);
! 4659: }
! 4660:
! 4661:
! 4662: static int
! 4663: test_xmlSAX2InitHtmlDefaultSAXHandler(void) {
! 4664: int test_ret = 0;
! 4665:
! 4666: #if defined(LIBXML_HTML_ENABLED)
! 4667: int mem_base;
! 4668: xmlSAXHandler * hdlr; /* the SAX handler */
! 4669: int n_hdlr;
! 4670:
! 4671: for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) {
! 4672: mem_base = xmlMemBlocks();
! 4673: hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0);
! 4674:
! 4675: xmlSAX2InitHtmlDefaultSAXHandler(hdlr);
! 4676: call_tests++;
! 4677: des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0);
! 4678: xmlResetLastError();
! 4679: if (mem_base != xmlMemBlocks()) {
! 4680: printf("Leak of %d blocks found in xmlSAX2InitHtmlDefaultSAXHandler",
! 4681: xmlMemBlocks() - mem_base);
! 4682: test_ret++;
! 4683: printf(" %d", n_hdlr);
! 4684: printf("\n");
! 4685: }
! 4686: }
! 4687: function_tests++;
! 4688: #endif
! 4689:
! 4690: return(test_ret);
! 4691: }
! 4692:
! 4693:
! 4694: static int
! 4695: test_xmlSAX2InternalSubset(void) {
! 4696: int test_ret = 0;
! 4697:
! 4698: int mem_base;
! 4699: void * ctx; /* the user data (XML parser context) */
! 4700: int n_ctx;
! 4701: xmlChar * name; /* the root element name */
! 4702: int n_name;
! 4703: xmlChar * ExternalID; /* the external ID */
! 4704: int n_ExternalID;
! 4705: xmlChar * SystemID; /* the SYSTEM ID (e.g. filename or URL) */
! 4706: int n_SystemID;
! 4707:
! 4708: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4709: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 4710: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
! 4711: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
! 4712: mem_base = xmlMemBlocks();
! 4713: ctx = gen_void_ptr(n_ctx, 0);
! 4714: name = gen_const_xmlChar_ptr(n_name, 1);
! 4715: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
! 4716: SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
! 4717:
! 4718: xmlSAX2InternalSubset(ctx, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
! 4719: call_tests++;
! 4720: des_void_ptr(n_ctx, ctx, 0);
! 4721: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 4722: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2);
! 4723: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3);
! 4724: xmlResetLastError();
! 4725: if (mem_base != xmlMemBlocks()) {
! 4726: printf("Leak of %d blocks found in xmlSAX2InternalSubset",
! 4727: xmlMemBlocks() - mem_base);
! 4728: test_ret++;
! 4729: printf(" %d", n_ctx);
! 4730: printf(" %d", n_name);
! 4731: printf(" %d", n_ExternalID);
! 4732: printf(" %d", n_SystemID);
! 4733: printf("\n");
! 4734: }
! 4735: }
! 4736: }
! 4737: }
! 4738: }
! 4739: function_tests++;
! 4740:
! 4741: return(test_ret);
! 4742: }
! 4743:
! 4744:
! 4745: static int
! 4746: test_xmlSAX2IsStandalone(void) {
! 4747: int test_ret = 0;
! 4748:
! 4749: int mem_base;
! 4750: int ret_val;
! 4751: void * ctx; /* the user data (XML parser context) */
! 4752: int n_ctx;
! 4753:
! 4754: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4755: mem_base = xmlMemBlocks();
! 4756: ctx = gen_void_ptr(n_ctx, 0);
! 4757:
! 4758: ret_val = xmlSAX2IsStandalone(ctx);
! 4759: desret_int(ret_val);
! 4760: call_tests++;
! 4761: des_void_ptr(n_ctx, ctx, 0);
! 4762: xmlResetLastError();
! 4763: if (mem_base != xmlMemBlocks()) {
! 4764: printf("Leak of %d blocks found in xmlSAX2IsStandalone",
! 4765: xmlMemBlocks() - mem_base);
! 4766: test_ret++;
! 4767: printf(" %d", n_ctx);
! 4768: printf("\n");
! 4769: }
! 4770: }
! 4771: function_tests++;
! 4772:
! 4773: return(test_ret);
! 4774: }
! 4775:
! 4776:
! 4777: static int
! 4778: test_xmlSAX2NotationDecl(void) {
! 4779: int test_ret = 0;
! 4780:
! 4781: int mem_base;
! 4782: void * ctx; /* the user data (XML parser context) */
! 4783: int n_ctx;
! 4784: xmlChar * name; /* The name of the notation */
! 4785: int n_name;
! 4786: xmlChar * publicId; /* The public ID of the entity */
! 4787: int n_publicId;
! 4788: xmlChar * systemId; /* The system ID of the entity */
! 4789: int n_systemId;
! 4790:
! 4791: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4792: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 4793: for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) {
! 4794: for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) {
! 4795: mem_base = xmlMemBlocks();
! 4796: ctx = gen_void_ptr(n_ctx, 0);
! 4797: name = gen_const_xmlChar_ptr(n_name, 1);
! 4798: publicId = gen_const_xmlChar_ptr(n_publicId, 2);
! 4799: systemId = gen_const_xmlChar_ptr(n_systemId, 3);
! 4800:
! 4801: xmlSAX2NotationDecl(ctx, (const xmlChar *)name, (const xmlChar *)publicId, (const xmlChar *)systemId);
! 4802: call_tests++;
! 4803: des_void_ptr(n_ctx, ctx, 0);
! 4804: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 4805: des_const_xmlChar_ptr(n_publicId, (const xmlChar *)publicId, 2);
! 4806: des_const_xmlChar_ptr(n_systemId, (const xmlChar *)systemId, 3);
! 4807: xmlResetLastError();
! 4808: if (mem_base != xmlMemBlocks()) {
! 4809: printf("Leak of %d blocks found in xmlSAX2NotationDecl",
! 4810: xmlMemBlocks() - mem_base);
! 4811: test_ret++;
! 4812: printf(" %d", n_ctx);
! 4813: printf(" %d", n_name);
! 4814: printf(" %d", n_publicId);
! 4815: printf(" %d", n_systemId);
! 4816: printf("\n");
! 4817: }
! 4818: }
! 4819: }
! 4820: }
! 4821: }
! 4822: function_tests++;
! 4823:
! 4824: return(test_ret);
! 4825: }
! 4826:
! 4827:
! 4828: static int
! 4829: test_xmlSAX2ProcessingInstruction(void) {
! 4830: int test_ret = 0;
! 4831:
! 4832: int mem_base;
! 4833: void * ctx; /* the user data (XML parser context) */
! 4834: int n_ctx;
! 4835: xmlChar * target; /* the target name */
! 4836: int n_target;
! 4837: xmlChar * data; /* the PI data's */
! 4838: int n_data;
! 4839:
! 4840: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4841: for (n_target = 0;n_target < gen_nb_const_xmlChar_ptr;n_target++) {
! 4842: for (n_data = 0;n_data < gen_nb_const_xmlChar_ptr;n_data++) {
! 4843: mem_base = xmlMemBlocks();
! 4844: ctx = gen_void_ptr(n_ctx, 0);
! 4845: target = gen_const_xmlChar_ptr(n_target, 1);
! 4846: data = gen_const_xmlChar_ptr(n_data, 2);
! 4847:
! 4848: xmlSAX2ProcessingInstruction(ctx, (const xmlChar *)target, (const xmlChar *)data);
! 4849: call_tests++;
! 4850: des_void_ptr(n_ctx, ctx, 0);
! 4851: des_const_xmlChar_ptr(n_target, (const xmlChar *)target, 1);
! 4852: des_const_xmlChar_ptr(n_data, (const xmlChar *)data, 2);
! 4853: xmlResetLastError();
! 4854: if (mem_base != xmlMemBlocks()) {
! 4855: printf("Leak of %d blocks found in xmlSAX2ProcessingInstruction",
! 4856: xmlMemBlocks() - mem_base);
! 4857: test_ret++;
! 4858: printf(" %d", n_ctx);
! 4859: printf(" %d", n_target);
! 4860: printf(" %d", n_data);
! 4861: printf("\n");
! 4862: }
! 4863: }
! 4864: }
! 4865: }
! 4866: function_tests++;
! 4867:
! 4868: return(test_ret);
! 4869: }
! 4870:
! 4871:
! 4872: static int
! 4873: test_xmlSAX2Reference(void) {
! 4874: int test_ret = 0;
! 4875:
! 4876: int mem_base;
! 4877: void * ctx; /* the user data (XML parser context) */
! 4878: int n_ctx;
! 4879: xmlChar * name; /* The entity name */
! 4880: int n_name;
! 4881:
! 4882: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4883: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 4884: mem_base = xmlMemBlocks();
! 4885: ctx = gen_void_ptr(n_ctx, 0);
! 4886: name = gen_const_xmlChar_ptr(n_name, 1);
! 4887:
! 4888: xmlSAX2Reference(ctx, (const xmlChar *)name);
! 4889: call_tests++;
! 4890: des_void_ptr(n_ctx, ctx, 0);
! 4891: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 4892: xmlResetLastError();
! 4893: if (mem_base != xmlMemBlocks()) {
! 4894: printf("Leak of %d blocks found in xmlSAX2Reference",
! 4895: xmlMemBlocks() - mem_base);
! 4896: test_ret++;
! 4897: printf(" %d", n_ctx);
! 4898: printf(" %d", n_name);
! 4899: printf("\n");
! 4900: }
! 4901: }
! 4902: }
! 4903: function_tests++;
! 4904:
! 4905: return(test_ret);
! 4906: }
! 4907:
! 4908:
! 4909: static int
! 4910: test_xmlSAX2ResolveEntity(void) {
! 4911: int test_ret = 0;
! 4912:
! 4913: int mem_base;
! 4914: xmlParserInputPtr ret_val;
! 4915: void * ctx; /* the user data (XML parser context) */
! 4916: int n_ctx;
! 4917: xmlChar * publicId; /* The public ID of the entity */
! 4918: int n_publicId;
! 4919: xmlChar * systemId; /* The system ID of the entity */
! 4920: int n_systemId;
! 4921:
! 4922: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4923: for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) {
! 4924: for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) {
! 4925: mem_base = xmlMemBlocks();
! 4926: ctx = gen_void_ptr(n_ctx, 0);
! 4927: publicId = gen_const_xmlChar_ptr(n_publicId, 1);
! 4928: systemId = gen_const_xmlChar_ptr(n_systemId, 2);
! 4929:
! 4930: ret_val = xmlSAX2ResolveEntity(ctx, (const xmlChar *)publicId, (const xmlChar *)systemId);
! 4931: desret_xmlParserInputPtr(ret_val);
! 4932: call_tests++;
! 4933: des_void_ptr(n_ctx, ctx, 0);
! 4934: des_const_xmlChar_ptr(n_publicId, (const xmlChar *)publicId, 1);
! 4935: des_const_xmlChar_ptr(n_systemId, (const xmlChar *)systemId, 2);
! 4936: xmlResetLastError();
! 4937: if (mem_base != xmlMemBlocks()) {
! 4938: printf("Leak of %d blocks found in xmlSAX2ResolveEntity",
! 4939: xmlMemBlocks() - mem_base);
! 4940: test_ret++;
! 4941: printf(" %d", n_ctx);
! 4942: printf(" %d", n_publicId);
! 4943: printf(" %d", n_systemId);
! 4944: printf("\n");
! 4945: }
! 4946: }
! 4947: }
! 4948: }
! 4949: function_tests++;
! 4950:
! 4951: return(test_ret);
! 4952: }
! 4953:
! 4954:
! 4955: #define gen_nb_xmlSAXLocatorPtr 1
! 4956: static xmlSAXLocatorPtr gen_xmlSAXLocatorPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 4957: return(NULL);
! 4958: }
! 4959: static void des_xmlSAXLocatorPtr(int no ATTRIBUTE_UNUSED, xmlSAXLocatorPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 4960: }
! 4961:
! 4962: static int
! 4963: test_xmlSAX2SetDocumentLocator(void) {
! 4964: int test_ret = 0;
! 4965:
! 4966: int mem_base;
! 4967: void * ctx; /* the user data (XML parser context) */
! 4968: int n_ctx;
! 4969: xmlSAXLocatorPtr loc; /* A SAX Locator */
! 4970: int n_loc;
! 4971:
! 4972: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 4973: for (n_loc = 0;n_loc < gen_nb_xmlSAXLocatorPtr;n_loc++) {
! 4974: mem_base = xmlMemBlocks();
! 4975: ctx = gen_void_ptr(n_ctx, 0);
! 4976: loc = gen_xmlSAXLocatorPtr(n_loc, 1);
! 4977:
! 4978: xmlSAX2SetDocumentLocator(ctx, loc);
! 4979: call_tests++;
! 4980: des_void_ptr(n_ctx, ctx, 0);
! 4981: des_xmlSAXLocatorPtr(n_loc, loc, 1);
! 4982: xmlResetLastError();
! 4983: if (mem_base != xmlMemBlocks()) {
! 4984: printf("Leak of %d blocks found in xmlSAX2SetDocumentLocator",
! 4985: xmlMemBlocks() - mem_base);
! 4986: test_ret++;
! 4987: printf(" %d", n_ctx);
! 4988: printf(" %d", n_loc);
! 4989: printf("\n");
! 4990: }
! 4991: }
! 4992: }
! 4993: function_tests++;
! 4994:
! 4995: return(test_ret);
! 4996: }
! 4997:
! 4998:
! 4999: static int
! 5000: test_xmlSAX2StartDocument(void) {
! 5001: int test_ret = 0;
! 5002:
! 5003: int mem_base;
! 5004: void * ctx; /* the user data (XML parser context) */
! 5005: int n_ctx;
! 5006:
! 5007: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 5008: mem_base = xmlMemBlocks();
! 5009: ctx = gen_void_ptr(n_ctx, 0);
! 5010:
! 5011: xmlSAX2StartDocument(ctx);
! 5012: call_tests++;
! 5013: des_void_ptr(n_ctx, ctx, 0);
! 5014: xmlResetLastError();
! 5015: if (mem_base != xmlMemBlocks()) {
! 5016: printf("Leak of %d blocks found in xmlSAX2StartDocument",
! 5017: xmlMemBlocks() - mem_base);
! 5018: test_ret++;
! 5019: printf(" %d", n_ctx);
! 5020: printf("\n");
! 5021: }
! 5022: }
! 5023: function_tests++;
! 5024:
! 5025: return(test_ret);
! 5026: }
! 5027:
! 5028:
! 5029: static int
! 5030: test_xmlSAX2StartElement(void) {
! 5031: int test_ret = 0;
! 5032:
! 5033: #if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED)
! 5034: #ifdef LIBXML_SAX1_ENABLED
! 5035: int mem_base;
! 5036: void * ctx; /* the user data (XML parser context) */
! 5037: int n_ctx;
! 5038: xmlChar * fullname; /* The element name, including namespace prefix */
! 5039: int n_fullname;
! 5040: xmlChar ** atts; /* An array of name/value attributes pairs, NULL terminated */
! 5041: int n_atts;
! 5042:
! 5043: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 5044: for (n_fullname = 0;n_fullname < gen_nb_const_xmlChar_ptr;n_fullname++) {
! 5045: for (n_atts = 0;n_atts < gen_nb_const_xmlChar_ptr_ptr;n_atts++) {
! 5046: mem_base = xmlMemBlocks();
! 5047: ctx = gen_void_ptr(n_ctx, 0);
! 5048: fullname = gen_const_xmlChar_ptr(n_fullname, 1);
! 5049: atts = gen_const_xmlChar_ptr_ptr(n_atts, 2);
! 5050:
! 5051: xmlSAX2StartElement(ctx, (const xmlChar *)fullname, (const xmlChar **)atts);
! 5052: call_tests++;
! 5053: des_void_ptr(n_ctx, ctx, 0);
! 5054: des_const_xmlChar_ptr(n_fullname, (const xmlChar *)fullname, 1);
! 5055: des_const_xmlChar_ptr_ptr(n_atts, (const xmlChar **)atts, 2);
! 5056: xmlResetLastError();
! 5057: if (mem_base != xmlMemBlocks()) {
! 5058: printf("Leak of %d blocks found in xmlSAX2StartElement",
! 5059: xmlMemBlocks() - mem_base);
! 5060: test_ret++;
! 5061: printf(" %d", n_ctx);
! 5062: printf(" %d", n_fullname);
! 5063: printf(" %d", n_atts);
! 5064: printf("\n");
! 5065: }
! 5066: }
! 5067: }
! 5068: }
! 5069: function_tests++;
! 5070: #endif
! 5071: #endif
! 5072:
! 5073: return(test_ret);
! 5074: }
! 5075:
! 5076:
! 5077: static int
! 5078: test_xmlSAX2StartElementNs(void) {
! 5079: int test_ret = 0;
! 5080:
! 5081: int mem_base;
! 5082: void * ctx; /* the user data (XML parser context) */
! 5083: int n_ctx;
! 5084: xmlChar * localname; /* the local name of the element */
! 5085: int n_localname;
! 5086: xmlChar * prefix; /* the element namespace prefix if available */
! 5087: int n_prefix;
! 5088: xmlChar * URI; /* the element namespace name if available */
! 5089: int n_URI;
! 5090: int nb_namespaces; /* number of namespace definitions on that node */
! 5091: int n_nb_namespaces;
! 5092: xmlChar ** namespaces; /* pointer to the array of prefix/URI pairs namespace definitions */
! 5093: int n_namespaces;
! 5094: int nb_attributes; /* the number of attributes on that node */
! 5095: int n_nb_attributes;
! 5096: int nb_defaulted; /* the number of defaulted attributes. */
! 5097: int n_nb_defaulted;
! 5098: xmlChar ** attributes; /* pointer to the array of (localname/prefix/URI/value/end) attribute values. */
! 5099: int n_attributes;
! 5100:
! 5101: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 5102: for (n_localname = 0;n_localname < gen_nb_const_xmlChar_ptr;n_localname++) {
! 5103: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
! 5104: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
! 5105: for (n_nb_namespaces = 0;n_nb_namespaces < gen_nb_int;n_nb_namespaces++) {
! 5106: for (n_namespaces = 0;n_namespaces < gen_nb_const_xmlChar_ptr_ptr;n_namespaces++) {
! 5107: for (n_nb_attributes = 0;n_nb_attributes < gen_nb_int;n_nb_attributes++) {
! 5108: for (n_nb_defaulted = 0;n_nb_defaulted < gen_nb_int;n_nb_defaulted++) {
! 5109: for (n_attributes = 0;n_attributes < gen_nb_const_xmlChar_ptr_ptr;n_attributes++) {
! 5110: mem_base = xmlMemBlocks();
! 5111: ctx = gen_void_ptr(n_ctx, 0);
! 5112: localname = gen_const_xmlChar_ptr(n_localname, 1);
! 5113: prefix = gen_const_xmlChar_ptr(n_prefix, 2);
! 5114: URI = gen_const_xmlChar_ptr(n_URI, 3);
! 5115: nb_namespaces = gen_int(n_nb_namespaces, 4);
! 5116: namespaces = gen_const_xmlChar_ptr_ptr(n_namespaces, 5);
! 5117: nb_attributes = gen_int(n_nb_attributes, 6);
! 5118: nb_defaulted = gen_int(n_nb_defaulted, 7);
! 5119: attributes = gen_const_xmlChar_ptr_ptr(n_attributes, 8);
! 5120:
! 5121: xmlSAX2StartElementNs(ctx, (const xmlChar *)localname, (const xmlChar *)prefix, (const xmlChar *)URI, nb_namespaces, (const xmlChar **)namespaces, nb_attributes, nb_defaulted, (const xmlChar **)attributes);
! 5122: call_tests++;
! 5123: des_void_ptr(n_ctx, ctx, 0);
! 5124: des_const_xmlChar_ptr(n_localname, (const xmlChar *)localname, 1);
! 5125: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2);
! 5126: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 3);
! 5127: des_int(n_nb_namespaces, nb_namespaces, 4);
! 5128: des_const_xmlChar_ptr_ptr(n_namespaces, (const xmlChar **)namespaces, 5);
! 5129: des_int(n_nb_attributes, nb_attributes, 6);
! 5130: des_int(n_nb_defaulted, nb_defaulted, 7);
! 5131: des_const_xmlChar_ptr_ptr(n_attributes, (const xmlChar **)attributes, 8);
! 5132: xmlResetLastError();
! 5133: if (mem_base != xmlMemBlocks()) {
! 5134: printf("Leak of %d blocks found in xmlSAX2StartElementNs",
! 5135: xmlMemBlocks() - mem_base);
! 5136: test_ret++;
! 5137: printf(" %d", n_ctx);
! 5138: printf(" %d", n_localname);
! 5139: printf(" %d", n_prefix);
! 5140: printf(" %d", n_URI);
! 5141: printf(" %d", n_nb_namespaces);
! 5142: printf(" %d", n_namespaces);
! 5143: printf(" %d", n_nb_attributes);
! 5144: printf(" %d", n_nb_defaulted);
! 5145: printf(" %d", n_attributes);
! 5146: printf("\n");
! 5147: }
! 5148: }
! 5149: }
! 5150: }
! 5151: }
! 5152: }
! 5153: }
! 5154: }
! 5155: }
! 5156: }
! 5157: function_tests++;
! 5158:
! 5159: return(test_ret);
! 5160: }
! 5161:
! 5162:
! 5163: static int
! 5164: test_xmlSAX2UnparsedEntityDecl(void) {
! 5165: int test_ret = 0;
! 5166:
! 5167: int mem_base;
! 5168: void * ctx; /* the user data (XML parser context) */
! 5169: int n_ctx;
! 5170: xmlChar * name; /* The name of the entity */
! 5171: int n_name;
! 5172: xmlChar * publicId; /* The public ID of the entity */
! 5173: int n_publicId;
! 5174: xmlChar * systemId; /* The system ID of the entity */
! 5175: int n_systemId;
! 5176: xmlChar * notationName; /* the name of the notation */
! 5177: int n_notationName;
! 5178:
! 5179: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 5180: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 5181: for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) {
! 5182: for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) {
! 5183: for (n_notationName = 0;n_notationName < gen_nb_const_xmlChar_ptr;n_notationName++) {
! 5184: mem_base = xmlMemBlocks();
! 5185: ctx = gen_void_ptr(n_ctx, 0);
! 5186: name = gen_const_xmlChar_ptr(n_name, 1);
! 5187: publicId = gen_const_xmlChar_ptr(n_publicId, 2);
! 5188: systemId = gen_const_xmlChar_ptr(n_systemId, 3);
! 5189: notationName = gen_const_xmlChar_ptr(n_notationName, 4);
! 5190:
! 5191: xmlSAX2UnparsedEntityDecl(ctx, (const xmlChar *)name, (const xmlChar *)publicId, (const xmlChar *)systemId, (const xmlChar *)notationName);
! 5192: call_tests++;
! 5193: des_void_ptr(n_ctx, ctx, 0);
! 5194: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 5195: des_const_xmlChar_ptr(n_publicId, (const xmlChar *)publicId, 2);
! 5196: des_const_xmlChar_ptr(n_systemId, (const xmlChar *)systemId, 3);
! 5197: des_const_xmlChar_ptr(n_notationName, (const xmlChar *)notationName, 4);
! 5198: xmlResetLastError();
! 5199: if (mem_base != xmlMemBlocks()) {
! 5200: printf("Leak of %d blocks found in xmlSAX2UnparsedEntityDecl",
! 5201: xmlMemBlocks() - mem_base);
! 5202: test_ret++;
! 5203: printf(" %d", n_ctx);
! 5204: printf(" %d", n_name);
! 5205: printf(" %d", n_publicId);
! 5206: printf(" %d", n_systemId);
! 5207: printf(" %d", n_notationName);
! 5208: printf("\n");
! 5209: }
! 5210: }
! 5211: }
! 5212: }
! 5213: }
! 5214: }
! 5215: function_tests++;
! 5216:
! 5217: return(test_ret);
! 5218: }
! 5219:
! 5220:
! 5221: static int
! 5222: test_xmlSAXDefaultVersion(void) {
! 5223: int test_ret = 0;
! 5224:
! 5225: #if defined(LIBXML_SAX1_ENABLED)
! 5226: #ifdef LIBXML_SAX1_ENABLED
! 5227: int mem_base;
! 5228: int ret_val;
! 5229: int version; /* the version, 1 or 2 */
! 5230: int n_version;
! 5231:
! 5232: for (n_version = 0;n_version < gen_nb_int;n_version++) {
! 5233: mem_base = xmlMemBlocks();
! 5234: version = gen_int(n_version, 0);
! 5235:
! 5236: ret_val = xmlSAXDefaultVersion(version);
! 5237: desret_int(ret_val);
! 5238: call_tests++;
! 5239: des_int(n_version, version, 0);
! 5240: xmlResetLastError();
! 5241: if (mem_base != xmlMemBlocks()) {
! 5242: printf("Leak of %d blocks found in xmlSAXDefaultVersion",
! 5243: xmlMemBlocks() - mem_base);
! 5244: test_ret++;
! 5245: printf(" %d", n_version);
! 5246: printf("\n");
! 5247: }
! 5248: }
! 5249: function_tests++;
! 5250: #endif
! 5251: #endif
! 5252:
! 5253: return(test_ret);
! 5254: }
! 5255:
! 5256:
! 5257: static int
! 5258: test_xmlSAXVersion(void) {
! 5259: int test_ret = 0;
! 5260:
! 5261: int mem_base;
! 5262: int ret_val;
! 5263: xmlSAXHandler * hdlr; /* the SAX handler */
! 5264: int n_hdlr;
! 5265: int version; /* the version, 1 or 2 */
! 5266: int n_version;
! 5267:
! 5268: for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) {
! 5269: for (n_version = 0;n_version < gen_nb_int;n_version++) {
! 5270: mem_base = xmlMemBlocks();
! 5271: hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0);
! 5272: version = gen_int(n_version, 1);
! 5273:
! 5274: ret_val = xmlSAXVersion(hdlr, version);
! 5275: desret_int(ret_val);
! 5276: call_tests++;
! 5277: des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0);
! 5278: des_int(n_version, version, 1);
! 5279: xmlResetLastError();
! 5280: if (mem_base != xmlMemBlocks()) {
! 5281: printf("Leak of %d blocks found in xmlSAXVersion",
! 5282: xmlMemBlocks() - mem_base);
! 5283: test_ret++;
! 5284: printf(" %d", n_hdlr);
! 5285: printf(" %d", n_version);
! 5286: printf("\n");
! 5287: }
! 5288: }
! 5289: }
! 5290: function_tests++;
! 5291:
! 5292: return(test_ret);
! 5293: }
! 5294:
! 5295: static int
! 5296: test_SAX2(void) {
! 5297: int test_ret = 0;
! 5298:
! 5299: if (quiet == 0) printf("Testing SAX2 : 38 of 38 functions ...\n");
! 5300: test_ret += test_docbDefaultSAXHandlerInit();
! 5301: test_ret += test_htmlDefaultSAXHandlerInit();
! 5302: test_ret += test_xmlDefaultSAXHandlerInit();
! 5303: test_ret += test_xmlSAX2AttributeDecl();
! 5304: test_ret += test_xmlSAX2CDataBlock();
! 5305: test_ret += test_xmlSAX2Characters();
! 5306: test_ret += test_xmlSAX2Comment();
! 5307: test_ret += test_xmlSAX2ElementDecl();
! 5308: test_ret += test_xmlSAX2EndDocument();
! 5309: test_ret += test_xmlSAX2EndElement();
! 5310: test_ret += test_xmlSAX2EndElementNs();
! 5311: test_ret += test_xmlSAX2EntityDecl();
! 5312: test_ret += test_xmlSAX2ExternalSubset();
! 5313: test_ret += test_xmlSAX2GetColumnNumber();
! 5314: test_ret += test_xmlSAX2GetEntity();
! 5315: test_ret += test_xmlSAX2GetLineNumber();
! 5316: test_ret += test_xmlSAX2GetParameterEntity();
! 5317: test_ret += test_xmlSAX2GetPublicId();
! 5318: test_ret += test_xmlSAX2GetSystemId();
! 5319: test_ret += test_xmlSAX2HasExternalSubset();
! 5320: test_ret += test_xmlSAX2HasInternalSubset();
! 5321: test_ret += test_xmlSAX2IgnorableWhitespace();
! 5322: test_ret += test_xmlSAX2InitDefaultSAXHandler();
! 5323: test_ret += test_xmlSAX2InitDocbDefaultSAXHandler();
! 5324: test_ret += test_xmlSAX2InitHtmlDefaultSAXHandler();
! 5325: test_ret += test_xmlSAX2InternalSubset();
! 5326: test_ret += test_xmlSAX2IsStandalone();
! 5327: test_ret += test_xmlSAX2NotationDecl();
! 5328: test_ret += test_xmlSAX2ProcessingInstruction();
! 5329: test_ret += test_xmlSAX2Reference();
! 5330: test_ret += test_xmlSAX2ResolveEntity();
! 5331: test_ret += test_xmlSAX2SetDocumentLocator();
! 5332: test_ret += test_xmlSAX2StartDocument();
! 5333: test_ret += test_xmlSAX2StartElement();
! 5334: test_ret += test_xmlSAX2StartElementNs();
! 5335: test_ret += test_xmlSAX2UnparsedEntityDecl();
! 5336: test_ret += test_xmlSAXDefaultVersion();
! 5337: test_ret += test_xmlSAXVersion();
! 5338:
! 5339: if (test_ret != 0)
! 5340: printf("Module SAX2: %d errors\n", test_ret);
! 5341: return(test_ret);
! 5342: }
! 5343:
! 5344: static int
! 5345: test_xmlC14NDocDumpMemory(void) {
! 5346: int test_ret = 0;
! 5347:
! 5348: #if defined(LIBXML_C14N_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 5349: int mem_base;
! 5350: int ret_val;
! 5351: xmlDocPtr doc; /* the XML document for canonization */
! 5352: int n_doc;
! 5353: xmlNodeSetPtr nodes; /* the nodes set to be included in the canonized image or NULL if all document nodes should be included */
! 5354: int n_nodes;
! 5355: int mode; /* the c14n mode (see @xmlC14NMode) */
! 5356: int n_mode;
! 5357: xmlChar ** inclusive_ns_prefixes; /* the list of inclusive namespace prefixes ended with a NULL or NULL if there is no inclusive namespaces (only for exclusive canonicalization, ignored otherwise) */
! 5358: int n_inclusive_ns_prefixes;
! 5359: int with_comments; /* include comments in the result (!=0) or not (==0) */
! 5360: int n_with_comments;
! 5361: xmlChar ** doc_txt_ptr; /* the memory pointer for allocated canonical XML text; the caller of this functions is responsible for calling xmlFree() to free allocated memory */
! 5362: int n_doc_txt_ptr;
! 5363:
! 5364: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 5365: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
! 5366: for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
! 5367: for (n_inclusive_ns_prefixes = 0;n_inclusive_ns_prefixes < gen_nb_xmlChar_ptr_ptr;n_inclusive_ns_prefixes++) {
! 5368: for (n_with_comments = 0;n_with_comments < gen_nb_int;n_with_comments++) {
! 5369: for (n_doc_txt_ptr = 0;n_doc_txt_ptr < gen_nb_xmlChar_ptr_ptr;n_doc_txt_ptr++) {
! 5370: mem_base = xmlMemBlocks();
! 5371: doc = gen_xmlDocPtr(n_doc, 0);
! 5372: nodes = gen_xmlNodeSetPtr(n_nodes, 1);
! 5373: mode = gen_int(n_mode, 2);
! 5374: inclusive_ns_prefixes = gen_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, 3);
! 5375: with_comments = gen_int(n_with_comments, 4);
! 5376: doc_txt_ptr = gen_xmlChar_ptr_ptr(n_doc_txt_ptr, 5);
! 5377:
! 5378: ret_val = xmlC14NDocDumpMemory(doc, nodes, mode, inclusive_ns_prefixes, with_comments, doc_txt_ptr);
! 5379: desret_int(ret_val);
! 5380: call_tests++;
! 5381: des_xmlDocPtr(n_doc, doc, 0);
! 5382: des_xmlNodeSetPtr(n_nodes, nodes, 1);
! 5383: des_int(n_mode, mode, 2);
! 5384: des_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, inclusive_ns_prefixes, 3);
! 5385: des_int(n_with_comments, with_comments, 4);
! 5386: des_xmlChar_ptr_ptr(n_doc_txt_ptr, doc_txt_ptr, 5);
! 5387: xmlResetLastError();
! 5388: if (mem_base != xmlMemBlocks()) {
! 5389: printf("Leak of %d blocks found in xmlC14NDocDumpMemory",
! 5390: xmlMemBlocks() - mem_base);
! 5391: test_ret++;
! 5392: printf(" %d", n_doc);
! 5393: printf(" %d", n_nodes);
! 5394: printf(" %d", n_mode);
! 5395: printf(" %d", n_inclusive_ns_prefixes);
! 5396: printf(" %d", n_with_comments);
! 5397: printf(" %d", n_doc_txt_ptr);
! 5398: printf("\n");
! 5399: }
! 5400: }
! 5401: }
! 5402: }
! 5403: }
! 5404: }
! 5405: }
! 5406: function_tests++;
! 5407: #endif
! 5408:
! 5409: return(test_ret);
! 5410: }
! 5411:
! 5412:
! 5413: static int
! 5414: test_xmlC14NDocSave(void) {
! 5415: int test_ret = 0;
! 5416:
! 5417: #if defined(LIBXML_C14N_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 5418: int mem_base;
! 5419: int ret_val;
! 5420: xmlDocPtr doc; /* the XML document for canonization */
! 5421: int n_doc;
! 5422: xmlNodeSetPtr nodes; /* the nodes set to be included in the canonized image or NULL if all document nodes should be included */
! 5423: int n_nodes;
! 5424: int mode; /* the c14n mode (see @xmlC14NMode) */
! 5425: int n_mode;
! 5426: xmlChar ** inclusive_ns_prefixes; /* the list of inclusive namespace prefixes ended with a NULL or NULL if there is no inclusive namespaces (only for exclusive canonicalization, ignored otherwise) */
! 5427: int n_inclusive_ns_prefixes;
! 5428: int with_comments; /* include comments in the result (!=0) or not (==0) */
! 5429: int n_with_comments;
! 5430: const char * filename; /* the filename to store canonical XML image */
! 5431: int n_filename;
! 5432: int compression; /* the compression level (zlib requred): -1 - libxml default, 0 - uncompressed, >0 - compression level */
! 5433: int n_compression;
! 5434:
! 5435: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 5436: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
! 5437: for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
! 5438: for (n_inclusive_ns_prefixes = 0;n_inclusive_ns_prefixes < gen_nb_xmlChar_ptr_ptr;n_inclusive_ns_prefixes++) {
! 5439: for (n_with_comments = 0;n_with_comments < gen_nb_int;n_with_comments++) {
! 5440: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
! 5441: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
! 5442: mem_base = xmlMemBlocks();
! 5443: doc = gen_xmlDocPtr(n_doc, 0);
! 5444: nodes = gen_xmlNodeSetPtr(n_nodes, 1);
! 5445: mode = gen_int(n_mode, 2);
! 5446: inclusive_ns_prefixes = gen_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, 3);
! 5447: with_comments = gen_int(n_with_comments, 4);
! 5448: filename = gen_fileoutput(n_filename, 5);
! 5449: compression = gen_int(n_compression, 6);
! 5450:
! 5451: ret_val = xmlC14NDocSave(doc, nodes, mode, inclusive_ns_prefixes, with_comments, filename, compression);
! 5452: desret_int(ret_val);
! 5453: call_tests++;
! 5454: des_xmlDocPtr(n_doc, doc, 0);
! 5455: des_xmlNodeSetPtr(n_nodes, nodes, 1);
! 5456: des_int(n_mode, mode, 2);
! 5457: des_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, inclusive_ns_prefixes, 3);
! 5458: des_int(n_with_comments, with_comments, 4);
! 5459: des_fileoutput(n_filename, filename, 5);
! 5460: des_int(n_compression, compression, 6);
! 5461: xmlResetLastError();
! 5462: if (mem_base != xmlMemBlocks()) {
! 5463: printf("Leak of %d blocks found in xmlC14NDocSave",
! 5464: xmlMemBlocks() - mem_base);
! 5465: test_ret++;
! 5466: printf(" %d", n_doc);
! 5467: printf(" %d", n_nodes);
! 5468: printf(" %d", n_mode);
! 5469: printf(" %d", n_inclusive_ns_prefixes);
! 5470: printf(" %d", n_with_comments);
! 5471: printf(" %d", n_filename);
! 5472: printf(" %d", n_compression);
! 5473: printf("\n");
! 5474: }
! 5475: }
! 5476: }
! 5477: }
! 5478: }
! 5479: }
! 5480: }
! 5481: }
! 5482: function_tests++;
! 5483: #endif
! 5484:
! 5485: return(test_ret);
! 5486: }
! 5487:
! 5488:
! 5489: static int
! 5490: test_xmlC14NDocSaveTo(void) {
! 5491: int test_ret = 0;
! 5492:
! 5493: #if defined(LIBXML_C14N_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 5494: int mem_base;
! 5495: int ret_val;
! 5496: xmlDocPtr doc; /* the XML document for canonization */
! 5497: int n_doc;
! 5498: xmlNodeSetPtr nodes; /* the nodes set to be included in the canonized image or NULL if all document nodes should be included */
! 5499: int n_nodes;
! 5500: int mode; /* the c14n mode (see @xmlC14NMode) */
! 5501: int n_mode;
! 5502: xmlChar ** inclusive_ns_prefixes; /* the list of inclusive namespace prefixes ended with a NULL or NULL if there is no inclusive namespaces (only for exclusive canonicalization, ignored otherwise) */
! 5503: int n_inclusive_ns_prefixes;
! 5504: int with_comments; /* include comments in the result (!=0) or not (==0) */
! 5505: int n_with_comments;
! 5506: xmlOutputBufferPtr buf; /* the output buffer to store canonical XML; this buffer MUST have encoder==NULL because C14N requires UTF-8 output */
! 5507: int n_buf;
! 5508:
! 5509: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 5510: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
! 5511: for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
! 5512: for (n_inclusive_ns_prefixes = 0;n_inclusive_ns_prefixes < gen_nb_xmlChar_ptr_ptr;n_inclusive_ns_prefixes++) {
! 5513: for (n_with_comments = 0;n_with_comments < gen_nb_int;n_with_comments++) {
! 5514: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
! 5515: mem_base = xmlMemBlocks();
! 5516: doc = gen_xmlDocPtr(n_doc, 0);
! 5517: nodes = gen_xmlNodeSetPtr(n_nodes, 1);
! 5518: mode = gen_int(n_mode, 2);
! 5519: inclusive_ns_prefixes = gen_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, 3);
! 5520: with_comments = gen_int(n_with_comments, 4);
! 5521: buf = gen_xmlOutputBufferPtr(n_buf, 5);
! 5522:
! 5523: ret_val = xmlC14NDocSaveTo(doc, nodes, mode, inclusive_ns_prefixes, with_comments, buf);
! 5524: desret_int(ret_val);
! 5525: call_tests++;
! 5526: des_xmlDocPtr(n_doc, doc, 0);
! 5527: des_xmlNodeSetPtr(n_nodes, nodes, 1);
! 5528: des_int(n_mode, mode, 2);
! 5529: des_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, inclusive_ns_prefixes, 3);
! 5530: des_int(n_with_comments, with_comments, 4);
! 5531: des_xmlOutputBufferPtr(n_buf, buf, 5);
! 5532: xmlResetLastError();
! 5533: if (mem_base != xmlMemBlocks()) {
! 5534: printf("Leak of %d blocks found in xmlC14NDocSaveTo",
! 5535: xmlMemBlocks() - mem_base);
! 5536: test_ret++;
! 5537: printf(" %d", n_doc);
! 5538: printf(" %d", n_nodes);
! 5539: printf(" %d", n_mode);
! 5540: printf(" %d", n_inclusive_ns_prefixes);
! 5541: printf(" %d", n_with_comments);
! 5542: printf(" %d", n_buf);
! 5543: printf("\n");
! 5544: }
! 5545: }
! 5546: }
! 5547: }
! 5548: }
! 5549: }
! 5550: }
! 5551: function_tests++;
! 5552: #endif
! 5553:
! 5554: return(test_ret);
! 5555: }
! 5556:
! 5557:
! 5558: static int
! 5559: test_xmlC14NExecute(void) {
! 5560: int test_ret = 0;
! 5561:
! 5562:
! 5563: /* missing type support */
! 5564: return(test_ret);
! 5565: }
! 5566:
! 5567: static int
! 5568: test_c14n(void) {
! 5569: int test_ret = 0;
! 5570:
! 5571: if (quiet == 0) printf("Testing c14n : 3 of 4 functions ...\n");
! 5572: test_ret += test_xmlC14NDocDumpMemory();
! 5573: test_ret += test_xmlC14NDocSave();
! 5574: test_ret += test_xmlC14NDocSaveTo();
! 5575: test_ret += test_xmlC14NExecute();
! 5576:
! 5577: if (test_ret != 0)
! 5578: printf("Module c14n: %d errors\n", test_ret);
! 5579: return(test_ret);
! 5580: }
! 5581: #ifdef LIBXML_CATALOG_ENABLED
! 5582:
! 5583: #define gen_nb_xmlCatalogPtr 1
! 5584: static xmlCatalogPtr gen_xmlCatalogPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 5585: return(NULL);
! 5586: }
! 5587: static void des_xmlCatalogPtr(int no ATTRIBUTE_UNUSED, xmlCatalogPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 5588: }
! 5589: #endif
! 5590:
! 5591:
! 5592: static int
! 5593: test_xmlACatalogAdd(void) {
! 5594: int test_ret = 0;
! 5595:
! 5596: #if defined(LIBXML_CATALOG_ENABLED)
! 5597: int mem_base;
! 5598: int ret_val;
! 5599: xmlCatalogPtr catal; /* a Catalog */
! 5600: int n_catal;
! 5601: xmlChar * type; /* the type of record to add to the catalog */
! 5602: int n_type;
! 5603: xmlChar * orig; /* the system, public or prefix to match */
! 5604: int n_orig;
! 5605: xmlChar * replace; /* the replacement value for the match */
! 5606: int n_replace;
! 5607:
! 5608: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
! 5609: for (n_type = 0;n_type < gen_nb_const_xmlChar_ptr;n_type++) {
! 5610: for (n_orig = 0;n_orig < gen_nb_const_xmlChar_ptr;n_orig++) {
! 5611: for (n_replace = 0;n_replace < gen_nb_const_xmlChar_ptr;n_replace++) {
! 5612: mem_base = xmlMemBlocks();
! 5613: catal = gen_xmlCatalogPtr(n_catal, 0);
! 5614: type = gen_const_xmlChar_ptr(n_type, 1);
! 5615: orig = gen_const_xmlChar_ptr(n_orig, 2);
! 5616: replace = gen_const_xmlChar_ptr(n_replace, 3);
! 5617:
! 5618: ret_val = xmlACatalogAdd(catal, (const xmlChar *)type, (const xmlChar *)orig, (const xmlChar *)replace);
! 5619: desret_int(ret_val);
! 5620: call_tests++;
! 5621: des_xmlCatalogPtr(n_catal, catal, 0);
! 5622: des_const_xmlChar_ptr(n_type, (const xmlChar *)type, 1);
! 5623: des_const_xmlChar_ptr(n_orig, (const xmlChar *)orig, 2);
! 5624: des_const_xmlChar_ptr(n_replace, (const xmlChar *)replace, 3);
! 5625: xmlResetLastError();
! 5626: if (mem_base != xmlMemBlocks()) {
! 5627: printf("Leak of %d blocks found in xmlACatalogAdd",
! 5628: xmlMemBlocks() - mem_base);
! 5629: test_ret++;
! 5630: printf(" %d", n_catal);
! 5631: printf(" %d", n_type);
! 5632: printf(" %d", n_orig);
! 5633: printf(" %d", n_replace);
! 5634: printf("\n");
! 5635: }
! 5636: }
! 5637: }
! 5638: }
! 5639: }
! 5640: function_tests++;
! 5641: #endif
! 5642:
! 5643: return(test_ret);
! 5644: }
! 5645:
! 5646:
! 5647: static int
! 5648: test_xmlACatalogDump(void) {
! 5649: int test_ret = 0;
! 5650:
! 5651: #if defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 5652: int mem_base;
! 5653: xmlCatalogPtr catal; /* a Catalog */
! 5654: int n_catal;
! 5655: FILE * out; /* the file. */
! 5656: int n_out;
! 5657:
! 5658: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
! 5659: for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) {
! 5660: mem_base = xmlMemBlocks();
! 5661: catal = gen_xmlCatalogPtr(n_catal, 0);
! 5662: out = gen_FILE_ptr(n_out, 1);
! 5663:
! 5664: xmlACatalogDump(catal, out);
! 5665: call_tests++;
! 5666: des_xmlCatalogPtr(n_catal, catal, 0);
! 5667: des_FILE_ptr(n_out, out, 1);
! 5668: xmlResetLastError();
! 5669: if (mem_base != xmlMemBlocks()) {
! 5670: printf("Leak of %d blocks found in xmlACatalogDump",
! 5671: xmlMemBlocks() - mem_base);
! 5672: test_ret++;
! 5673: printf(" %d", n_catal);
! 5674: printf(" %d", n_out);
! 5675: printf("\n");
! 5676: }
! 5677: }
! 5678: }
! 5679: function_tests++;
! 5680: #endif
! 5681:
! 5682: return(test_ret);
! 5683: }
! 5684:
! 5685:
! 5686: static int
! 5687: test_xmlACatalogRemove(void) {
! 5688: int test_ret = 0;
! 5689:
! 5690: #if defined(LIBXML_CATALOG_ENABLED)
! 5691: int mem_base;
! 5692: int ret_val;
! 5693: xmlCatalogPtr catal; /* a Catalog */
! 5694: int n_catal;
! 5695: xmlChar * value; /* the value to remove */
! 5696: int n_value;
! 5697:
! 5698: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
! 5699: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 5700: mem_base = xmlMemBlocks();
! 5701: catal = gen_xmlCatalogPtr(n_catal, 0);
! 5702: value = gen_const_xmlChar_ptr(n_value, 1);
! 5703:
! 5704: ret_val = xmlACatalogRemove(catal, (const xmlChar *)value);
! 5705: desret_int(ret_val);
! 5706: call_tests++;
! 5707: des_xmlCatalogPtr(n_catal, catal, 0);
! 5708: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
! 5709: xmlResetLastError();
! 5710: if (mem_base != xmlMemBlocks()) {
! 5711: printf("Leak of %d blocks found in xmlACatalogRemove",
! 5712: xmlMemBlocks() - mem_base);
! 5713: test_ret++;
! 5714: printf(" %d", n_catal);
! 5715: printf(" %d", n_value);
! 5716: printf("\n");
! 5717: }
! 5718: }
! 5719: }
! 5720: function_tests++;
! 5721: #endif
! 5722:
! 5723: return(test_ret);
! 5724: }
! 5725:
! 5726:
! 5727: static int
! 5728: test_xmlACatalogResolve(void) {
! 5729: int test_ret = 0;
! 5730:
! 5731: #if defined(LIBXML_CATALOG_ENABLED)
! 5732: int mem_base;
! 5733: xmlChar * ret_val;
! 5734: xmlCatalogPtr catal; /* a Catalog */
! 5735: int n_catal;
! 5736: xmlChar * pubID; /* the public ID string */
! 5737: int n_pubID;
! 5738: xmlChar * sysID; /* the system ID string */
! 5739: int n_sysID;
! 5740:
! 5741: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
! 5742: for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
! 5743: for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
! 5744: mem_base = xmlMemBlocks();
! 5745: catal = gen_xmlCatalogPtr(n_catal, 0);
! 5746: pubID = gen_const_xmlChar_ptr(n_pubID, 1);
! 5747: sysID = gen_const_xmlChar_ptr(n_sysID, 2);
! 5748:
! 5749: ret_val = xmlACatalogResolve(catal, (const xmlChar *)pubID, (const xmlChar *)sysID);
! 5750: desret_xmlChar_ptr(ret_val);
! 5751: call_tests++;
! 5752: des_xmlCatalogPtr(n_catal, catal, 0);
! 5753: des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 1);
! 5754: des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 2);
! 5755: xmlResetLastError();
! 5756: if (mem_base != xmlMemBlocks()) {
! 5757: printf("Leak of %d blocks found in xmlACatalogResolve",
! 5758: xmlMemBlocks() - mem_base);
! 5759: test_ret++;
! 5760: printf(" %d", n_catal);
! 5761: printf(" %d", n_pubID);
! 5762: printf(" %d", n_sysID);
! 5763: printf("\n");
! 5764: }
! 5765: }
! 5766: }
! 5767: }
! 5768: function_tests++;
! 5769: #endif
! 5770:
! 5771: return(test_ret);
! 5772: }
! 5773:
! 5774:
! 5775: static int
! 5776: test_xmlACatalogResolvePublic(void) {
! 5777: int test_ret = 0;
! 5778:
! 5779: #if defined(LIBXML_CATALOG_ENABLED)
! 5780: int mem_base;
! 5781: xmlChar * ret_val;
! 5782: xmlCatalogPtr catal; /* a Catalog */
! 5783: int n_catal;
! 5784: xmlChar * pubID; /* the public ID string */
! 5785: int n_pubID;
! 5786:
! 5787: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
! 5788: for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
! 5789: mem_base = xmlMemBlocks();
! 5790: catal = gen_xmlCatalogPtr(n_catal, 0);
! 5791: pubID = gen_const_xmlChar_ptr(n_pubID, 1);
! 5792:
! 5793: ret_val = xmlACatalogResolvePublic(catal, (const xmlChar *)pubID);
! 5794: desret_xmlChar_ptr(ret_val);
! 5795: call_tests++;
! 5796: des_xmlCatalogPtr(n_catal, catal, 0);
! 5797: des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 1);
! 5798: xmlResetLastError();
! 5799: if (mem_base != xmlMemBlocks()) {
! 5800: printf("Leak of %d blocks found in xmlACatalogResolvePublic",
! 5801: xmlMemBlocks() - mem_base);
! 5802: test_ret++;
! 5803: printf(" %d", n_catal);
! 5804: printf(" %d", n_pubID);
! 5805: printf("\n");
! 5806: }
! 5807: }
! 5808: }
! 5809: function_tests++;
! 5810: #endif
! 5811:
! 5812: return(test_ret);
! 5813: }
! 5814:
! 5815:
! 5816: static int
! 5817: test_xmlACatalogResolveSystem(void) {
! 5818: int test_ret = 0;
! 5819:
! 5820: #if defined(LIBXML_CATALOG_ENABLED)
! 5821: int mem_base;
! 5822: xmlChar * ret_val;
! 5823: xmlCatalogPtr catal; /* a Catalog */
! 5824: int n_catal;
! 5825: xmlChar * sysID; /* the system ID string */
! 5826: int n_sysID;
! 5827:
! 5828: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
! 5829: for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
! 5830: mem_base = xmlMemBlocks();
! 5831: catal = gen_xmlCatalogPtr(n_catal, 0);
! 5832: sysID = gen_const_xmlChar_ptr(n_sysID, 1);
! 5833:
! 5834: ret_val = xmlACatalogResolveSystem(catal, (const xmlChar *)sysID);
! 5835: desret_xmlChar_ptr(ret_val);
! 5836: call_tests++;
! 5837: des_xmlCatalogPtr(n_catal, catal, 0);
! 5838: des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 1);
! 5839: xmlResetLastError();
! 5840: if (mem_base != xmlMemBlocks()) {
! 5841: printf("Leak of %d blocks found in xmlACatalogResolveSystem",
! 5842: xmlMemBlocks() - mem_base);
! 5843: test_ret++;
! 5844: printf(" %d", n_catal);
! 5845: printf(" %d", n_sysID);
! 5846: printf("\n");
! 5847: }
! 5848: }
! 5849: }
! 5850: function_tests++;
! 5851: #endif
! 5852:
! 5853: return(test_ret);
! 5854: }
! 5855:
! 5856:
! 5857: static int
! 5858: test_xmlACatalogResolveURI(void) {
! 5859: int test_ret = 0;
! 5860:
! 5861: #if defined(LIBXML_CATALOG_ENABLED)
! 5862: int mem_base;
! 5863: xmlChar * ret_val;
! 5864: xmlCatalogPtr catal; /* a Catalog */
! 5865: int n_catal;
! 5866: xmlChar * URI; /* the URI */
! 5867: int n_URI;
! 5868:
! 5869: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
! 5870: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
! 5871: mem_base = xmlMemBlocks();
! 5872: catal = gen_xmlCatalogPtr(n_catal, 0);
! 5873: URI = gen_const_xmlChar_ptr(n_URI, 1);
! 5874:
! 5875: ret_val = xmlACatalogResolveURI(catal, (const xmlChar *)URI);
! 5876: desret_xmlChar_ptr(ret_val);
! 5877: call_tests++;
! 5878: des_xmlCatalogPtr(n_catal, catal, 0);
! 5879: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 1);
! 5880: xmlResetLastError();
! 5881: if (mem_base != xmlMemBlocks()) {
! 5882: printf("Leak of %d blocks found in xmlACatalogResolveURI",
! 5883: xmlMemBlocks() - mem_base);
! 5884: test_ret++;
! 5885: printf(" %d", n_catal);
! 5886: printf(" %d", n_URI);
! 5887: printf("\n");
! 5888: }
! 5889: }
! 5890: }
! 5891: function_tests++;
! 5892: #endif
! 5893:
! 5894: return(test_ret);
! 5895: }
! 5896:
! 5897:
! 5898: static int
! 5899: test_xmlCatalogAdd(void) {
! 5900: int test_ret = 0;
! 5901:
! 5902: #if defined(LIBXML_CATALOG_ENABLED)
! 5903: int mem_base;
! 5904: int ret_val;
! 5905: xmlChar * type; /* the type of record to add to the catalog */
! 5906: int n_type;
! 5907: xmlChar * orig; /* the system, public or prefix to match */
! 5908: int n_orig;
! 5909: xmlChar * replace; /* the replacement value for the match */
! 5910: int n_replace;
! 5911:
! 5912: for (n_type = 0;n_type < gen_nb_const_xmlChar_ptr;n_type++) {
! 5913: for (n_orig = 0;n_orig < gen_nb_const_xmlChar_ptr;n_orig++) {
! 5914: for (n_replace = 0;n_replace < gen_nb_const_xmlChar_ptr;n_replace++) {
! 5915: mem_base = xmlMemBlocks();
! 5916: type = gen_const_xmlChar_ptr(n_type, 0);
! 5917: orig = gen_const_xmlChar_ptr(n_orig, 1);
! 5918: replace = gen_const_xmlChar_ptr(n_replace, 2);
! 5919:
! 5920: ret_val = xmlCatalogAdd((const xmlChar *)type, (const xmlChar *)orig, (const xmlChar *)replace);
! 5921: desret_int(ret_val);
! 5922: call_tests++;
! 5923: des_const_xmlChar_ptr(n_type, (const xmlChar *)type, 0);
! 5924: des_const_xmlChar_ptr(n_orig, (const xmlChar *)orig, 1);
! 5925: des_const_xmlChar_ptr(n_replace, (const xmlChar *)replace, 2);
! 5926: xmlResetLastError();
! 5927: if (mem_base != xmlMemBlocks()) {
! 5928: printf("Leak of %d blocks found in xmlCatalogAdd",
! 5929: xmlMemBlocks() - mem_base);
! 5930: test_ret++;
! 5931: printf(" %d", n_type);
! 5932: printf(" %d", n_orig);
! 5933: printf(" %d", n_replace);
! 5934: printf("\n");
! 5935: }
! 5936: }
! 5937: }
! 5938: }
! 5939: function_tests++;
! 5940: #endif
! 5941:
! 5942: return(test_ret);
! 5943: }
! 5944:
! 5945:
! 5946: static int
! 5947: test_xmlCatalogCleanup(void) {
! 5948: int test_ret = 0;
! 5949:
! 5950: #if defined(LIBXML_CATALOG_ENABLED)
! 5951:
! 5952:
! 5953: xmlCatalogCleanup();
! 5954: call_tests++;
! 5955: xmlResetLastError();
! 5956: function_tests++;
! 5957: #endif
! 5958:
! 5959: return(test_ret);
! 5960: }
! 5961:
! 5962:
! 5963: static int
! 5964: test_xmlCatalogConvert(void) {
! 5965: int test_ret = 0;
! 5966:
! 5967: #if defined(LIBXML_CATALOG_ENABLED)
! 5968: int ret_val;
! 5969:
! 5970:
! 5971: ret_val = xmlCatalogConvert();
! 5972: desret_int(ret_val);
! 5973: call_tests++;
! 5974: xmlResetLastError();
! 5975: function_tests++;
! 5976: #endif
! 5977:
! 5978: return(test_ret);
! 5979: }
! 5980:
! 5981:
! 5982: static int
! 5983: test_xmlCatalogDump(void) {
! 5984: int test_ret = 0;
! 5985:
! 5986: #if defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 5987: int mem_base;
! 5988: FILE * out; /* the file. */
! 5989: int n_out;
! 5990:
! 5991: for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) {
! 5992: mem_base = xmlMemBlocks();
! 5993: out = gen_FILE_ptr(n_out, 0);
! 5994:
! 5995: xmlCatalogDump(out);
! 5996: call_tests++;
! 5997: des_FILE_ptr(n_out, out, 0);
! 5998: xmlResetLastError();
! 5999: if (mem_base != xmlMemBlocks()) {
! 6000: printf("Leak of %d blocks found in xmlCatalogDump",
! 6001: xmlMemBlocks() - mem_base);
! 6002: test_ret++;
! 6003: printf(" %d", n_out);
! 6004: printf("\n");
! 6005: }
! 6006: }
! 6007: function_tests++;
! 6008: #endif
! 6009:
! 6010: return(test_ret);
! 6011: }
! 6012:
! 6013:
! 6014: static int
! 6015: test_xmlCatalogGetDefaults(void) {
! 6016: int test_ret = 0;
! 6017:
! 6018: #if defined(LIBXML_CATALOG_ENABLED)
! 6019: int mem_base;
! 6020: xmlCatalogAllow ret_val;
! 6021:
! 6022: mem_base = xmlMemBlocks();
! 6023:
! 6024: ret_val = xmlCatalogGetDefaults();
! 6025: desret_xmlCatalogAllow(ret_val);
! 6026: call_tests++;
! 6027: xmlResetLastError();
! 6028: if (mem_base != xmlMemBlocks()) {
! 6029: printf("Leak of %d blocks found in xmlCatalogGetDefaults",
! 6030: xmlMemBlocks() - mem_base);
! 6031: test_ret++;
! 6032: printf("\n");
! 6033: }
! 6034: function_tests++;
! 6035: #endif
! 6036:
! 6037: return(test_ret);
! 6038: }
! 6039:
! 6040:
! 6041: static int
! 6042: test_xmlCatalogIsEmpty(void) {
! 6043: int test_ret = 0;
! 6044:
! 6045: #if defined(LIBXML_CATALOG_ENABLED)
! 6046: int mem_base;
! 6047: int ret_val;
! 6048: xmlCatalogPtr catal; /* should this create an SGML catalog */
! 6049: int n_catal;
! 6050:
! 6051: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
! 6052: mem_base = xmlMemBlocks();
! 6053: catal = gen_xmlCatalogPtr(n_catal, 0);
! 6054:
! 6055: ret_val = xmlCatalogIsEmpty(catal);
! 6056: desret_int(ret_val);
! 6057: call_tests++;
! 6058: des_xmlCatalogPtr(n_catal, catal, 0);
! 6059: xmlResetLastError();
! 6060: if (mem_base != xmlMemBlocks()) {
! 6061: printf("Leak of %d blocks found in xmlCatalogIsEmpty",
! 6062: xmlMemBlocks() - mem_base);
! 6063: test_ret++;
! 6064: printf(" %d", n_catal);
! 6065: printf("\n");
! 6066: }
! 6067: }
! 6068: function_tests++;
! 6069: #endif
! 6070:
! 6071: return(test_ret);
! 6072: }
! 6073:
! 6074:
! 6075: static int
! 6076: test_xmlCatalogLocalResolve(void) {
! 6077: int test_ret = 0;
! 6078:
! 6079: #if defined(LIBXML_CATALOG_ENABLED)
! 6080: int mem_base;
! 6081: xmlChar * ret_val;
! 6082: void * catalogs; /* a document's list of catalogs */
! 6083: int n_catalogs;
! 6084: xmlChar * pubID; /* the public ID string */
! 6085: int n_pubID;
! 6086: xmlChar * sysID; /* the system ID string */
! 6087: int n_sysID;
! 6088:
! 6089: for (n_catalogs = 0;n_catalogs < gen_nb_void_ptr;n_catalogs++) {
! 6090: for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
! 6091: for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
! 6092: mem_base = xmlMemBlocks();
! 6093: catalogs = gen_void_ptr(n_catalogs, 0);
! 6094: pubID = gen_const_xmlChar_ptr(n_pubID, 1);
! 6095: sysID = gen_const_xmlChar_ptr(n_sysID, 2);
! 6096:
! 6097: ret_val = xmlCatalogLocalResolve(catalogs, (const xmlChar *)pubID, (const xmlChar *)sysID);
! 6098: desret_xmlChar_ptr(ret_val);
! 6099: call_tests++;
! 6100: des_void_ptr(n_catalogs, catalogs, 0);
! 6101: des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 1);
! 6102: des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 2);
! 6103: xmlResetLastError();
! 6104: if (mem_base != xmlMemBlocks()) {
! 6105: printf("Leak of %d blocks found in xmlCatalogLocalResolve",
! 6106: xmlMemBlocks() - mem_base);
! 6107: test_ret++;
! 6108: printf(" %d", n_catalogs);
! 6109: printf(" %d", n_pubID);
! 6110: printf(" %d", n_sysID);
! 6111: printf("\n");
! 6112: }
! 6113: }
! 6114: }
! 6115: }
! 6116: function_tests++;
! 6117: #endif
! 6118:
! 6119: return(test_ret);
! 6120: }
! 6121:
! 6122:
! 6123: static int
! 6124: test_xmlCatalogLocalResolveURI(void) {
! 6125: int test_ret = 0;
! 6126:
! 6127: #if defined(LIBXML_CATALOG_ENABLED)
! 6128: int mem_base;
! 6129: xmlChar * ret_val;
! 6130: void * catalogs; /* a document's list of catalogs */
! 6131: int n_catalogs;
! 6132: xmlChar * URI; /* the URI */
! 6133: int n_URI;
! 6134:
! 6135: for (n_catalogs = 0;n_catalogs < gen_nb_void_ptr;n_catalogs++) {
! 6136: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
! 6137: mem_base = xmlMemBlocks();
! 6138: catalogs = gen_void_ptr(n_catalogs, 0);
! 6139: URI = gen_const_xmlChar_ptr(n_URI, 1);
! 6140:
! 6141: ret_val = xmlCatalogLocalResolveURI(catalogs, (const xmlChar *)URI);
! 6142: desret_xmlChar_ptr(ret_val);
! 6143: call_tests++;
! 6144: des_void_ptr(n_catalogs, catalogs, 0);
! 6145: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 1);
! 6146: xmlResetLastError();
! 6147: if (mem_base != xmlMemBlocks()) {
! 6148: printf("Leak of %d blocks found in xmlCatalogLocalResolveURI",
! 6149: xmlMemBlocks() - mem_base);
! 6150: test_ret++;
! 6151: printf(" %d", n_catalogs);
! 6152: printf(" %d", n_URI);
! 6153: printf("\n");
! 6154: }
! 6155: }
! 6156: }
! 6157: function_tests++;
! 6158: #endif
! 6159:
! 6160: return(test_ret);
! 6161: }
! 6162:
! 6163:
! 6164: static int
! 6165: test_xmlCatalogRemove(void) {
! 6166: int test_ret = 0;
! 6167:
! 6168: #if defined(LIBXML_CATALOG_ENABLED)
! 6169: int ret_val;
! 6170: xmlChar * value; /* the value to remove */
! 6171: int n_value;
! 6172:
! 6173: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 6174: value = gen_const_xmlChar_ptr(n_value, 0);
! 6175:
! 6176: ret_val = xmlCatalogRemove((const xmlChar *)value);
! 6177: desret_int(ret_val);
! 6178: call_tests++;
! 6179: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
! 6180: xmlResetLastError();
! 6181: }
! 6182: function_tests++;
! 6183: #endif
! 6184:
! 6185: return(test_ret);
! 6186: }
! 6187:
! 6188:
! 6189: static int
! 6190: test_xmlCatalogResolve(void) {
! 6191: int test_ret = 0;
! 6192:
! 6193: #if defined(LIBXML_CATALOG_ENABLED)
! 6194: xmlChar * ret_val;
! 6195: xmlChar * pubID; /* the public ID string */
! 6196: int n_pubID;
! 6197: xmlChar * sysID; /* the system ID string */
! 6198: int n_sysID;
! 6199:
! 6200: for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
! 6201: for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
! 6202: pubID = gen_const_xmlChar_ptr(n_pubID, 0);
! 6203: sysID = gen_const_xmlChar_ptr(n_sysID, 1);
! 6204:
! 6205: ret_val = xmlCatalogResolve((const xmlChar *)pubID, (const xmlChar *)sysID);
! 6206: desret_xmlChar_ptr(ret_val);
! 6207: call_tests++;
! 6208: des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 0);
! 6209: des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 1);
! 6210: xmlResetLastError();
! 6211: }
! 6212: }
! 6213: function_tests++;
! 6214: #endif
! 6215:
! 6216: return(test_ret);
! 6217: }
! 6218:
! 6219:
! 6220: static int
! 6221: test_xmlCatalogResolvePublic(void) {
! 6222: int test_ret = 0;
! 6223:
! 6224: #if defined(LIBXML_CATALOG_ENABLED)
! 6225: int mem_base;
! 6226: xmlChar * ret_val;
! 6227: xmlChar * pubID; /* the public ID string */
! 6228: int n_pubID;
! 6229:
! 6230: for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
! 6231: mem_base = xmlMemBlocks();
! 6232: pubID = gen_const_xmlChar_ptr(n_pubID, 0);
! 6233:
! 6234: ret_val = xmlCatalogResolvePublic((const xmlChar *)pubID);
! 6235: desret_xmlChar_ptr(ret_val);
! 6236: call_tests++;
! 6237: des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 0);
! 6238: xmlResetLastError();
! 6239: if (mem_base != xmlMemBlocks()) {
! 6240: printf("Leak of %d blocks found in xmlCatalogResolvePublic",
! 6241: xmlMemBlocks() - mem_base);
! 6242: test_ret++;
! 6243: printf(" %d", n_pubID);
! 6244: printf("\n");
! 6245: }
! 6246: }
! 6247: function_tests++;
! 6248: #endif
! 6249:
! 6250: return(test_ret);
! 6251: }
! 6252:
! 6253:
! 6254: static int
! 6255: test_xmlCatalogResolveSystem(void) {
! 6256: int test_ret = 0;
! 6257:
! 6258: #if defined(LIBXML_CATALOG_ENABLED)
! 6259: int mem_base;
! 6260: xmlChar * ret_val;
! 6261: xmlChar * sysID; /* the system ID string */
! 6262: int n_sysID;
! 6263:
! 6264: for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
! 6265: mem_base = xmlMemBlocks();
! 6266: sysID = gen_const_xmlChar_ptr(n_sysID, 0);
! 6267:
! 6268: ret_val = xmlCatalogResolveSystem((const xmlChar *)sysID);
! 6269: desret_xmlChar_ptr(ret_val);
! 6270: call_tests++;
! 6271: des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 0);
! 6272: xmlResetLastError();
! 6273: if (mem_base != xmlMemBlocks()) {
! 6274: printf("Leak of %d blocks found in xmlCatalogResolveSystem",
! 6275: xmlMemBlocks() - mem_base);
! 6276: test_ret++;
! 6277: printf(" %d", n_sysID);
! 6278: printf("\n");
! 6279: }
! 6280: }
! 6281: function_tests++;
! 6282: #endif
! 6283:
! 6284: return(test_ret);
! 6285: }
! 6286:
! 6287:
! 6288: static int
! 6289: test_xmlCatalogResolveURI(void) {
! 6290: int test_ret = 0;
! 6291:
! 6292: #if defined(LIBXML_CATALOG_ENABLED)
! 6293: int mem_base;
! 6294: xmlChar * ret_val;
! 6295: xmlChar * URI; /* the URI */
! 6296: int n_URI;
! 6297:
! 6298: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
! 6299: mem_base = xmlMemBlocks();
! 6300: URI = gen_const_xmlChar_ptr(n_URI, 0);
! 6301:
! 6302: ret_val = xmlCatalogResolveURI((const xmlChar *)URI);
! 6303: desret_xmlChar_ptr(ret_val);
! 6304: call_tests++;
! 6305: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
! 6306: xmlResetLastError();
! 6307: if (mem_base != xmlMemBlocks()) {
! 6308: printf("Leak of %d blocks found in xmlCatalogResolveURI",
! 6309: xmlMemBlocks() - mem_base);
! 6310: test_ret++;
! 6311: printf(" %d", n_URI);
! 6312: printf("\n");
! 6313: }
! 6314: }
! 6315: function_tests++;
! 6316: #endif
! 6317:
! 6318: return(test_ret);
! 6319: }
! 6320:
! 6321:
! 6322: static int
! 6323: test_xmlCatalogSetDefaultPrefer(void) {
! 6324: int test_ret = 0;
! 6325:
! 6326: #if defined(LIBXML_CATALOG_ENABLED)
! 6327: int mem_base;
! 6328: xmlCatalogPrefer ret_val;
! 6329: xmlCatalogPrefer prefer; /* the default preference for delegation */
! 6330: int n_prefer;
! 6331:
! 6332: for (n_prefer = 0;n_prefer < gen_nb_xmlCatalogPrefer;n_prefer++) {
! 6333: mem_base = xmlMemBlocks();
! 6334: prefer = gen_xmlCatalogPrefer(n_prefer, 0);
! 6335:
! 6336: ret_val = xmlCatalogSetDefaultPrefer(prefer);
! 6337: desret_xmlCatalogPrefer(ret_val);
! 6338: call_tests++;
! 6339: des_xmlCatalogPrefer(n_prefer, prefer, 0);
! 6340: xmlResetLastError();
! 6341: if (mem_base != xmlMemBlocks()) {
! 6342: printf("Leak of %d blocks found in xmlCatalogSetDefaultPrefer",
! 6343: xmlMemBlocks() - mem_base);
! 6344: test_ret++;
! 6345: printf(" %d", n_prefer);
! 6346: printf("\n");
! 6347: }
! 6348: }
! 6349: function_tests++;
! 6350: #endif
! 6351:
! 6352: return(test_ret);
! 6353: }
! 6354:
! 6355:
! 6356: static int
! 6357: test_xmlCatalogSetDefaults(void) {
! 6358: int test_ret = 0;
! 6359:
! 6360: #if defined(LIBXML_CATALOG_ENABLED)
! 6361: int mem_base;
! 6362: xmlCatalogAllow allow; /* what catalogs should be accepted */
! 6363: int n_allow;
! 6364:
! 6365: for (n_allow = 0;n_allow < gen_nb_xmlCatalogAllow;n_allow++) {
! 6366: mem_base = xmlMemBlocks();
! 6367: allow = gen_xmlCatalogAllow(n_allow, 0);
! 6368:
! 6369: xmlCatalogSetDefaults(allow);
! 6370: call_tests++;
! 6371: des_xmlCatalogAllow(n_allow, allow, 0);
! 6372: xmlResetLastError();
! 6373: if (mem_base != xmlMemBlocks()) {
! 6374: printf("Leak of %d blocks found in xmlCatalogSetDefaults",
! 6375: xmlMemBlocks() - mem_base);
! 6376: test_ret++;
! 6377: printf(" %d", n_allow);
! 6378: printf("\n");
! 6379: }
! 6380: }
! 6381: function_tests++;
! 6382: #endif
! 6383:
! 6384: return(test_ret);
! 6385: }
! 6386:
! 6387:
! 6388: static int
! 6389: test_xmlConvertSGMLCatalog(void) {
! 6390: int test_ret = 0;
! 6391:
! 6392: #if defined(LIBXML_CATALOG_ENABLED)
! 6393: int mem_base;
! 6394: int ret_val;
! 6395: xmlCatalogPtr catal; /* the catalog */
! 6396: int n_catal;
! 6397:
! 6398: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
! 6399: mem_base = xmlMemBlocks();
! 6400: catal = gen_xmlCatalogPtr(n_catal, 0);
! 6401:
! 6402: ret_val = xmlConvertSGMLCatalog(catal);
! 6403: desret_int(ret_val);
! 6404: call_tests++;
! 6405: des_xmlCatalogPtr(n_catal, catal, 0);
! 6406: xmlResetLastError();
! 6407: if (mem_base != xmlMemBlocks()) {
! 6408: printf("Leak of %d blocks found in xmlConvertSGMLCatalog",
! 6409: xmlMemBlocks() - mem_base);
! 6410: test_ret++;
! 6411: printf(" %d", n_catal);
! 6412: printf("\n");
! 6413: }
! 6414: }
! 6415: function_tests++;
! 6416: #endif
! 6417:
! 6418: return(test_ret);
! 6419: }
! 6420:
! 6421:
! 6422: static int
! 6423: test_xmlInitializeCatalog(void) {
! 6424: int test_ret = 0;
! 6425:
! 6426: #if defined(LIBXML_CATALOG_ENABLED)
! 6427: int mem_base;
! 6428:
! 6429: mem_base = xmlMemBlocks();
! 6430:
! 6431: xmlInitializeCatalog();
! 6432: call_tests++;
! 6433: xmlResetLastError();
! 6434: if (mem_base != xmlMemBlocks()) {
! 6435: printf("Leak of %d blocks found in xmlInitializeCatalog",
! 6436: xmlMemBlocks() - mem_base);
! 6437: test_ret++;
! 6438: printf("\n");
! 6439: }
! 6440: function_tests++;
! 6441: #endif
! 6442:
! 6443: return(test_ret);
! 6444: }
! 6445:
! 6446:
! 6447: static int
! 6448: test_xmlLoadACatalog(void) {
! 6449: int test_ret = 0;
! 6450:
! 6451:
! 6452: /* missing type support */
! 6453: return(test_ret);
! 6454: }
! 6455:
! 6456:
! 6457: static int
! 6458: test_xmlLoadCatalog(void) {
! 6459: int test_ret = 0;
! 6460:
! 6461: #if defined(LIBXML_CATALOG_ENABLED)
! 6462: int ret_val;
! 6463: const char * filename; /* a file path */
! 6464: int n_filename;
! 6465:
! 6466: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 6467: filename = gen_filepath(n_filename, 0);
! 6468:
! 6469: ret_val = xmlLoadCatalog(filename);
! 6470: desret_int(ret_val);
! 6471: call_tests++;
! 6472: des_filepath(n_filename, filename, 0);
! 6473: xmlResetLastError();
! 6474: }
! 6475: function_tests++;
! 6476: #endif
! 6477:
! 6478: return(test_ret);
! 6479: }
! 6480:
! 6481:
! 6482: static int
! 6483: test_xmlLoadCatalogs(void) {
! 6484: int test_ret = 0;
! 6485:
! 6486: #if defined(LIBXML_CATALOG_ENABLED)
! 6487: char * pathss; /* a list of directories separated by a colon or a space. */
! 6488: int n_pathss;
! 6489:
! 6490: for (n_pathss = 0;n_pathss < gen_nb_const_char_ptr;n_pathss++) {
! 6491: pathss = gen_const_char_ptr(n_pathss, 0);
! 6492:
! 6493: xmlLoadCatalogs((const char *)pathss);
! 6494: call_tests++;
! 6495: des_const_char_ptr(n_pathss, (const char *)pathss, 0);
! 6496: xmlResetLastError();
! 6497: }
! 6498: function_tests++;
! 6499: #endif
! 6500:
! 6501: return(test_ret);
! 6502: }
! 6503:
! 6504:
! 6505: static int
! 6506: test_xmlLoadSGMLSuperCatalog(void) {
! 6507: int test_ret = 0;
! 6508:
! 6509:
! 6510: /* missing type support */
! 6511: return(test_ret);
! 6512: }
! 6513:
! 6514:
! 6515: static int
! 6516: test_xmlNewCatalog(void) {
! 6517: int test_ret = 0;
! 6518:
! 6519:
! 6520: /* missing type support */
! 6521: return(test_ret);
! 6522: }
! 6523:
! 6524:
! 6525: static int
! 6526: test_xmlParseCatalogFile(void) {
! 6527: int test_ret = 0;
! 6528:
! 6529: #if defined(LIBXML_CATALOG_ENABLED)
! 6530: int mem_base;
! 6531: xmlDocPtr ret_val;
! 6532: const char * filename; /* the filename */
! 6533: int n_filename;
! 6534:
! 6535: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 6536: mem_base = xmlMemBlocks();
! 6537: filename = gen_filepath(n_filename, 0);
! 6538:
! 6539: ret_val = xmlParseCatalogFile(filename);
! 6540: desret_xmlDocPtr(ret_val);
! 6541: call_tests++;
! 6542: des_filepath(n_filename, filename, 0);
! 6543: xmlResetLastError();
! 6544: if (mem_base != xmlMemBlocks()) {
! 6545: printf("Leak of %d blocks found in xmlParseCatalogFile",
! 6546: xmlMemBlocks() - mem_base);
! 6547: test_ret++;
! 6548: printf(" %d", n_filename);
! 6549: printf("\n");
! 6550: }
! 6551: }
! 6552: function_tests++;
! 6553: #endif
! 6554:
! 6555: return(test_ret);
! 6556: }
! 6557:
! 6558: static int
! 6559: test_catalog(void) {
! 6560: int test_ret = 0;
! 6561:
! 6562: if (quiet == 0) printf("Testing catalog : 27 of 36 functions ...\n");
! 6563: test_ret += test_xmlACatalogAdd();
! 6564: test_ret += test_xmlACatalogDump();
! 6565: test_ret += test_xmlACatalogRemove();
! 6566: test_ret += test_xmlACatalogResolve();
! 6567: test_ret += test_xmlACatalogResolvePublic();
! 6568: test_ret += test_xmlACatalogResolveSystem();
! 6569: test_ret += test_xmlACatalogResolveURI();
! 6570: test_ret += test_xmlCatalogAdd();
! 6571: test_ret += test_xmlCatalogCleanup();
! 6572: test_ret += test_xmlCatalogConvert();
! 6573: test_ret += test_xmlCatalogDump();
! 6574: test_ret += test_xmlCatalogGetDefaults();
! 6575: test_ret += test_xmlCatalogIsEmpty();
! 6576: test_ret += test_xmlCatalogLocalResolve();
! 6577: test_ret += test_xmlCatalogLocalResolveURI();
! 6578: test_ret += test_xmlCatalogRemove();
! 6579: test_ret += test_xmlCatalogResolve();
! 6580: test_ret += test_xmlCatalogResolvePublic();
! 6581: test_ret += test_xmlCatalogResolveSystem();
! 6582: test_ret += test_xmlCatalogResolveURI();
! 6583: test_ret += test_xmlCatalogSetDefaultPrefer();
! 6584: test_ret += test_xmlCatalogSetDefaults();
! 6585: test_ret += test_xmlConvertSGMLCatalog();
! 6586: test_ret += test_xmlInitializeCatalog();
! 6587: test_ret += test_xmlLoadACatalog();
! 6588: test_ret += test_xmlLoadCatalog();
! 6589: test_ret += test_xmlLoadCatalogs();
! 6590: test_ret += test_xmlLoadSGMLSuperCatalog();
! 6591: test_ret += test_xmlNewCatalog();
! 6592: test_ret += test_xmlParseCatalogFile();
! 6593:
! 6594: if (test_ret != 0)
! 6595: printf("Module catalog: %d errors\n", test_ret);
! 6596: return(test_ret);
! 6597: }
! 6598:
! 6599: #define gen_nb_const_xmlChRangeGroup_ptr 1
! 6600: static xmlChRangeGroup * gen_const_xmlChRangeGroup_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 6601: return(NULL);
! 6602: }
! 6603: static void des_const_xmlChRangeGroup_ptr(int no ATTRIBUTE_UNUSED, const xmlChRangeGroup * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 6604: }
! 6605:
! 6606: static int
! 6607: test_xmlCharInRange(void) {
! 6608: int test_ret = 0;
! 6609:
! 6610: int mem_base;
! 6611: int ret_val;
! 6612: unsigned int val; /* character to be validated */
! 6613: int n_val;
! 6614: xmlChRangeGroup * rptr; /* pointer to range to be used to validate */
! 6615: int n_rptr;
! 6616:
! 6617: for (n_val = 0;n_val < gen_nb_unsigned_int;n_val++) {
! 6618: for (n_rptr = 0;n_rptr < gen_nb_const_xmlChRangeGroup_ptr;n_rptr++) {
! 6619: mem_base = xmlMemBlocks();
! 6620: val = gen_unsigned_int(n_val, 0);
! 6621: rptr = gen_const_xmlChRangeGroup_ptr(n_rptr, 1);
! 6622:
! 6623: ret_val = xmlCharInRange(val, (const xmlChRangeGroup *)rptr);
! 6624: desret_int(ret_val);
! 6625: call_tests++;
! 6626: des_unsigned_int(n_val, val, 0);
! 6627: des_const_xmlChRangeGroup_ptr(n_rptr, (const xmlChRangeGroup *)rptr, 1);
! 6628: xmlResetLastError();
! 6629: if (mem_base != xmlMemBlocks()) {
! 6630: printf("Leak of %d blocks found in xmlCharInRange",
! 6631: xmlMemBlocks() - mem_base);
! 6632: test_ret++;
! 6633: printf(" %d", n_val);
! 6634: printf(" %d", n_rptr);
! 6635: printf("\n");
! 6636: }
! 6637: }
! 6638: }
! 6639: function_tests++;
! 6640:
! 6641: return(test_ret);
! 6642: }
! 6643:
! 6644:
! 6645: static int
! 6646: test_xmlIsBaseChar(void) {
! 6647: int test_ret = 0;
! 6648:
! 6649: int mem_base;
! 6650: int ret_val;
! 6651: unsigned int ch; /* character to validate */
! 6652: int n_ch;
! 6653:
! 6654: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
! 6655: mem_base = xmlMemBlocks();
! 6656: ch = gen_unsigned_int(n_ch, 0);
! 6657:
! 6658: ret_val = xmlIsBaseChar(ch);
! 6659: desret_int(ret_val);
! 6660: call_tests++;
! 6661: des_unsigned_int(n_ch, ch, 0);
! 6662: xmlResetLastError();
! 6663: if (mem_base != xmlMemBlocks()) {
! 6664: printf("Leak of %d blocks found in xmlIsBaseChar",
! 6665: xmlMemBlocks() - mem_base);
! 6666: test_ret++;
! 6667: printf(" %d", n_ch);
! 6668: printf("\n");
! 6669: }
! 6670: }
! 6671: function_tests++;
! 6672:
! 6673: return(test_ret);
! 6674: }
! 6675:
! 6676:
! 6677: static int
! 6678: test_xmlIsBlank(void) {
! 6679: int test_ret = 0;
! 6680:
! 6681: int mem_base;
! 6682: int ret_val;
! 6683: unsigned int ch; /* character to validate */
! 6684: int n_ch;
! 6685:
! 6686: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
! 6687: mem_base = xmlMemBlocks();
! 6688: ch = gen_unsigned_int(n_ch, 0);
! 6689:
! 6690: ret_val = xmlIsBlank(ch);
! 6691: desret_int(ret_val);
! 6692: call_tests++;
! 6693: des_unsigned_int(n_ch, ch, 0);
! 6694: xmlResetLastError();
! 6695: if (mem_base != xmlMemBlocks()) {
! 6696: printf("Leak of %d blocks found in xmlIsBlank",
! 6697: xmlMemBlocks() - mem_base);
! 6698: test_ret++;
! 6699: printf(" %d", n_ch);
! 6700: printf("\n");
! 6701: }
! 6702: }
! 6703: function_tests++;
! 6704:
! 6705: return(test_ret);
! 6706: }
! 6707:
! 6708:
! 6709: static int
! 6710: test_xmlIsChar(void) {
! 6711: int test_ret = 0;
! 6712:
! 6713: int mem_base;
! 6714: int ret_val;
! 6715: unsigned int ch; /* character to validate */
! 6716: int n_ch;
! 6717:
! 6718: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
! 6719: mem_base = xmlMemBlocks();
! 6720: ch = gen_unsigned_int(n_ch, 0);
! 6721:
! 6722: ret_val = xmlIsChar(ch);
! 6723: desret_int(ret_val);
! 6724: call_tests++;
! 6725: des_unsigned_int(n_ch, ch, 0);
! 6726: xmlResetLastError();
! 6727: if (mem_base != xmlMemBlocks()) {
! 6728: printf("Leak of %d blocks found in xmlIsChar",
! 6729: xmlMemBlocks() - mem_base);
! 6730: test_ret++;
! 6731: printf(" %d", n_ch);
! 6732: printf("\n");
! 6733: }
! 6734: }
! 6735: function_tests++;
! 6736:
! 6737: return(test_ret);
! 6738: }
! 6739:
! 6740:
! 6741: static int
! 6742: test_xmlIsCombining(void) {
! 6743: int test_ret = 0;
! 6744:
! 6745: int mem_base;
! 6746: int ret_val;
! 6747: unsigned int ch; /* character to validate */
! 6748: int n_ch;
! 6749:
! 6750: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
! 6751: mem_base = xmlMemBlocks();
! 6752: ch = gen_unsigned_int(n_ch, 0);
! 6753:
! 6754: ret_val = xmlIsCombining(ch);
! 6755: desret_int(ret_val);
! 6756: call_tests++;
! 6757: des_unsigned_int(n_ch, ch, 0);
! 6758: xmlResetLastError();
! 6759: if (mem_base != xmlMemBlocks()) {
! 6760: printf("Leak of %d blocks found in xmlIsCombining",
! 6761: xmlMemBlocks() - mem_base);
! 6762: test_ret++;
! 6763: printf(" %d", n_ch);
! 6764: printf("\n");
! 6765: }
! 6766: }
! 6767: function_tests++;
! 6768:
! 6769: return(test_ret);
! 6770: }
! 6771:
! 6772:
! 6773: static int
! 6774: test_xmlIsDigit(void) {
! 6775: int test_ret = 0;
! 6776:
! 6777: int mem_base;
! 6778: int ret_val;
! 6779: unsigned int ch; /* character to validate */
! 6780: int n_ch;
! 6781:
! 6782: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
! 6783: mem_base = xmlMemBlocks();
! 6784: ch = gen_unsigned_int(n_ch, 0);
! 6785:
! 6786: ret_val = xmlIsDigit(ch);
! 6787: desret_int(ret_val);
! 6788: call_tests++;
! 6789: des_unsigned_int(n_ch, ch, 0);
! 6790: xmlResetLastError();
! 6791: if (mem_base != xmlMemBlocks()) {
! 6792: printf("Leak of %d blocks found in xmlIsDigit",
! 6793: xmlMemBlocks() - mem_base);
! 6794: test_ret++;
! 6795: printf(" %d", n_ch);
! 6796: printf("\n");
! 6797: }
! 6798: }
! 6799: function_tests++;
! 6800:
! 6801: return(test_ret);
! 6802: }
! 6803:
! 6804:
! 6805: static int
! 6806: test_xmlIsExtender(void) {
! 6807: int test_ret = 0;
! 6808:
! 6809: int mem_base;
! 6810: int ret_val;
! 6811: unsigned int ch; /* character to validate */
! 6812: int n_ch;
! 6813:
! 6814: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
! 6815: mem_base = xmlMemBlocks();
! 6816: ch = gen_unsigned_int(n_ch, 0);
! 6817:
! 6818: ret_val = xmlIsExtender(ch);
! 6819: desret_int(ret_val);
! 6820: call_tests++;
! 6821: des_unsigned_int(n_ch, ch, 0);
! 6822: xmlResetLastError();
! 6823: if (mem_base != xmlMemBlocks()) {
! 6824: printf("Leak of %d blocks found in xmlIsExtender",
! 6825: xmlMemBlocks() - mem_base);
! 6826: test_ret++;
! 6827: printf(" %d", n_ch);
! 6828: printf("\n");
! 6829: }
! 6830: }
! 6831: function_tests++;
! 6832:
! 6833: return(test_ret);
! 6834: }
! 6835:
! 6836:
! 6837: static int
! 6838: test_xmlIsIdeographic(void) {
! 6839: int test_ret = 0;
! 6840:
! 6841: int mem_base;
! 6842: int ret_val;
! 6843: unsigned int ch; /* character to validate */
! 6844: int n_ch;
! 6845:
! 6846: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
! 6847: mem_base = xmlMemBlocks();
! 6848: ch = gen_unsigned_int(n_ch, 0);
! 6849:
! 6850: ret_val = xmlIsIdeographic(ch);
! 6851: desret_int(ret_val);
! 6852: call_tests++;
! 6853: des_unsigned_int(n_ch, ch, 0);
! 6854: xmlResetLastError();
! 6855: if (mem_base != xmlMemBlocks()) {
! 6856: printf("Leak of %d blocks found in xmlIsIdeographic",
! 6857: xmlMemBlocks() - mem_base);
! 6858: test_ret++;
! 6859: printf(" %d", n_ch);
! 6860: printf("\n");
! 6861: }
! 6862: }
! 6863: function_tests++;
! 6864:
! 6865: return(test_ret);
! 6866: }
! 6867:
! 6868:
! 6869: static int
! 6870: test_xmlIsPubidChar(void) {
! 6871: int test_ret = 0;
! 6872:
! 6873: int mem_base;
! 6874: int ret_val;
! 6875: unsigned int ch; /* character to validate */
! 6876: int n_ch;
! 6877:
! 6878: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
! 6879: mem_base = xmlMemBlocks();
! 6880: ch = gen_unsigned_int(n_ch, 0);
! 6881:
! 6882: ret_val = xmlIsPubidChar(ch);
! 6883: desret_int(ret_val);
! 6884: call_tests++;
! 6885: des_unsigned_int(n_ch, ch, 0);
! 6886: xmlResetLastError();
! 6887: if (mem_base != xmlMemBlocks()) {
! 6888: printf("Leak of %d blocks found in xmlIsPubidChar",
! 6889: xmlMemBlocks() - mem_base);
! 6890: test_ret++;
! 6891: printf(" %d", n_ch);
! 6892: printf("\n");
! 6893: }
! 6894: }
! 6895: function_tests++;
! 6896:
! 6897: return(test_ret);
! 6898: }
! 6899:
! 6900: static int
! 6901: test_chvalid(void) {
! 6902: int test_ret = 0;
! 6903:
! 6904: if (quiet == 0) printf("Testing chvalid : 9 of 9 functions ...\n");
! 6905: test_ret += test_xmlCharInRange();
! 6906: test_ret += test_xmlIsBaseChar();
! 6907: test_ret += test_xmlIsBlank();
! 6908: test_ret += test_xmlIsChar();
! 6909: test_ret += test_xmlIsCombining();
! 6910: test_ret += test_xmlIsDigit();
! 6911: test_ret += test_xmlIsExtender();
! 6912: test_ret += test_xmlIsIdeographic();
! 6913: test_ret += test_xmlIsPubidChar();
! 6914:
! 6915: if (test_ret != 0)
! 6916: printf("Module chvalid: %d errors\n", test_ret);
! 6917: return(test_ret);
! 6918: }
! 6919:
! 6920: static int
! 6921: test_xmlBoolToText(void) {
! 6922: int test_ret = 0;
! 6923:
! 6924: #if defined(LIBXML_DEBUG_ENABLED)
! 6925: int mem_base;
! 6926: const char * ret_val;
! 6927: int boolval; /* a bool to turn into text */
! 6928: int n_boolval;
! 6929:
! 6930: for (n_boolval = 0;n_boolval < gen_nb_int;n_boolval++) {
! 6931: mem_base = xmlMemBlocks();
! 6932: boolval = gen_int(n_boolval, 0);
! 6933:
! 6934: ret_val = xmlBoolToText(boolval);
! 6935: desret_const_char_ptr(ret_val);
! 6936: call_tests++;
! 6937: des_int(n_boolval, boolval, 0);
! 6938: xmlResetLastError();
! 6939: if (mem_base != xmlMemBlocks()) {
! 6940: printf("Leak of %d blocks found in xmlBoolToText",
! 6941: xmlMemBlocks() - mem_base);
! 6942: test_ret++;
! 6943: printf(" %d", n_boolval);
! 6944: printf("\n");
! 6945: }
! 6946: }
! 6947: function_tests++;
! 6948: #endif
! 6949:
! 6950: return(test_ret);
! 6951: }
! 6952:
! 6953:
! 6954: static int
! 6955: test_xmlDebugCheckDocument(void) {
! 6956: int test_ret = 0;
! 6957:
! 6958: #if defined(LIBXML_DEBUG_ENABLED)
! 6959: int mem_base;
! 6960: int ret_val;
! 6961: FILE * output; /* the FILE * for the output */
! 6962: int n_output;
! 6963: xmlDocPtr doc; /* the document */
! 6964: int n_doc;
! 6965:
! 6966: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
! 6967: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 6968: mem_base = xmlMemBlocks();
! 6969: output = gen_debug_FILE_ptr(n_output, 0);
! 6970: doc = gen_xmlDocPtr(n_doc, 1);
! 6971:
! 6972: ret_val = xmlDebugCheckDocument(output, doc);
! 6973: desret_int(ret_val);
! 6974: call_tests++;
! 6975: des_debug_FILE_ptr(n_output, output, 0);
! 6976: des_xmlDocPtr(n_doc, doc, 1);
! 6977: xmlResetLastError();
! 6978: if (mem_base != xmlMemBlocks()) {
! 6979: printf("Leak of %d blocks found in xmlDebugCheckDocument",
! 6980: xmlMemBlocks() - mem_base);
! 6981: test_ret++;
! 6982: printf(" %d", n_output);
! 6983: printf(" %d", n_doc);
! 6984: printf("\n");
! 6985: }
! 6986: }
! 6987: }
! 6988: function_tests++;
! 6989: #endif
! 6990:
! 6991: return(test_ret);
! 6992: }
! 6993:
! 6994:
! 6995: static int
! 6996: test_xmlDebugDumpAttr(void) {
! 6997: int test_ret = 0;
! 6998:
! 6999: #if defined(LIBXML_DEBUG_ENABLED)
! 7000: int mem_base;
! 7001: FILE * output; /* the FILE * for the output */
! 7002: int n_output;
! 7003: xmlAttrPtr attr; /* the attribute */
! 7004: int n_attr;
! 7005: int depth; /* the indentation level. */
! 7006: int n_depth;
! 7007:
! 7008: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
! 7009: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
! 7010: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
! 7011: mem_base = xmlMemBlocks();
! 7012: output = gen_debug_FILE_ptr(n_output, 0);
! 7013: attr = gen_xmlAttrPtr(n_attr, 1);
! 7014: depth = gen_int(n_depth, 2);
! 7015:
! 7016: xmlDebugDumpAttr(output, attr, depth);
! 7017: call_tests++;
! 7018: des_debug_FILE_ptr(n_output, output, 0);
! 7019: des_xmlAttrPtr(n_attr, attr, 1);
! 7020: des_int(n_depth, depth, 2);
! 7021: xmlResetLastError();
! 7022: if (mem_base != xmlMemBlocks()) {
! 7023: printf("Leak of %d blocks found in xmlDebugDumpAttr",
! 7024: xmlMemBlocks() - mem_base);
! 7025: test_ret++;
! 7026: printf(" %d", n_output);
! 7027: printf(" %d", n_attr);
! 7028: printf(" %d", n_depth);
! 7029: printf("\n");
! 7030: }
! 7031: }
! 7032: }
! 7033: }
! 7034: function_tests++;
! 7035: #endif
! 7036:
! 7037: return(test_ret);
! 7038: }
! 7039:
! 7040:
! 7041: static int
! 7042: test_xmlDebugDumpAttrList(void) {
! 7043: int test_ret = 0;
! 7044:
! 7045: #if defined(LIBXML_DEBUG_ENABLED)
! 7046: int mem_base;
! 7047: FILE * output; /* the FILE * for the output */
! 7048: int n_output;
! 7049: xmlAttrPtr attr; /* the attribute list */
! 7050: int n_attr;
! 7051: int depth; /* the indentation level. */
! 7052: int n_depth;
! 7053:
! 7054: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
! 7055: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
! 7056: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
! 7057: mem_base = xmlMemBlocks();
! 7058: output = gen_debug_FILE_ptr(n_output, 0);
! 7059: attr = gen_xmlAttrPtr(n_attr, 1);
! 7060: depth = gen_int(n_depth, 2);
! 7061:
! 7062: xmlDebugDumpAttrList(output, attr, depth);
! 7063: call_tests++;
! 7064: des_debug_FILE_ptr(n_output, output, 0);
! 7065: des_xmlAttrPtr(n_attr, attr, 1);
! 7066: des_int(n_depth, depth, 2);
! 7067: xmlResetLastError();
! 7068: if (mem_base != xmlMemBlocks()) {
! 7069: printf("Leak of %d blocks found in xmlDebugDumpAttrList",
! 7070: xmlMemBlocks() - mem_base);
! 7071: test_ret++;
! 7072: printf(" %d", n_output);
! 7073: printf(" %d", n_attr);
! 7074: printf(" %d", n_depth);
! 7075: printf("\n");
! 7076: }
! 7077: }
! 7078: }
! 7079: }
! 7080: function_tests++;
! 7081: #endif
! 7082:
! 7083: return(test_ret);
! 7084: }
! 7085:
! 7086:
! 7087: static int
! 7088: test_xmlDebugDumpDTD(void) {
! 7089: int test_ret = 0;
! 7090:
! 7091: #if defined(LIBXML_DEBUG_ENABLED)
! 7092: int mem_base;
! 7093: FILE * output; /* the FILE * for the output */
! 7094: int n_output;
! 7095: xmlDtdPtr dtd; /* the DTD */
! 7096: int n_dtd;
! 7097:
! 7098: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
! 7099: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
! 7100: mem_base = xmlMemBlocks();
! 7101: output = gen_debug_FILE_ptr(n_output, 0);
! 7102: dtd = gen_xmlDtdPtr(n_dtd, 1);
! 7103:
! 7104: xmlDebugDumpDTD(output, dtd);
! 7105: call_tests++;
! 7106: des_debug_FILE_ptr(n_output, output, 0);
! 7107: des_xmlDtdPtr(n_dtd, dtd, 1);
! 7108: xmlResetLastError();
! 7109: if (mem_base != xmlMemBlocks()) {
! 7110: printf("Leak of %d blocks found in xmlDebugDumpDTD",
! 7111: xmlMemBlocks() - mem_base);
! 7112: test_ret++;
! 7113: printf(" %d", n_output);
! 7114: printf(" %d", n_dtd);
! 7115: printf("\n");
! 7116: }
! 7117: }
! 7118: }
! 7119: function_tests++;
! 7120: #endif
! 7121:
! 7122: return(test_ret);
! 7123: }
! 7124:
! 7125:
! 7126: static int
! 7127: test_xmlDebugDumpDocument(void) {
! 7128: int test_ret = 0;
! 7129:
! 7130: #if defined(LIBXML_DEBUG_ENABLED)
! 7131: int mem_base;
! 7132: FILE * output; /* the FILE * for the output */
! 7133: int n_output;
! 7134: xmlDocPtr doc; /* the document */
! 7135: int n_doc;
! 7136:
! 7137: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
! 7138: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 7139: mem_base = xmlMemBlocks();
! 7140: output = gen_debug_FILE_ptr(n_output, 0);
! 7141: doc = gen_xmlDocPtr(n_doc, 1);
! 7142:
! 7143: xmlDebugDumpDocument(output, doc);
! 7144: call_tests++;
! 7145: des_debug_FILE_ptr(n_output, output, 0);
! 7146: des_xmlDocPtr(n_doc, doc, 1);
! 7147: xmlResetLastError();
! 7148: if (mem_base != xmlMemBlocks()) {
! 7149: printf("Leak of %d blocks found in xmlDebugDumpDocument",
! 7150: xmlMemBlocks() - mem_base);
! 7151: test_ret++;
! 7152: printf(" %d", n_output);
! 7153: printf(" %d", n_doc);
! 7154: printf("\n");
! 7155: }
! 7156: }
! 7157: }
! 7158: function_tests++;
! 7159: #endif
! 7160:
! 7161: return(test_ret);
! 7162: }
! 7163:
! 7164:
! 7165: static int
! 7166: test_xmlDebugDumpDocumentHead(void) {
! 7167: int test_ret = 0;
! 7168:
! 7169: #if defined(LIBXML_DEBUG_ENABLED)
! 7170: int mem_base;
! 7171: FILE * output; /* the FILE * for the output */
! 7172: int n_output;
! 7173: xmlDocPtr doc; /* the document */
! 7174: int n_doc;
! 7175:
! 7176: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
! 7177: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 7178: mem_base = xmlMemBlocks();
! 7179: output = gen_debug_FILE_ptr(n_output, 0);
! 7180: doc = gen_xmlDocPtr(n_doc, 1);
! 7181:
! 7182: xmlDebugDumpDocumentHead(output, doc);
! 7183: call_tests++;
! 7184: des_debug_FILE_ptr(n_output, output, 0);
! 7185: des_xmlDocPtr(n_doc, doc, 1);
! 7186: xmlResetLastError();
! 7187: if (mem_base != xmlMemBlocks()) {
! 7188: printf("Leak of %d blocks found in xmlDebugDumpDocumentHead",
! 7189: xmlMemBlocks() - mem_base);
! 7190: test_ret++;
! 7191: printf(" %d", n_output);
! 7192: printf(" %d", n_doc);
! 7193: printf("\n");
! 7194: }
! 7195: }
! 7196: }
! 7197: function_tests++;
! 7198: #endif
! 7199:
! 7200: return(test_ret);
! 7201: }
! 7202:
! 7203:
! 7204: static int
! 7205: test_xmlDebugDumpEntities(void) {
! 7206: int test_ret = 0;
! 7207:
! 7208: #if defined(LIBXML_DEBUG_ENABLED)
! 7209: int mem_base;
! 7210: FILE * output; /* the FILE * for the output */
! 7211: int n_output;
! 7212: xmlDocPtr doc; /* the document */
! 7213: int n_doc;
! 7214:
! 7215: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
! 7216: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 7217: mem_base = xmlMemBlocks();
! 7218: output = gen_debug_FILE_ptr(n_output, 0);
! 7219: doc = gen_xmlDocPtr(n_doc, 1);
! 7220:
! 7221: xmlDebugDumpEntities(output, doc);
! 7222: call_tests++;
! 7223: des_debug_FILE_ptr(n_output, output, 0);
! 7224: des_xmlDocPtr(n_doc, doc, 1);
! 7225: xmlResetLastError();
! 7226: if (mem_base != xmlMemBlocks()) {
! 7227: printf("Leak of %d blocks found in xmlDebugDumpEntities",
! 7228: xmlMemBlocks() - mem_base);
! 7229: test_ret++;
! 7230: printf(" %d", n_output);
! 7231: printf(" %d", n_doc);
! 7232: printf("\n");
! 7233: }
! 7234: }
! 7235: }
! 7236: function_tests++;
! 7237: #endif
! 7238:
! 7239: return(test_ret);
! 7240: }
! 7241:
! 7242:
! 7243: static int
! 7244: test_xmlDebugDumpNode(void) {
! 7245: int test_ret = 0;
! 7246:
! 7247: #if defined(LIBXML_DEBUG_ENABLED)
! 7248: int mem_base;
! 7249: FILE * output; /* the FILE * for the output */
! 7250: int n_output;
! 7251: xmlNodePtr node; /* the node */
! 7252: int n_node;
! 7253: int depth; /* the indentation level. */
! 7254: int n_depth;
! 7255:
! 7256: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
! 7257: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 7258: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
! 7259: mem_base = xmlMemBlocks();
! 7260: output = gen_debug_FILE_ptr(n_output, 0);
! 7261: node = gen_xmlNodePtr(n_node, 1);
! 7262: depth = gen_int(n_depth, 2);
! 7263:
! 7264: xmlDebugDumpNode(output, node, depth);
! 7265: call_tests++;
! 7266: des_debug_FILE_ptr(n_output, output, 0);
! 7267: des_xmlNodePtr(n_node, node, 1);
! 7268: des_int(n_depth, depth, 2);
! 7269: xmlResetLastError();
! 7270: if (mem_base != xmlMemBlocks()) {
! 7271: printf("Leak of %d blocks found in xmlDebugDumpNode",
! 7272: xmlMemBlocks() - mem_base);
! 7273: test_ret++;
! 7274: printf(" %d", n_output);
! 7275: printf(" %d", n_node);
! 7276: printf(" %d", n_depth);
! 7277: printf("\n");
! 7278: }
! 7279: }
! 7280: }
! 7281: }
! 7282: function_tests++;
! 7283: #endif
! 7284:
! 7285: return(test_ret);
! 7286: }
! 7287:
! 7288:
! 7289: static int
! 7290: test_xmlDebugDumpNodeList(void) {
! 7291: int test_ret = 0;
! 7292:
! 7293: #if defined(LIBXML_DEBUG_ENABLED)
! 7294: int mem_base;
! 7295: FILE * output; /* the FILE * for the output */
! 7296: int n_output;
! 7297: xmlNodePtr node; /* the node list */
! 7298: int n_node;
! 7299: int depth; /* the indentation level. */
! 7300: int n_depth;
! 7301:
! 7302: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
! 7303: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 7304: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
! 7305: mem_base = xmlMemBlocks();
! 7306: output = gen_debug_FILE_ptr(n_output, 0);
! 7307: node = gen_xmlNodePtr(n_node, 1);
! 7308: depth = gen_int(n_depth, 2);
! 7309:
! 7310: xmlDebugDumpNodeList(output, node, depth);
! 7311: call_tests++;
! 7312: des_debug_FILE_ptr(n_output, output, 0);
! 7313: des_xmlNodePtr(n_node, node, 1);
! 7314: des_int(n_depth, depth, 2);
! 7315: xmlResetLastError();
! 7316: if (mem_base != xmlMemBlocks()) {
! 7317: printf("Leak of %d blocks found in xmlDebugDumpNodeList",
! 7318: xmlMemBlocks() - mem_base);
! 7319: test_ret++;
! 7320: printf(" %d", n_output);
! 7321: printf(" %d", n_node);
! 7322: printf(" %d", n_depth);
! 7323: printf("\n");
! 7324: }
! 7325: }
! 7326: }
! 7327: }
! 7328: function_tests++;
! 7329: #endif
! 7330:
! 7331: return(test_ret);
! 7332: }
! 7333:
! 7334:
! 7335: static int
! 7336: test_xmlDebugDumpOneNode(void) {
! 7337: int test_ret = 0;
! 7338:
! 7339: #if defined(LIBXML_DEBUG_ENABLED)
! 7340: int mem_base;
! 7341: FILE * output; /* the FILE * for the output */
! 7342: int n_output;
! 7343: xmlNodePtr node; /* the node */
! 7344: int n_node;
! 7345: int depth; /* the indentation level. */
! 7346: int n_depth;
! 7347:
! 7348: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
! 7349: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 7350: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
! 7351: mem_base = xmlMemBlocks();
! 7352: output = gen_debug_FILE_ptr(n_output, 0);
! 7353: node = gen_xmlNodePtr(n_node, 1);
! 7354: depth = gen_int(n_depth, 2);
! 7355:
! 7356: xmlDebugDumpOneNode(output, node, depth);
! 7357: call_tests++;
! 7358: des_debug_FILE_ptr(n_output, output, 0);
! 7359: des_xmlNodePtr(n_node, node, 1);
! 7360: des_int(n_depth, depth, 2);
! 7361: xmlResetLastError();
! 7362: if (mem_base != xmlMemBlocks()) {
! 7363: printf("Leak of %d blocks found in xmlDebugDumpOneNode",
! 7364: xmlMemBlocks() - mem_base);
! 7365: test_ret++;
! 7366: printf(" %d", n_output);
! 7367: printf(" %d", n_node);
! 7368: printf(" %d", n_depth);
! 7369: printf("\n");
! 7370: }
! 7371: }
! 7372: }
! 7373: }
! 7374: function_tests++;
! 7375: #endif
! 7376:
! 7377: return(test_ret);
! 7378: }
! 7379:
! 7380:
! 7381: static int
! 7382: test_xmlDebugDumpString(void) {
! 7383: int test_ret = 0;
! 7384:
! 7385: #if defined(LIBXML_DEBUG_ENABLED)
! 7386: int mem_base;
! 7387: FILE * output; /* the FILE * for the output */
! 7388: int n_output;
! 7389: xmlChar * str; /* the string */
! 7390: int n_str;
! 7391:
! 7392: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
! 7393: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 7394: mem_base = xmlMemBlocks();
! 7395: output = gen_debug_FILE_ptr(n_output, 0);
! 7396: str = gen_const_xmlChar_ptr(n_str, 1);
! 7397:
! 7398: xmlDebugDumpString(output, (const xmlChar *)str);
! 7399: call_tests++;
! 7400: des_debug_FILE_ptr(n_output, output, 0);
! 7401: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
! 7402: xmlResetLastError();
! 7403: if (mem_base != xmlMemBlocks()) {
! 7404: printf("Leak of %d blocks found in xmlDebugDumpString",
! 7405: xmlMemBlocks() - mem_base);
! 7406: test_ret++;
! 7407: printf(" %d", n_output);
! 7408: printf(" %d", n_str);
! 7409: printf("\n");
! 7410: }
! 7411: }
! 7412: }
! 7413: function_tests++;
! 7414: #endif
! 7415:
! 7416: return(test_ret);
! 7417: }
! 7418:
! 7419:
! 7420: static int
! 7421: test_xmlLsCountNode(void) {
! 7422: int test_ret = 0;
! 7423:
! 7424: #if defined(LIBXML_DEBUG_ENABLED)
! 7425: int mem_base;
! 7426: int ret_val;
! 7427: xmlNodePtr node; /* the node to count */
! 7428: int n_node;
! 7429:
! 7430: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 7431: mem_base = xmlMemBlocks();
! 7432: node = gen_xmlNodePtr(n_node, 0);
! 7433:
! 7434: ret_val = xmlLsCountNode(node);
! 7435: desret_int(ret_val);
! 7436: call_tests++;
! 7437: des_xmlNodePtr(n_node, node, 0);
! 7438: xmlResetLastError();
! 7439: if (mem_base != xmlMemBlocks()) {
! 7440: printf("Leak of %d blocks found in xmlLsCountNode",
! 7441: xmlMemBlocks() - mem_base);
! 7442: test_ret++;
! 7443: printf(" %d", n_node);
! 7444: printf("\n");
! 7445: }
! 7446: }
! 7447: function_tests++;
! 7448: #endif
! 7449:
! 7450: return(test_ret);
! 7451: }
! 7452:
! 7453:
! 7454: static int
! 7455: test_xmlLsOneNode(void) {
! 7456: int test_ret = 0;
! 7457:
! 7458: #if defined(LIBXML_DEBUG_ENABLED)
! 7459: int mem_base;
! 7460: FILE * output; /* the FILE * for the output */
! 7461: int n_output;
! 7462: xmlNodePtr node; /* the node to dump */
! 7463: int n_node;
! 7464:
! 7465: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
! 7466: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 7467: mem_base = xmlMemBlocks();
! 7468: output = gen_debug_FILE_ptr(n_output, 0);
! 7469: node = gen_xmlNodePtr(n_node, 1);
! 7470:
! 7471: xmlLsOneNode(output, node);
! 7472: call_tests++;
! 7473: des_debug_FILE_ptr(n_output, output, 0);
! 7474: des_xmlNodePtr(n_node, node, 1);
! 7475: xmlResetLastError();
! 7476: if (mem_base != xmlMemBlocks()) {
! 7477: printf("Leak of %d blocks found in xmlLsOneNode",
! 7478: xmlMemBlocks() - mem_base);
! 7479: test_ret++;
! 7480: printf(" %d", n_output);
! 7481: printf(" %d", n_node);
! 7482: printf("\n");
! 7483: }
! 7484: }
! 7485: }
! 7486: function_tests++;
! 7487: #endif
! 7488:
! 7489: return(test_ret);
! 7490: }
! 7491:
! 7492:
! 7493: #define gen_nb_char_ptr 1
! 7494: static char * gen_char_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 7495: return(NULL);
! 7496: }
! 7497: static void des_char_ptr(int no ATTRIBUTE_UNUSED, char * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 7498: }
! 7499:
! 7500: static int
! 7501: test_xmlShell(void) {
! 7502: int test_ret = 0;
! 7503:
! 7504:
! 7505: /* missing type support */
! 7506: return(test_ret);
! 7507: }
! 7508:
! 7509:
! 7510: static int
! 7511: test_xmlShellBase(void) {
! 7512: int test_ret = 0;
! 7513:
! 7514: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
! 7515: int mem_base;
! 7516: int ret_val;
! 7517: xmlShellCtxtPtr ctxt; /* the shell context */
! 7518: int n_ctxt;
! 7519: char * arg; /* unused */
! 7520: int n_arg;
! 7521: xmlNodePtr node; /* a node */
! 7522: int n_node;
! 7523: xmlNodePtr node2; /* unused */
! 7524: int n_node2;
! 7525:
! 7526: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
! 7527: for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
! 7528: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 7529: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
! 7530: mem_base = xmlMemBlocks();
! 7531: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
! 7532: arg = gen_char_ptr(n_arg, 1);
! 7533: node = gen_xmlNodePtr(n_node, 2);
! 7534: node2 = gen_xmlNodePtr(n_node2, 3);
! 7535:
! 7536: ret_val = xmlShellBase(ctxt, arg, node, node2);
! 7537: desret_int(ret_val);
! 7538: call_tests++;
! 7539: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
! 7540: des_char_ptr(n_arg, arg, 1);
! 7541: des_xmlNodePtr(n_node, node, 2);
! 7542: des_xmlNodePtr(n_node2, node2, 3);
! 7543: xmlResetLastError();
! 7544: if (mem_base != xmlMemBlocks()) {
! 7545: printf("Leak of %d blocks found in xmlShellBase",
! 7546: xmlMemBlocks() - mem_base);
! 7547: test_ret++;
! 7548: printf(" %d", n_ctxt);
! 7549: printf(" %d", n_arg);
! 7550: printf(" %d", n_node);
! 7551: printf(" %d", n_node2);
! 7552: printf("\n");
! 7553: }
! 7554: }
! 7555: }
! 7556: }
! 7557: }
! 7558: function_tests++;
! 7559: #endif
! 7560:
! 7561: return(test_ret);
! 7562: }
! 7563:
! 7564:
! 7565: static int
! 7566: test_xmlShellCat(void) {
! 7567: int test_ret = 0;
! 7568:
! 7569: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 7570: int mem_base;
! 7571: int ret_val;
! 7572: xmlShellCtxtPtr ctxt; /* the shell context */
! 7573: int n_ctxt;
! 7574: char * arg; /* unused */
! 7575: int n_arg;
! 7576: xmlNodePtr node; /* a node */
! 7577: int n_node;
! 7578: xmlNodePtr node2; /* unused */
! 7579: int n_node2;
! 7580:
! 7581: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
! 7582: for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
! 7583: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 7584: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
! 7585: mem_base = xmlMemBlocks();
! 7586: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
! 7587: arg = gen_char_ptr(n_arg, 1);
! 7588: node = gen_xmlNodePtr(n_node, 2);
! 7589: node2 = gen_xmlNodePtr(n_node2, 3);
! 7590:
! 7591: ret_val = xmlShellCat(ctxt, arg, node, node2);
! 7592: desret_int(ret_val);
! 7593: call_tests++;
! 7594: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
! 7595: des_char_ptr(n_arg, arg, 1);
! 7596: des_xmlNodePtr(n_node, node, 2);
! 7597: des_xmlNodePtr(n_node2, node2, 3);
! 7598: xmlResetLastError();
! 7599: if (mem_base != xmlMemBlocks()) {
! 7600: printf("Leak of %d blocks found in xmlShellCat",
! 7601: xmlMemBlocks() - mem_base);
! 7602: test_ret++;
! 7603: printf(" %d", n_ctxt);
! 7604: printf(" %d", n_arg);
! 7605: printf(" %d", n_node);
! 7606: printf(" %d", n_node2);
! 7607: printf("\n");
! 7608: }
! 7609: }
! 7610: }
! 7611: }
! 7612: }
! 7613: function_tests++;
! 7614: #endif
! 7615:
! 7616: return(test_ret);
! 7617: }
! 7618:
! 7619:
! 7620: static int
! 7621: test_xmlShellDir(void) {
! 7622: int test_ret = 0;
! 7623:
! 7624: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
! 7625: int mem_base;
! 7626: int ret_val;
! 7627: xmlShellCtxtPtr ctxt; /* the shell context */
! 7628: int n_ctxt;
! 7629: char * arg; /* unused */
! 7630: int n_arg;
! 7631: xmlNodePtr node; /* a node */
! 7632: int n_node;
! 7633: xmlNodePtr node2; /* unused */
! 7634: int n_node2;
! 7635:
! 7636: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
! 7637: for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
! 7638: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 7639: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
! 7640: mem_base = xmlMemBlocks();
! 7641: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
! 7642: arg = gen_char_ptr(n_arg, 1);
! 7643: node = gen_xmlNodePtr(n_node, 2);
! 7644: node2 = gen_xmlNodePtr(n_node2, 3);
! 7645:
! 7646: ret_val = xmlShellDir(ctxt, arg, node, node2);
! 7647: desret_int(ret_val);
! 7648: call_tests++;
! 7649: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
! 7650: des_char_ptr(n_arg, arg, 1);
! 7651: des_xmlNodePtr(n_node, node, 2);
! 7652: des_xmlNodePtr(n_node2, node2, 3);
! 7653: xmlResetLastError();
! 7654: if (mem_base != xmlMemBlocks()) {
! 7655: printf("Leak of %d blocks found in xmlShellDir",
! 7656: xmlMemBlocks() - mem_base);
! 7657: test_ret++;
! 7658: printf(" %d", n_ctxt);
! 7659: printf(" %d", n_arg);
! 7660: printf(" %d", n_node);
! 7661: printf(" %d", n_node2);
! 7662: printf("\n");
! 7663: }
! 7664: }
! 7665: }
! 7666: }
! 7667: }
! 7668: function_tests++;
! 7669: #endif
! 7670:
! 7671: return(test_ret);
! 7672: }
! 7673:
! 7674:
! 7675: static int
! 7676: test_xmlShellDu(void) {
! 7677: int test_ret = 0;
! 7678:
! 7679: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
! 7680: int mem_base;
! 7681: int ret_val;
! 7682: xmlShellCtxtPtr ctxt; /* the shell context */
! 7683: int n_ctxt;
! 7684: char * arg; /* unused */
! 7685: int n_arg;
! 7686: xmlNodePtr tree; /* a node defining a subtree */
! 7687: int n_tree;
! 7688: xmlNodePtr node2; /* unused */
! 7689: int n_node2;
! 7690:
! 7691: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
! 7692: for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
! 7693: for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
! 7694: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
! 7695: mem_base = xmlMemBlocks();
! 7696: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
! 7697: arg = gen_char_ptr(n_arg, 1);
! 7698: tree = gen_xmlNodePtr(n_tree, 2);
! 7699: node2 = gen_xmlNodePtr(n_node2, 3);
! 7700:
! 7701: ret_val = xmlShellDu(ctxt, arg, tree, node2);
! 7702: desret_int(ret_val);
! 7703: call_tests++;
! 7704: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
! 7705: des_char_ptr(n_arg, arg, 1);
! 7706: des_xmlNodePtr(n_tree, tree, 2);
! 7707: des_xmlNodePtr(n_node2, node2, 3);
! 7708: xmlResetLastError();
! 7709: if (mem_base != xmlMemBlocks()) {
! 7710: printf("Leak of %d blocks found in xmlShellDu",
! 7711: xmlMemBlocks() - mem_base);
! 7712: test_ret++;
! 7713: printf(" %d", n_ctxt);
! 7714: printf(" %d", n_arg);
! 7715: printf(" %d", n_tree);
! 7716: printf(" %d", n_node2);
! 7717: printf("\n");
! 7718: }
! 7719: }
! 7720: }
! 7721: }
! 7722: }
! 7723: function_tests++;
! 7724: #endif
! 7725:
! 7726: return(test_ret);
! 7727: }
! 7728:
! 7729:
! 7730: static int
! 7731: test_xmlShellList(void) {
! 7732: int test_ret = 0;
! 7733:
! 7734: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
! 7735: int mem_base;
! 7736: int ret_val;
! 7737: xmlShellCtxtPtr ctxt; /* the shell context */
! 7738: int n_ctxt;
! 7739: char * arg; /* unused */
! 7740: int n_arg;
! 7741: xmlNodePtr node; /* a node */
! 7742: int n_node;
! 7743: xmlNodePtr node2; /* unused */
! 7744: int n_node2;
! 7745:
! 7746: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
! 7747: for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
! 7748: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 7749: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
! 7750: mem_base = xmlMemBlocks();
! 7751: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
! 7752: arg = gen_char_ptr(n_arg, 1);
! 7753: node = gen_xmlNodePtr(n_node, 2);
! 7754: node2 = gen_xmlNodePtr(n_node2, 3);
! 7755:
! 7756: ret_val = xmlShellList(ctxt, arg, node, node2);
! 7757: desret_int(ret_val);
! 7758: call_tests++;
! 7759: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
! 7760: des_char_ptr(n_arg, arg, 1);
! 7761: des_xmlNodePtr(n_node, node, 2);
! 7762: des_xmlNodePtr(n_node2, node2, 3);
! 7763: xmlResetLastError();
! 7764: if (mem_base != xmlMemBlocks()) {
! 7765: printf("Leak of %d blocks found in xmlShellList",
! 7766: xmlMemBlocks() - mem_base);
! 7767: test_ret++;
! 7768: printf(" %d", n_ctxt);
! 7769: printf(" %d", n_arg);
! 7770: printf(" %d", n_node);
! 7771: printf(" %d", n_node2);
! 7772: printf("\n");
! 7773: }
! 7774: }
! 7775: }
! 7776: }
! 7777: }
! 7778: function_tests++;
! 7779: #endif
! 7780:
! 7781: return(test_ret);
! 7782: }
! 7783:
! 7784:
! 7785: static int
! 7786: test_xmlShellLoad(void) {
! 7787: int test_ret = 0;
! 7788:
! 7789: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
! 7790: int mem_base;
! 7791: int ret_val;
! 7792: xmlShellCtxtPtr ctxt; /* the shell context */
! 7793: int n_ctxt;
! 7794: char * filename; /* the file name */
! 7795: int n_filename;
! 7796: xmlNodePtr node; /* unused */
! 7797: int n_node;
! 7798: xmlNodePtr node2; /* unused */
! 7799: int n_node2;
! 7800:
! 7801: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
! 7802: for (n_filename = 0;n_filename < gen_nb_char_ptr;n_filename++) {
! 7803: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 7804: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
! 7805: mem_base = xmlMemBlocks();
! 7806: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
! 7807: filename = gen_char_ptr(n_filename, 1);
! 7808: node = gen_xmlNodePtr(n_node, 2);
! 7809: node2 = gen_xmlNodePtr(n_node2, 3);
! 7810:
! 7811: ret_val = xmlShellLoad(ctxt, filename, node, node2);
! 7812: desret_int(ret_val);
! 7813: call_tests++;
! 7814: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
! 7815: des_char_ptr(n_filename, filename, 1);
! 7816: des_xmlNodePtr(n_node, node, 2);
! 7817: des_xmlNodePtr(n_node2, node2, 3);
! 7818: xmlResetLastError();
! 7819: if (mem_base != xmlMemBlocks()) {
! 7820: printf("Leak of %d blocks found in xmlShellLoad",
! 7821: xmlMemBlocks() - mem_base);
! 7822: test_ret++;
! 7823: printf(" %d", n_ctxt);
! 7824: printf(" %d", n_filename);
! 7825: printf(" %d", n_node);
! 7826: printf(" %d", n_node2);
! 7827: printf("\n");
! 7828: }
! 7829: }
! 7830: }
! 7831: }
! 7832: }
! 7833: function_tests++;
! 7834: #endif
! 7835:
! 7836: return(test_ret);
! 7837: }
! 7838:
! 7839:
! 7840: static int
! 7841: test_xmlShellPrintXPathResult(void) {
! 7842: int test_ret = 0;
! 7843:
! 7844: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
! 7845: int mem_base;
! 7846: xmlXPathObjectPtr list; /* a valid result generated by an xpath evaluation */
! 7847: int n_list;
! 7848:
! 7849: for (n_list = 0;n_list < gen_nb_xmlXPathObjectPtr;n_list++) {
! 7850: mem_base = xmlMemBlocks();
! 7851: list = gen_xmlXPathObjectPtr(n_list, 0);
! 7852:
! 7853: xmlShellPrintXPathResult(list);
! 7854: call_tests++;
! 7855: des_xmlXPathObjectPtr(n_list, list, 0);
! 7856: xmlResetLastError();
! 7857: if (mem_base != xmlMemBlocks()) {
! 7858: printf("Leak of %d blocks found in xmlShellPrintXPathResult",
! 7859: xmlMemBlocks() - mem_base);
! 7860: test_ret++;
! 7861: printf(" %d", n_list);
! 7862: printf("\n");
! 7863: }
! 7864: }
! 7865: function_tests++;
! 7866: #endif
! 7867:
! 7868: return(test_ret);
! 7869: }
! 7870:
! 7871:
! 7872: static int
! 7873: test_xmlShellPwd(void) {
! 7874: int test_ret = 0;
! 7875:
! 7876: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
! 7877: int mem_base;
! 7878: int ret_val;
! 7879: xmlShellCtxtPtr ctxt; /* the shell context */
! 7880: int n_ctxt;
! 7881: char * buffer; /* the output buffer */
! 7882: int n_buffer;
! 7883: xmlNodePtr node; /* a node */
! 7884: int n_node;
! 7885: xmlNodePtr node2; /* unused */
! 7886: int n_node2;
! 7887:
! 7888: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
! 7889: for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
! 7890: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 7891: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
! 7892: mem_base = xmlMemBlocks();
! 7893: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
! 7894: buffer = gen_char_ptr(n_buffer, 1);
! 7895: node = gen_xmlNodePtr(n_node, 2);
! 7896: node2 = gen_xmlNodePtr(n_node2, 3);
! 7897:
! 7898: ret_val = xmlShellPwd(ctxt, buffer, node, node2);
! 7899: desret_int(ret_val);
! 7900: call_tests++;
! 7901: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
! 7902: des_char_ptr(n_buffer, buffer, 1);
! 7903: des_xmlNodePtr(n_node, node, 2);
! 7904: des_xmlNodePtr(n_node2, node2, 3);
! 7905: xmlResetLastError();
! 7906: if (mem_base != xmlMemBlocks()) {
! 7907: printf("Leak of %d blocks found in xmlShellPwd",
! 7908: xmlMemBlocks() - mem_base);
! 7909: test_ret++;
! 7910: printf(" %d", n_ctxt);
! 7911: printf(" %d", n_buffer);
! 7912: printf(" %d", n_node);
! 7913: printf(" %d", n_node2);
! 7914: printf("\n");
! 7915: }
! 7916: }
! 7917: }
! 7918: }
! 7919: }
! 7920: function_tests++;
! 7921: #endif
! 7922:
! 7923: return(test_ret);
! 7924: }
! 7925:
! 7926:
! 7927: static int
! 7928: test_xmlShellSave(void) {
! 7929: int test_ret = 0;
! 7930:
! 7931: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 7932: int mem_base;
! 7933: int ret_val;
! 7934: xmlShellCtxtPtr ctxt; /* the shell context */
! 7935: int n_ctxt;
! 7936: char * filename; /* the file name (optional) */
! 7937: int n_filename;
! 7938: xmlNodePtr node; /* unused */
! 7939: int n_node;
! 7940: xmlNodePtr node2; /* unused */
! 7941: int n_node2;
! 7942:
! 7943: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
! 7944: for (n_filename = 0;n_filename < gen_nb_char_ptr;n_filename++) {
! 7945: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 7946: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
! 7947: mem_base = xmlMemBlocks();
! 7948: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
! 7949: filename = gen_char_ptr(n_filename, 1);
! 7950: node = gen_xmlNodePtr(n_node, 2);
! 7951: node2 = gen_xmlNodePtr(n_node2, 3);
! 7952:
! 7953: ret_val = xmlShellSave(ctxt, filename, node, node2);
! 7954: desret_int(ret_val);
! 7955: call_tests++;
! 7956: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
! 7957: des_char_ptr(n_filename, filename, 1);
! 7958: des_xmlNodePtr(n_node, node, 2);
! 7959: des_xmlNodePtr(n_node2, node2, 3);
! 7960: xmlResetLastError();
! 7961: if (mem_base != xmlMemBlocks()) {
! 7962: printf("Leak of %d blocks found in xmlShellSave",
! 7963: xmlMemBlocks() - mem_base);
! 7964: test_ret++;
! 7965: printf(" %d", n_ctxt);
! 7966: printf(" %d", n_filename);
! 7967: printf(" %d", n_node);
! 7968: printf(" %d", n_node2);
! 7969: printf("\n");
! 7970: }
! 7971: }
! 7972: }
! 7973: }
! 7974: }
! 7975: function_tests++;
! 7976: #endif
! 7977:
! 7978: return(test_ret);
! 7979: }
! 7980:
! 7981:
! 7982: static int
! 7983: test_xmlShellValidate(void) {
! 7984: int test_ret = 0;
! 7985:
! 7986: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_VALID_ENABLED)
! 7987: int mem_base;
! 7988: int ret_val;
! 7989: xmlShellCtxtPtr ctxt; /* the shell context */
! 7990: int n_ctxt;
! 7991: char * dtd; /* the DTD URI (optional) */
! 7992: int n_dtd;
! 7993: xmlNodePtr node; /* unused */
! 7994: int n_node;
! 7995: xmlNodePtr node2; /* unused */
! 7996: int n_node2;
! 7997:
! 7998: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
! 7999: for (n_dtd = 0;n_dtd < gen_nb_char_ptr;n_dtd++) {
! 8000: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 8001: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
! 8002: mem_base = xmlMemBlocks();
! 8003: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
! 8004: dtd = gen_char_ptr(n_dtd, 1);
! 8005: node = gen_xmlNodePtr(n_node, 2);
! 8006: node2 = gen_xmlNodePtr(n_node2, 3);
! 8007:
! 8008: ret_val = xmlShellValidate(ctxt, dtd, node, node2);
! 8009: desret_int(ret_val);
! 8010: call_tests++;
! 8011: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
! 8012: des_char_ptr(n_dtd, dtd, 1);
! 8013: des_xmlNodePtr(n_node, node, 2);
! 8014: des_xmlNodePtr(n_node2, node2, 3);
! 8015: xmlResetLastError();
! 8016: if (mem_base != xmlMemBlocks()) {
! 8017: printf("Leak of %d blocks found in xmlShellValidate",
! 8018: xmlMemBlocks() - mem_base);
! 8019: test_ret++;
! 8020: printf(" %d", n_ctxt);
! 8021: printf(" %d", n_dtd);
! 8022: printf(" %d", n_node);
! 8023: printf(" %d", n_node2);
! 8024: printf("\n");
! 8025: }
! 8026: }
! 8027: }
! 8028: }
! 8029: }
! 8030: function_tests++;
! 8031: #endif
! 8032:
! 8033: return(test_ret);
! 8034: }
! 8035:
! 8036:
! 8037: static int
! 8038: test_xmlShellWrite(void) {
! 8039: int test_ret = 0;
! 8040:
! 8041: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 8042: int mem_base;
! 8043: int ret_val;
! 8044: xmlShellCtxtPtr ctxt; /* the shell context */
! 8045: int n_ctxt;
! 8046: char * filename; /* the file name */
! 8047: int n_filename;
! 8048: xmlNodePtr node; /* a node in the tree */
! 8049: int n_node;
! 8050: xmlNodePtr node2; /* unused */
! 8051: int n_node2;
! 8052:
! 8053: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
! 8054: for (n_filename = 0;n_filename < gen_nb_char_ptr;n_filename++) {
! 8055: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 8056: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
! 8057: mem_base = xmlMemBlocks();
! 8058: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
! 8059: filename = gen_char_ptr(n_filename, 1);
! 8060: node = gen_xmlNodePtr(n_node, 2);
! 8061: node2 = gen_xmlNodePtr(n_node2, 3);
! 8062:
! 8063: ret_val = xmlShellWrite(ctxt, filename, node, node2);
! 8064: desret_int(ret_val);
! 8065: call_tests++;
! 8066: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
! 8067: des_char_ptr(n_filename, filename, 1);
! 8068: des_xmlNodePtr(n_node, node, 2);
! 8069: des_xmlNodePtr(n_node2, node2, 3);
! 8070: xmlResetLastError();
! 8071: if (mem_base != xmlMemBlocks()) {
! 8072: printf("Leak of %d blocks found in xmlShellWrite",
! 8073: xmlMemBlocks() - mem_base);
! 8074: test_ret++;
! 8075: printf(" %d", n_ctxt);
! 8076: printf(" %d", n_filename);
! 8077: printf(" %d", n_node);
! 8078: printf(" %d", n_node2);
! 8079: printf("\n");
! 8080: }
! 8081: }
! 8082: }
! 8083: }
! 8084: }
! 8085: function_tests++;
! 8086: #endif
! 8087:
! 8088: return(test_ret);
! 8089: }
! 8090:
! 8091: static int
! 8092: test_debugXML(void) {
! 8093: int test_ret = 0;
! 8094:
! 8095: if (quiet == 0) printf("Testing debugXML : 25 of 28 functions ...\n");
! 8096: test_ret += test_xmlBoolToText();
! 8097: test_ret += test_xmlDebugCheckDocument();
! 8098: test_ret += test_xmlDebugDumpAttr();
! 8099: test_ret += test_xmlDebugDumpAttrList();
! 8100: test_ret += test_xmlDebugDumpDTD();
! 8101: test_ret += test_xmlDebugDumpDocument();
! 8102: test_ret += test_xmlDebugDumpDocumentHead();
! 8103: test_ret += test_xmlDebugDumpEntities();
! 8104: test_ret += test_xmlDebugDumpNode();
! 8105: test_ret += test_xmlDebugDumpNodeList();
! 8106: test_ret += test_xmlDebugDumpOneNode();
! 8107: test_ret += test_xmlDebugDumpString();
! 8108: test_ret += test_xmlLsCountNode();
! 8109: test_ret += test_xmlLsOneNode();
! 8110: test_ret += test_xmlShell();
! 8111: test_ret += test_xmlShellBase();
! 8112: test_ret += test_xmlShellCat();
! 8113: test_ret += test_xmlShellDir();
! 8114: test_ret += test_xmlShellDu();
! 8115: test_ret += test_xmlShellList();
! 8116: test_ret += test_xmlShellLoad();
! 8117: test_ret += test_xmlShellPrintXPathResult();
! 8118: test_ret += test_xmlShellPwd();
! 8119: test_ret += test_xmlShellSave();
! 8120: test_ret += test_xmlShellValidate();
! 8121: test_ret += test_xmlShellWrite();
! 8122:
! 8123: if (test_ret != 0)
! 8124: printf("Module debugXML: %d errors\n", test_ret);
! 8125: return(test_ret);
! 8126: }
! 8127:
! 8128: static int
! 8129: test_xmlDictCleanup(void) {
! 8130: int test_ret = 0;
! 8131:
! 8132: int mem_base;
! 8133:
! 8134: mem_base = xmlMemBlocks();
! 8135:
! 8136: xmlDictCleanup();
! 8137: call_tests++;
! 8138: xmlResetLastError();
! 8139: if (mem_base != xmlMemBlocks()) {
! 8140: printf("Leak of %d blocks found in xmlDictCleanup",
! 8141: xmlMemBlocks() - mem_base);
! 8142: test_ret++;
! 8143: printf("\n");
! 8144: }
! 8145: function_tests++;
! 8146:
! 8147: return(test_ret);
! 8148: }
! 8149:
! 8150:
! 8151: static int
! 8152: test_xmlDictCreate(void) {
! 8153: int test_ret = 0;
! 8154:
! 8155: int mem_base;
! 8156: xmlDictPtr ret_val;
! 8157:
! 8158: mem_base = xmlMemBlocks();
! 8159:
! 8160: ret_val = xmlDictCreate();
! 8161: desret_xmlDictPtr(ret_val);
! 8162: call_tests++;
! 8163: xmlResetLastError();
! 8164: if (mem_base != xmlMemBlocks()) {
! 8165: printf("Leak of %d blocks found in xmlDictCreate",
! 8166: xmlMemBlocks() - mem_base);
! 8167: test_ret++;
! 8168: printf("\n");
! 8169: }
! 8170: function_tests++;
! 8171:
! 8172: return(test_ret);
! 8173: }
! 8174:
! 8175:
! 8176: static int
! 8177: test_xmlDictCreateSub(void) {
! 8178: int test_ret = 0;
! 8179:
! 8180: int mem_base;
! 8181: xmlDictPtr ret_val;
! 8182: xmlDictPtr sub; /* an existing dictionnary */
! 8183: int n_sub;
! 8184:
! 8185: for (n_sub = 0;n_sub < gen_nb_xmlDictPtr;n_sub++) {
! 8186: mem_base = xmlMemBlocks();
! 8187: sub = gen_xmlDictPtr(n_sub, 0);
! 8188:
! 8189: ret_val = xmlDictCreateSub(sub);
! 8190: desret_xmlDictPtr(ret_val);
! 8191: call_tests++;
! 8192: des_xmlDictPtr(n_sub, sub, 0);
! 8193: xmlResetLastError();
! 8194: if (mem_base != xmlMemBlocks()) {
! 8195: printf("Leak of %d blocks found in xmlDictCreateSub",
! 8196: xmlMemBlocks() - mem_base);
! 8197: test_ret++;
! 8198: printf(" %d", n_sub);
! 8199: printf("\n");
! 8200: }
! 8201: }
! 8202: function_tests++;
! 8203:
! 8204: return(test_ret);
! 8205: }
! 8206:
! 8207:
! 8208: static int
! 8209: test_xmlDictExists(void) {
! 8210: int test_ret = 0;
! 8211:
! 8212: int mem_base;
! 8213: const xmlChar * ret_val;
! 8214: xmlDictPtr dict; /* the dictionnary */
! 8215: int n_dict;
! 8216: xmlChar * name; /* the name of the userdata */
! 8217: int n_name;
! 8218: int len; /* the length of the name, if -1 it is recomputed */
! 8219: int n_len;
! 8220:
! 8221: for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
! 8222: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 8223: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 8224: mem_base = xmlMemBlocks();
! 8225: dict = gen_xmlDictPtr(n_dict, 0);
! 8226: name = gen_const_xmlChar_ptr(n_name, 1);
! 8227: len = gen_int(n_len, 2);
! 8228:
! 8229: ret_val = xmlDictExists(dict, (const xmlChar *)name, len);
! 8230: desret_const_xmlChar_ptr(ret_val);
! 8231: call_tests++;
! 8232: des_xmlDictPtr(n_dict, dict, 0);
! 8233: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 8234: des_int(n_len, len, 2);
! 8235: xmlResetLastError();
! 8236: if (mem_base != xmlMemBlocks()) {
! 8237: printf("Leak of %d blocks found in xmlDictExists",
! 8238: xmlMemBlocks() - mem_base);
! 8239: test_ret++;
! 8240: printf(" %d", n_dict);
! 8241: printf(" %d", n_name);
! 8242: printf(" %d", n_len);
! 8243: printf("\n");
! 8244: }
! 8245: }
! 8246: }
! 8247: }
! 8248: function_tests++;
! 8249:
! 8250: return(test_ret);
! 8251: }
! 8252:
! 8253:
! 8254: static int
! 8255: test_xmlDictLookup(void) {
! 8256: int test_ret = 0;
! 8257:
! 8258: int mem_base;
! 8259: const xmlChar * ret_val;
! 8260: xmlDictPtr dict; /* the dictionnary */
! 8261: int n_dict;
! 8262: xmlChar * name; /* the name of the userdata */
! 8263: int n_name;
! 8264: int len; /* the length of the name, if -1 it is recomputed */
! 8265: int n_len;
! 8266:
! 8267: for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
! 8268: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 8269: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 8270: mem_base = xmlMemBlocks();
! 8271: dict = gen_xmlDictPtr(n_dict, 0);
! 8272: name = gen_const_xmlChar_ptr(n_name, 1);
! 8273: len = gen_int(n_len, 2);
! 8274:
! 8275: ret_val = xmlDictLookup(dict, (const xmlChar *)name, len);
! 8276: desret_const_xmlChar_ptr(ret_val);
! 8277: call_tests++;
! 8278: des_xmlDictPtr(n_dict, dict, 0);
! 8279: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 8280: des_int(n_len, len, 2);
! 8281: xmlResetLastError();
! 8282: if (mem_base != xmlMemBlocks()) {
! 8283: printf("Leak of %d blocks found in xmlDictLookup",
! 8284: xmlMemBlocks() - mem_base);
! 8285: test_ret++;
! 8286: printf(" %d", n_dict);
! 8287: printf(" %d", n_name);
! 8288: printf(" %d", n_len);
! 8289: printf("\n");
! 8290: }
! 8291: }
! 8292: }
! 8293: }
! 8294: function_tests++;
! 8295:
! 8296: return(test_ret);
! 8297: }
! 8298:
! 8299:
! 8300: static int
! 8301: test_xmlDictOwns(void) {
! 8302: int test_ret = 0;
! 8303:
! 8304: int mem_base;
! 8305: int ret_val;
! 8306: xmlDictPtr dict; /* the dictionnary */
! 8307: int n_dict;
! 8308: xmlChar * str; /* the string */
! 8309: int n_str;
! 8310:
! 8311: for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
! 8312: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 8313: mem_base = xmlMemBlocks();
! 8314: dict = gen_xmlDictPtr(n_dict, 0);
! 8315: str = gen_const_xmlChar_ptr(n_str, 1);
! 8316:
! 8317: ret_val = xmlDictOwns(dict, (const xmlChar *)str);
! 8318: desret_int(ret_val);
! 8319: call_tests++;
! 8320: des_xmlDictPtr(n_dict, dict, 0);
! 8321: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
! 8322: xmlResetLastError();
! 8323: if (mem_base != xmlMemBlocks()) {
! 8324: printf("Leak of %d blocks found in xmlDictOwns",
! 8325: xmlMemBlocks() - mem_base);
! 8326: test_ret++;
! 8327: printf(" %d", n_dict);
! 8328: printf(" %d", n_str);
! 8329: printf("\n");
! 8330: }
! 8331: }
! 8332: }
! 8333: function_tests++;
! 8334:
! 8335: return(test_ret);
! 8336: }
! 8337:
! 8338:
! 8339: static int
! 8340: test_xmlDictQLookup(void) {
! 8341: int test_ret = 0;
! 8342:
! 8343: int mem_base;
! 8344: const xmlChar * ret_val;
! 8345: xmlDictPtr dict; /* the dictionnary */
! 8346: int n_dict;
! 8347: xmlChar * prefix; /* the prefix */
! 8348: int n_prefix;
! 8349: xmlChar * name; /* the name */
! 8350: int n_name;
! 8351:
! 8352: for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
! 8353: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
! 8354: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 8355: mem_base = xmlMemBlocks();
! 8356: dict = gen_xmlDictPtr(n_dict, 0);
! 8357: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
! 8358: name = gen_const_xmlChar_ptr(n_name, 2);
! 8359:
! 8360: ret_val = xmlDictQLookup(dict, (const xmlChar *)prefix, (const xmlChar *)name);
! 8361: desret_const_xmlChar_ptr(ret_val);
! 8362: call_tests++;
! 8363: des_xmlDictPtr(n_dict, dict, 0);
! 8364: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
! 8365: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 8366: xmlResetLastError();
! 8367: if (mem_base != xmlMemBlocks()) {
! 8368: printf("Leak of %d blocks found in xmlDictQLookup",
! 8369: xmlMemBlocks() - mem_base);
! 8370: test_ret++;
! 8371: printf(" %d", n_dict);
! 8372: printf(" %d", n_prefix);
! 8373: printf(" %d", n_name);
! 8374: printf("\n");
! 8375: }
! 8376: }
! 8377: }
! 8378: }
! 8379: function_tests++;
! 8380:
! 8381: return(test_ret);
! 8382: }
! 8383:
! 8384:
! 8385: static int
! 8386: test_xmlDictReference(void) {
! 8387: int test_ret = 0;
! 8388:
! 8389: int mem_base;
! 8390: int ret_val;
! 8391: xmlDictPtr dict; /* the dictionnary */
! 8392: int n_dict;
! 8393:
! 8394: for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
! 8395: mem_base = xmlMemBlocks();
! 8396: dict = gen_xmlDictPtr(n_dict, 0);
! 8397:
! 8398: ret_val = xmlDictReference(dict);
! 8399: xmlDictFree(dict);
! 8400: desret_int(ret_val);
! 8401: call_tests++;
! 8402: des_xmlDictPtr(n_dict, dict, 0);
! 8403: xmlResetLastError();
! 8404: if (mem_base != xmlMemBlocks()) {
! 8405: printf("Leak of %d blocks found in xmlDictReference",
! 8406: xmlMemBlocks() - mem_base);
! 8407: test_ret++;
! 8408: printf(" %d", n_dict);
! 8409: printf("\n");
! 8410: }
! 8411: }
! 8412: function_tests++;
! 8413:
! 8414: return(test_ret);
! 8415: }
! 8416:
! 8417:
! 8418: static int
! 8419: test_xmlDictSize(void) {
! 8420: int test_ret = 0;
! 8421:
! 8422: int mem_base;
! 8423: int ret_val;
! 8424: xmlDictPtr dict; /* the dictionnary */
! 8425: int n_dict;
! 8426:
! 8427: for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
! 8428: mem_base = xmlMemBlocks();
! 8429: dict = gen_xmlDictPtr(n_dict, 0);
! 8430:
! 8431: ret_val = xmlDictSize(dict);
! 8432: desret_int(ret_val);
! 8433: call_tests++;
! 8434: des_xmlDictPtr(n_dict, dict, 0);
! 8435: xmlResetLastError();
! 8436: if (mem_base != xmlMemBlocks()) {
! 8437: printf("Leak of %d blocks found in xmlDictSize",
! 8438: xmlMemBlocks() - mem_base);
! 8439: test_ret++;
! 8440: printf(" %d", n_dict);
! 8441: printf("\n");
! 8442: }
! 8443: }
! 8444: function_tests++;
! 8445:
! 8446: return(test_ret);
! 8447: }
! 8448:
! 8449: static int
! 8450: test_dict(void) {
! 8451: int test_ret = 0;
! 8452:
! 8453: if (quiet == 0) printf("Testing dict : 9 of 10 functions ...\n");
! 8454: test_ret += test_xmlDictCleanup();
! 8455: test_ret += test_xmlDictCreate();
! 8456: test_ret += test_xmlDictCreateSub();
! 8457: test_ret += test_xmlDictExists();
! 8458: test_ret += test_xmlDictLookup();
! 8459: test_ret += test_xmlDictOwns();
! 8460: test_ret += test_xmlDictQLookup();
! 8461: test_ret += test_xmlDictReference();
! 8462: test_ret += test_xmlDictSize();
! 8463:
! 8464: if (test_ret != 0)
! 8465: printf("Module dict: %d errors\n", test_ret);
! 8466: return(test_ret);
! 8467: }
! 8468:
! 8469: static int
! 8470: test_UTF8Toisolat1(void) {
! 8471: int test_ret = 0;
! 8472:
! 8473: #if defined(LIBXML_OUTPUT_ENABLED)
! 8474: #ifdef LIBXML_OUTPUT_ENABLED
! 8475: int mem_base;
! 8476: int ret_val;
! 8477: unsigned char * out; /* a pointer to an array of bytes to store the result */
! 8478: int n_out;
! 8479: int * outlen; /* the length of @out */
! 8480: int n_outlen;
! 8481: unsigned char * in; /* a pointer to an array of UTF-8 chars */
! 8482: int n_in;
! 8483: int * inlen; /* the length of @in */
! 8484: int n_inlen;
! 8485:
! 8486: for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
! 8487: for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
! 8488: for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
! 8489: for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
! 8490: mem_base = xmlMemBlocks();
! 8491: out = gen_unsigned_char_ptr(n_out, 0);
! 8492: outlen = gen_int_ptr(n_outlen, 1);
! 8493: in = gen_const_unsigned_char_ptr(n_in, 2);
! 8494: inlen = gen_int_ptr(n_inlen, 3);
! 8495:
! 8496: ret_val = UTF8Toisolat1(out, outlen, (const unsigned char *)in, inlen);
! 8497: desret_int(ret_val);
! 8498: call_tests++;
! 8499: des_unsigned_char_ptr(n_out, out, 0);
! 8500: des_int_ptr(n_outlen, outlen, 1);
! 8501: des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2);
! 8502: des_int_ptr(n_inlen, inlen, 3);
! 8503: xmlResetLastError();
! 8504: if (mem_base != xmlMemBlocks()) {
! 8505: printf("Leak of %d blocks found in UTF8Toisolat1",
! 8506: xmlMemBlocks() - mem_base);
! 8507: test_ret++;
! 8508: printf(" %d", n_out);
! 8509: printf(" %d", n_outlen);
! 8510: printf(" %d", n_in);
! 8511: printf(" %d", n_inlen);
! 8512: printf("\n");
! 8513: }
! 8514: }
! 8515: }
! 8516: }
! 8517: }
! 8518: function_tests++;
! 8519: #endif
! 8520: #endif
! 8521:
! 8522: return(test_ret);
! 8523: }
! 8524:
! 8525:
! 8526: static int
! 8527: test_isolat1ToUTF8(void) {
! 8528: int test_ret = 0;
! 8529:
! 8530: int mem_base;
! 8531: int ret_val;
! 8532: unsigned char * out; /* a pointer to an array of bytes to store the result */
! 8533: int n_out;
! 8534: int * outlen; /* the length of @out */
! 8535: int n_outlen;
! 8536: unsigned char * in; /* a pointer to an array of ISO Latin 1 chars */
! 8537: int n_in;
! 8538: int * inlen; /* the length of @in */
! 8539: int n_inlen;
! 8540:
! 8541: for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
! 8542: for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
! 8543: for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
! 8544: for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
! 8545: mem_base = xmlMemBlocks();
! 8546: out = gen_unsigned_char_ptr(n_out, 0);
! 8547: outlen = gen_int_ptr(n_outlen, 1);
! 8548: in = gen_const_unsigned_char_ptr(n_in, 2);
! 8549: inlen = gen_int_ptr(n_inlen, 3);
! 8550:
! 8551: ret_val = isolat1ToUTF8(out, outlen, (const unsigned char *)in, inlen);
! 8552: desret_int(ret_val);
! 8553: call_tests++;
! 8554: des_unsigned_char_ptr(n_out, out, 0);
! 8555: des_int_ptr(n_outlen, outlen, 1);
! 8556: des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2);
! 8557: des_int_ptr(n_inlen, inlen, 3);
! 8558: xmlResetLastError();
! 8559: if (mem_base != xmlMemBlocks()) {
! 8560: printf("Leak of %d blocks found in isolat1ToUTF8",
! 8561: xmlMemBlocks() - mem_base);
! 8562: test_ret++;
! 8563: printf(" %d", n_out);
! 8564: printf(" %d", n_outlen);
! 8565: printf(" %d", n_in);
! 8566: printf(" %d", n_inlen);
! 8567: printf("\n");
! 8568: }
! 8569: }
! 8570: }
! 8571: }
! 8572: }
! 8573: function_tests++;
! 8574:
! 8575: return(test_ret);
! 8576: }
! 8577:
! 8578:
! 8579: static int
! 8580: test_xmlAddEncodingAlias(void) {
! 8581: int test_ret = 0;
! 8582:
! 8583: int ret_val;
! 8584: char * name; /* the encoding name as parsed, in UTF-8 format (ASCII actually) */
! 8585: int n_name;
! 8586: char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */
! 8587: int n_alias;
! 8588:
! 8589: for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
! 8590: for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) {
! 8591: name = gen_const_char_ptr(n_name, 0);
! 8592: alias = gen_const_char_ptr(n_alias, 1);
! 8593:
! 8594: ret_val = xmlAddEncodingAlias((const char *)name, (const char *)alias);
! 8595: desret_int(ret_val);
! 8596: call_tests++;
! 8597: des_const_char_ptr(n_name, (const char *)name, 0);
! 8598: des_const_char_ptr(n_alias, (const char *)alias, 1);
! 8599: xmlResetLastError();
! 8600: }
! 8601: }
! 8602: function_tests++;
! 8603:
! 8604: return(test_ret);
! 8605: }
! 8606:
! 8607:
! 8608: #define gen_nb_xmlCharEncodingHandler_ptr 1
! 8609: static xmlCharEncodingHandler * gen_xmlCharEncodingHandler_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 8610: return(NULL);
! 8611: }
! 8612: static void des_xmlCharEncodingHandler_ptr(int no ATTRIBUTE_UNUSED, xmlCharEncodingHandler * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 8613: }
! 8614:
! 8615: static int
! 8616: test_xmlCharEncCloseFunc(void) {
! 8617: int test_ret = 0;
! 8618:
! 8619: int mem_base;
! 8620: int ret_val;
! 8621: xmlCharEncodingHandler * handler; /* char enconding transformation data structure */
! 8622: int n_handler;
! 8623:
! 8624: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
! 8625: mem_base = xmlMemBlocks();
! 8626: handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
! 8627:
! 8628: ret_val = xmlCharEncCloseFunc(handler);
! 8629: desret_int(ret_val);
! 8630: call_tests++;
! 8631: des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
! 8632: xmlResetLastError();
! 8633: if (mem_base != xmlMemBlocks()) {
! 8634: printf("Leak of %d blocks found in xmlCharEncCloseFunc",
! 8635: xmlMemBlocks() - mem_base);
! 8636: test_ret++;
! 8637: printf(" %d", n_handler);
! 8638: printf("\n");
! 8639: }
! 8640: }
! 8641: function_tests++;
! 8642:
! 8643: return(test_ret);
! 8644: }
! 8645:
! 8646:
! 8647: static int
! 8648: test_xmlCharEncFirstLine(void) {
! 8649: int test_ret = 0;
! 8650:
! 8651: int mem_base;
! 8652: int ret_val;
! 8653: xmlCharEncodingHandler * handler; /* char enconding transformation data structure */
! 8654: int n_handler;
! 8655: xmlBufferPtr out; /* an xmlBuffer for the output. */
! 8656: int n_out;
! 8657: xmlBufferPtr in; /* an xmlBuffer for the input */
! 8658: int n_in;
! 8659:
! 8660: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
! 8661: for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) {
! 8662: for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) {
! 8663: mem_base = xmlMemBlocks();
! 8664: handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
! 8665: out = gen_xmlBufferPtr(n_out, 1);
! 8666: in = gen_xmlBufferPtr(n_in, 2);
! 8667:
! 8668: ret_val = xmlCharEncFirstLine(handler, out, in);
! 8669: desret_int(ret_val);
! 8670: call_tests++;
! 8671: des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
! 8672: des_xmlBufferPtr(n_out, out, 1);
! 8673: des_xmlBufferPtr(n_in, in, 2);
! 8674: xmlResetLastError();
! 8675: if (mem_base != xmlMemBlocks()) {
! 8676: printf("Leak of %d blocks found in xmlCharEncFirstLine",
! 8677: xmlMemBlocks() - mem_base);
! 8678: test_ret++;
! 8679: printf(" %d", n_handler);
! 8680: printf(" %d", n_out);
! 8681: printf(" %d", n_in);
! 8682: printf("\n");
! 8683: }
! 8684: }
! 8685: }
! 8686: }
! 8687: function_tests++;
! 8688:
! 8689: return(test_ret);
! 8690: }
! 8691:
! 8692:
! 8693: static int
! 8694: test_xmlCharEncInFunc(void) {
! 8695: int test_ret = 0;
! 8696:
! 8697: int mem_base;
! 8698: int ret_val;
! 8699: xmlCharEncodingHandler * handler; /* char encoding transformation data structure */
! 8700: int n_handler;
! 8701: xmlBufferPtr out; /* an xmlBuffer for the output. */
! 8702: int n_out;
! 8703: xmlBufferPtr in; /* an xmlBuffer for the input */
! 8704: int n_in;
! 8705:
! 8706: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
! 8707: for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) {
! 8708: for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) {
! 8709: mem_base = xmlMemBlocks();
! 8710: handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
! 8711: out = gen_xmlBufferPtr(n_out, 1);
! 8712: in = gen_xmlBufferPtr(n_in, 2);
! 8713:
! 8714: ret_val = xmlCharEncInFunc(handler, out, in);
! 8715: desret_int(ret_val);
! 8716: call_tests++;
! 8717: des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
! 8718: des_xmlBufferPtr(n_out, out, 1);
! 8719: des_xmlBufferPtr(n_in, in, 2);
! 8720: xmlResetLastError();
! 8721: if (mem_base != xmlMemBlocks()) {
! 8722: printf("Leak of %d blocks found in xmlCharEncInFunc",
! 8723: xmlMemBlocks() - mem_base);
! 8724: test_ret++;
! 8725: printf(" %d", n_handler);
! 8726: printf(" %d", n_out);
! 8727: printf(" %d", n_in);
! 8728: printf("\n");
! 8729: }
! 8730: }
! 8731: }
! 8732: }
! 8733: function_tests++;
! 8734:
! 8735: return(test_ret);
! 8736: }
! 8737:
! 8738:
! 8739: static int
! 8740: test_xmlCharEncOutFunc(void) {
! 8741: int test_ret = 0;
! 8742:
! 8743: int mem_base;
! 8744: int ret_val;
! 8745: xmlCharEncodingHandler * handler; /* char enconding transformation data structure */
! 8746: int n_handler;
! 8747: xmlBufferPtr out; /* an xmlBuffer for the output. */
! 8748: int n_out;
! 8749: xmlBufferPtr in; /* an xmlBuffer for the input */
! 8750: int n_in;
! 8751:
! 8752: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
! 8753: for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) {
! 8754: for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) {
! 8755: mem_base = xmlMemBlocks();
! 8756: handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
! 8757: out = gen_xmlBufferPtr(n_out, 1);
! 8758: in = gen_xmlBufferPtr(n_in, 2);
! 8759:
! 8760: ret_val = xmlCharEncOutFunc(handler, out, in);
! 8761: desret_int(ret_val);
! 8762: call_tests++;
! 8763: des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
! 8764: des_xmlBufferPtr(n_out, out, 1);
! 8765: des_xmlBufferPtr(n_in, in, 2);
! 8766: xmlResetLastError();
! 8767: if (mem_base != xmlMemBlocks()) {
! 8768: printf("Leak of %d blocks found in xmlCharEncOutFunc",
! 8769: xmlMemBlocks() - mem_base);
! 8770: test_ret++;
! 8771: printf(" %d", n_handler);
! 8772: printf(" %d", n_out);
! 8773: printf(" %d", n_in);
! 8774: printf("\n");
! 8775: }
! 8776: }
! 8777: }
! 8778: }
! 8779: function_tests++;
! 8780:
! 8781: return(test_ret);
! 8782: }
! 8783:
! 8784:
! 8785: static int
! 8786: test_xmlCleanupCharEncodingHandlers(void) {
! 8787: int test_ret = 0;
! 8788:
! 8789:
! 8790:
! 8791: xmlCleanupCharEncodingHandlers();
! 8792: call_tests++;
! 8793: xmlResetLastError();
! 8794: function_tests++;
! 8795:
! 8796: return(test_ret);
! 8797: }
! 8798:
! 8799:
! 8800: static int
! 8801: test_xmlCleanupEncodingAliases(void) {
! 8802: int test_ret = 0;
! 8803:
! 8804: int mem_base;
! 8805:
! 8806: mem_base = xmlMemBlocks();
! 8807:
! 8808: xmlCleanupEncodingAliases();
! 8809: call_tests++;
! 8810: xmlResetLastError();
! 8811: if (mem_base != xmlMemBlocks()) {
! 8812: printf("Leak of %d blocks found in xmlCleanupEncodingAliases",
! 8813: xmlMemBlocks() - mem_base);
! 8814: test_ret++;
! 8815: printf("\n");
! 8816: }
! 8817: function_tests++;
! 8818:
! 8819: return(test_ret);
! 8820: }
! 8821:
! 8822:
! 8823: static int
! 8824: test_xmlDelEncodingAlias(void) {
! 8825: int test_ret = 0;
! 8826:
! 8827: int mem_base;
! 8828: int ret_val;
! 8829: char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */
! 8830: int n_alias;
! 8831:
! 8832: for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) {
! 8833: mem_base = xmlMemBlocks();
! 8834: alias = gen_const_char_ptr(n_alias, 0);
! 8835:
! 8836: ret_val = xmlDelEncodingAlias((const char *)alias);
! 8837: desret_int(ret_val);
! 8838: call_tests++;
! 8839: des_const_char_ptr(n_alias, (const char *)alias, 0);
! 8840: xmlResetLastError();
! 8841: if (mem_base != xmlMemBlocks()) {
! 8842: printf("Leak of %d blocks found in xmlDelEncodingAlias",
! 8843: xmlMemBlocks() - mem_base);
! 8844: test_ret++;
! 8845: printf(" %d", n_alias);
! 8846: printf("\n");
! 8847: }
! 8848: }
! 8849: function_tests++;
! 8850:
! 8851: return(test_ret);
! 8852: }
! 8853:
! 8854:
! 8855: static int
! 8856: test_xmlDetectCharEncoding(void) {
! 8857: int test_ret = 0;
! 8858:
! 8859: int mem_base;
! 8860: xmlCharEncoding ret_val;
! 8861: unsigned char * in; /* a pointer to the first bytes of the XML entity, must be at least 2 bytes long (at least 4 if encoding is UTF4 variant). */
! 8862: int n_in;
! 8863: int len; /* pointer to the length of the buffer */
! 8864: int n_len;
! 8865:
! 8866: for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
! 8867: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 8868: mem_base = xmlMemBlocks();
! 8869: in = gen_const_unsigned_char_ptr(n_in, 0);
! 8870: len = gen_int(n_len, 1);
! 8871:
! 8872: ret_val = xmlDetectCharEncoding((const unsigned char *)in, len);
! 8873: desret_xmlCharEncoding(ret_val);
! 8874: call_tests++;
! 8875: des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 0);
! 8876: des_int(n_len, len, 1);
! 8877: xmlResetLastError();
! 8878: if (mem_base != xmlMemBlocks()) {
! 8879: printf("Leak of %d blocks found in xmlDetectCharEncoding",
! 8880: xmlMemBlocks() - mem_base);
! 8881: test_ret++;
! 8882: printf(" %d", n_in);
! 8883: printf(" %d", n_len);
! 8884: printf("\n");
! 8885: }
! 8886: }
! 8887: }
! 8888: function_tests++;
! 8889:
! 8890: return(test_ret);
! 8891: }
! 8892:
! 8893:
! 8894: static int
! 8895: test_xmlFindCharEncodingHandler(void) {
! 8896: int test_ret = 0;
! 8897:
! 8898:
! 8899: /* missing type support */
! 8900: return(test_ret);
! 8901: }
! 8902:
! 8903:
! 8904: static int
! 8905: test_xmlGetCharEncodingHandler(void) {
! 8906: int test_ret = 0;
! 8907:
! 8908:
! 8909: /* missing type support */
! 8910: return(test_ret);
! 8911: }
! 8912:
! 8913:
! 8914: static int
! 8915: test_xmlGetCharEncodingName(void) {
! 8916: int test_ret = 0;
! 8917:
! 8918: int mem_base;
! 8919: const char * ret_val;
! 8920: xmlCharEncoding enc; /* the encoding */
! 8921: int n_enc;
! 8922:
! 8923: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
! 8924: mem_base = xmlMemBlocks();
! 8925: enc = gen_xmlCharEncoding(n_enc, 0);
! 8926:
! 8927: ret_val = xmlGetCharEncodingName(enc);
! 8928: desret_const_char_ptr(ret_val);
! 8929: call_tests++;
! 8930: des_xmlCharEncoding(n_enc, enc, 0);
! 8931: xmlResetLastError();
! 8932: if (mem_base != xmlMemBlocks()) {
! 8933: printf("Leak of %d blocks found in xmlGetCharEncodingName",
! 8934: xmlMemBlocks() - mem_base);
! 8935: test_ret++;
! 8936: printf(" %d", n_enc);
! 8937: printf("\n");
! 8938: }
! 8939: }
! 8940: function_tests++;
! 8941:
! 8942: return(test_ret);
! 8943: }
! 8944:
! 8945:
! 8946: static int
! 8947: test_xmlGetEncodingAlias(void) {
! 8948: int test_ret = 0;
! 8949:
! 8950: int mem_base;
! 8951: const char * ret_val;
! 8952: char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */
! 8953: int n_alias;
! 8954:
! 8955: for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) {
! 8956: mem_base = xmlMemBlocks();
! 8957: alias = gen_const_char_ptr(n_alias, 0);
! 8958:
! 8959: ret_val = xmlGetEncodingAlias((const char *)alias);
! 8960: desret_const_char_ptr(ret_val);
! 8961: call_tests++;
! 8962: des_const_char_ptr(n_alias, (const char *)alias, 0);
! 8963: xmlResetLastError();
! 8964: if (mem_base != xmlMemBlocks()) {
! 8965: printf("Leak of %d blocks found in xmlGetEncodingAlias",
! 8966: xmlMemBlocks() - mem_base);
! 8967: test_ret++;
! 8968: printf(" %d", n_alias);
! 8969: printf("\n");
! 8970: }
! 8971: }
! 8972: function_tests++;
! 8973:
! 8974: return(test_ret);
! 8975: }
! 8976:
! 8977:
! 8978: static int
! 8979: test_xmlInitCharEncodingHandlers(void) {
! 8980: int test_ret = 0;
! 8981:
! 8982:
! 8983:
! 8984: xmlInitCharEncodingHandlers();
! 8985: call_tests++;
! 8986: xmlResetLastError();
! 8987: function_tests++;
! 8988:
! 8989: return(test_ret);
! 8990: }
! 8991:
! 8992:
! 8993: static int
! 8994: test_xmlNewCharEncodingHandler(void) {
! 8995: int test_ret = 0;
! 8996:
! 8997:
! 8998: /* missing type support */
! 8999: return(test_ret);
! 9000: }
! 9001:
! 9002:
! 9003: static int
! 9004: test_xmlParseCharEncoding(void) {
! 9005: int test_ret = 0;
! 9006:
! 9007: int mem_base;
! 9008: xmlCharEncoding ret_val;
! 9009: char * name; /* the encoding name as parsed, in UTF-8 format (ASCII actually) */
! 9010: int n_name;
! 9011:
! 9012: for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
! 9013: mem_base = xmlMemBlocks();
! 9014: name = gen_const_char_ptr(n_name, 0);
! 9015:
! 9016: ret_val = xmlParseCharEncoding((const char *)name);
! 9017: desret_xmlCharEncoding(ret_val);
! 9018: call_tests++;
! 9019: des_const_char_ptr(n_name, (const char *)name, 0);
! 9020: xmlResetLastError();
! 9021: if (mem_base != xmlMemBlocks()) {
! 9022: printf("Leak of %d blocks found in xmlParseCharEncoding",
! 9023: xmlMemBlocks() - mem_base);
! 9024: test_ret++;
! 9025: printf(" %d", n_name);
! 9026: printf("\n");
! 9027: }
! 9028: }
! 9029: function_tests++;
! 9030:
! 9031: return(test_ret);
! 9032: }
! 9033:
! 9034:
! 9035: #define gen_nb_xmlCharEncodingHandlerPtr 1
! 9036: static xmlCharEncodingHandlerPtr gen_xmlCharEncodingHandlerPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 9037: return(NULL);
! 9038: }
! 9039: static void des_xmlCharEncodingHandlerPtr(int no ATTRIBUTE_UNUSED, xmlCharEncodingHandlerPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 9040: }
! 9041:
! 9042: static int
! 9043: test_xmlRegisterCharEncodingHandler(void) {
! 9044: int test_ret = 0;
! 9045:
! 9046: int mem_base;
! 9047: xmlCharEncodingHandlerPtr handler; /* the xmlCharEncodingHandlerPtr handler block */
! 9048: int n_handler;
! 9049:
! 9050: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) {
! 9051: mem_base = xmlMemBlocks();
! 9052: handler = gen_xmlCharEncodingHandlerPtr(n_handler, 0);
! 9053:
! 9054: xmlRegisterCharEncodingHandler(handler);
! 9055: call_tests++;
! 9056: des_xmlCharEncodingHandlerPtr(n_handler, handler, 0);
! 9057: xmlResetLastError();
! 9058: if (mem_base != xmlMemBlocks()) {
! 9059: printf("Leak of %d blocks found in xmlRegisterCharEncodingHandler",
! 9060: xmlMemBlocks() - mem_base);
! 9061: test_ret++;
! 9062: printf(" %d", n_handler);
! 9063: printf("\n");
! 9064: }
! 9065: }
! 9066: function_tests++;
! 9067:
! 9068: return(test_ret);
! 9069: }
! 9070:
! 9071: static int
! 9072: test_encoding(void) {
! 9073: int test_ret = 0;
! 9074:
! 9075: if (quiet == 0) printf("Testing encoding : 16 of 19 functions ...\n");
! 9076: test_ret += test_UTF8Toisolat1();
! 9077: test_ret += test_isolat1ToUTF8();
! 9078: test_ret += test_xmlAddEncodingAlias();
! 9079: test_ret += test_xmlCharEncCloseFunc();
! 9080: test_ret += test_xmlCharEncFirstLine();
! 9081: test_ret += test_xmlCharEncInFunc();
! 9082: test_ret += test_xmlCharEncOutFunc();
! 9083: test_ret += test_xmlCleanupCharEncodingHandlers();
! 9084: test_ret += test_xmlCleanupEncodingAliases();
! 9085: test_ret += test_xmlDelEncodingAlias();
! 9086: test_ret += test_xmlDetectCharEncoding();
! 9087: test_ret += test_xmlFindCharEncodingHandler();
! 9088: test_ret += test_xmlGetCharEncodingHandler();
! 9089: test_ret += test_xmlGetCharEncodingName();
! 9090: test_ret += test_xmlGetEncodingAlias();
! 9091: test_ret += test_xmlInitCharEncodingHandlers();
! 9092: test_ret += test_xmlNewCharEncodingHandler();
! 9093: test_ret += test_xmlParseCharEncoding();
! 9094: test_ret += test_xmlRegisterCharEncodingHandler();
! 9095:
! 9096: if (test_ret != 0)
! 9097: printf("Module encoding: %d errors\n", test_ret);
! 9098: return(test_ret);
! 9099: }
! 9100:
! 9101: static int
! 9102: test_xmlAddDocEntity(void) {
! 9103: int test_ret = 0;
! 9104:
! 9105: int mem_base;
! 9106: xmlEntityPtr ret_val;
! 9107: xmlDocPtr doc; /* the document */
! 9108: int n_doc;
! 9109: xmlChar * name; /* the entity name */
! 9110: int n_name;
! 9111: int type; /* the entity type XML_xxx_yyy_ENTITY */
! 9112: int n_type;
! 9113: xmlChar * ExternalID; /* the entity external ID if available */
! 9114: int n_ExternalID;
! 9115: xmlChar * SystemID; /* the entity system ID if available */
! 9116: int n_SystemID;
! 9117: xmlChar * content; /* the entity content */
! 9118: int n_content;
! 9119:
! 9120: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 9121: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 9122: for (n_type = 0;n_type < gen_nb_int;n_type++) {
! 9123: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
! 9124: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
! 9125: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 9126: mem_base = xmlMemBlocks();
! 9127: doc = gen_xmlDocPtr(n_doc, 0);
! 9128: name = gen_const_xmlChar_ptr(n_name, 1);
! 9129: type = gen_int(n_type, 2);
! 9130: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3);
! 9131: SystemID = gen_const_xmlChar_ptr(n_SystemID, 4);
! 9132: content = gen_const_xmlChar_ptr(n_content, 5);
! 9133:
! 9134: ret_val = xmlAddDocEntity(doc, (const xmlChar *)name, type, (const xmlChar *)ExternalID, (const xmlChar *)SystemID, (const xmlChar *)content);
! 9135: desret_xmlEntityPtr(ret_val);
! 9136: call_tests++;
! 9137: des_xmlDocPtr(n_doc, doc, 0);
! 9138: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 9139: des_int(n_type, type, 2);
! 9140: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 3);
! 9141: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 4);
! 9142: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 5);
! 9143: xmlResetLastError();
! 9144: if (mem_base != xmlMemBlocks()) {
! 9145: printf("Leak of %d blocks found in xmlAddDocEntity",
! 9146: xmlMemBlocks() - mem_base);
! 9147: test_ret++;
! 9148: printf(" %d", n_doc);
! 9149: printf(" %d", n_name);
! 9150: printf(" %d", n_type);
! 9151: printf(" %d", n_ExternalID);
! 9152: printf(" %d", n_SystemID);
! 9153: printf(" %d", n_content);
! 9154: printf("\n");
! 9155: }
! 9156: }
! 9157: }
! 9158: }
! 9159: }
! 9160: }
! 9161: }
! 9162: function_tests++;
! 9163:
! 9164: return(test_ret);
! 9165: }
! 9166:
! 9167:
! 9168: static int
! 9169: test_xmlAddDtdEntity(void) {
! 9170: int test_ret = 0;
! 9171:
! 9172: int mem_base;
! 9173: xmlEntityPtr ret_val;
! 9174: xmlDocPtr doc; /* the document */
! 9175: int n_doc;
! 9176: xmlChar * name; /* the entity name */
! 9177: int n_name;
! 9178: int type; /* the entity type XML_xxx_yyy_ENTITY */
! 9179: int n_type;
! 9180: xmlChar * ExternalID; /* the entity external ID if available */
! 9181: int n_ExternalID;
! 9182: xmlChar * SystemID; /* the entity system ID if available */
! 9183: int n_SystemID;
! 9184: xmlChar * content; /* the entity content */
! 9185: int n_content;
! 9186:
! 9187: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 9188: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 9189: for (n_type = 0;n_type < gen_nb_int;n_type++) {
! 9190: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
! 9191: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
! 9192: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 9193: mem_base = xmlMemBlocks();
! 9194: doc = gen_xmlDocPtr(n_doc, 0);
! 9195: name = gen_const_xmlChar_ptr(n_name, 1);
! 9196: type = gen_int(n_type, 2);
! 9197: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3);
! 9198: SystemID = gen_const_xmlChar_ptr(n_SystemID, 4);
! 9199: content = gen_const_xmlChar_ptr(n_content, 5);
! 9200:
! 9201: ret_val = xmlAddDtdEntity(doc, (const xmlChar *)name, type, (const xmlChar *)ExternalID, (const xmlChar *)SystemID, (const xmlChar *)content);
! 9202: desret_xmlEntityPtr(ret_val);
! 9203: call_tests++;
! 9204: des_xmlDocPtr(n_doc, doc, 0);
! 9205: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 9206: des_int(n_type, type, 2);
! 9207: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 3);
! 9208: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 4);
! 9209: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 5);
! 9210: xmlResetLastError();
! 9211: if (mem_base != xmlMemBlocks()) {
! 9212: printf("Leak of %d blocks found in xmlAddDtdEntity",
! 9213: xmlMemBlocks() - mem_base);
! 9214: test_ret++;
! 9215: printf(" %d", n_doc);
! 9216: printf(" %d", n_name);
! 9217: printf(" %d", n_type);
! 9218: printf(" %d", n_ExternalID);
! 9219: printf(" %d", n_SystemID);
! 9220: printf(" %d", n_content);
! 9221: printf("\n");
! 9222: }
! 9223: }
! 9224: }
! 9225: }
! 9226: }
! 9227: }
! 9228: }
! 9229: function_tests++;
! 9230:
! 9231: return(test_ret);
! 9232: }
! 9233:
! 9234:
! 9235: static int
! 9236: test_xmlCleanupPredefinedEntities(void) {
! 9237: int test_ret = 0;
! 9238:
! 9239: #if defined(LIBXML_LEGACY_ENABLED)
! 9240: #ifdef LIBXML_LEGACY_ENABLED
! 9241: int mem_base;
! 9242:
! 9243: mem_base = xmlMemBlocks();
! 9244:
! 9245: xmlCleanupPredefinedEntities();
! 9246: call_tests++;
! 9247: xmlResetLastError();
! 9248: if (mem_base != xmlMemBlocks()) {
! 9249: printf("Leak of %d blocks found in xmlCleanupPredefinedEntities",
! 9250: xmlMemBlocks() - mem_base);
! 9251: test_ret++;
! 9252: printf("\n");
! 9253: }
! 9254: function_tests++;
! 9255: #endif
! 9256: #endif
! 9257:
! 9258: return(test_ret);
! 9259: }
! 9260:
! 9261:
! 9262: #define gen_nb_xmlEntitiesTablePtr 1
! 9263: static xmlEntitiesTablePtr gen_xmlEntitiesTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 9264: return(NULL);
! 9265: }
! 9266: static void des_xmlEntitiesTablePtr(int no ATTRIBUTE_UNUSED, xmlEntitiesTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 9267: }
! 9268:
! 9269: static int
! 9270: test_xmlCopyEntitiesTable(void) {
! 9271: int test_ret = 0;
! 9272:
! 9273:
! 9274: /* missing type support */
! 9275: return(test_ret);
! 9276: }
! 9277:
! 9278:
! 9279: static int
! 9280: test_xmlCreateEntitiesTable(void) {
! 9281: int test_ret = 0;
! 9282:
! 9283:
! 9284: /* missing type support */
! 9285: return(test_ret);
! 9286: }
! 9287:
! 9288:
! 9289: static int
! 9290: test_xmlDumpEntitiesTable(void) {
! 9291: int test_ret = 0;
! 9292:
! 9293: #if defined(LIBXML_OUTPUT_ENABLED)
! 9294: int mem_base;
! 9295: xmlBufferPtr buf; /* An XML buffer. */
! 9296: int n_buf;
! 9297: xmlEntitiesTablePtr table; /* An entity table */
! 9298: int n_table;
! 9299:
! 9300: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 9301: for (n_table = 0;n_table < gen_nb_xmlEntitiesTablePtr;n_table++) {
! 9302: mem_base = xmlMemBlocks();
! 9303: buf = gen_xmlBufferPtr(n_buf, 0);
! 9304: table = gen_xmlEntitiesTablePtr(n_table, 1);
! 9305:
! 9306: xmlDumpEntitiesTable(buf, table);
! 9307: call_tests++;
! 9308: des_xmlBufferPtr(n_buf, buf, 0);
! 9309: des_xmlEntitiesTablePtr(n_table, table, 1);
! 9310: xmlResetLastError();
! 9311: if (mem_base != xmlMemBlocks()) {
! 9312: printf("Leak of %d blocks found in xmlDumpEntitiesTable",
! 9313: xmlMemBlocks() - mem_base);
! 9314: test_ret++;
! 9315: printf(" %d", n_buf);
! 9316: printf(" %d", n_table);
! 9317: printf("\n");
! 9318: }
! 9319: }
! 9320: }
! 9321: function_tests++;
! 9322: #endif
! 9323:
! 9324: return(test_ret);
! 9325: }
! 9326:
! 9327:
! 9328: #define gen_nb_xmlEntityPtr 1
! 9329: static xmlEntityPtr gen_xmlEntityPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 9330: return(NULL);
! 9331: }
! 9332: static void des_xmlEntityPtr(int no ATTRIBUTE_UNUSED, xmlEntityPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 9333: }
! 9334:
! 9335: static int
! 9336: test_xmlDumpEntityDecl(void) {
! 9337: int test_ret = 0;
! 9338:
! 9339: #if defined(LIBXML_OUTPUT_ENABLED)
! 9340: int mem_base;
! 9341: xmlBufferPtr buf; /* An XML buffer. */
! 9342: int n_buf;
! 9343: xmlEntityPtr ent; /* An entity table */
! 9344: int n_ent;
! 9345:
! 9346: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 9347: for (n_ent = 0;n_ent < gen_nb_xmlEntityPtr;n_ent++) {
! 9348: mem_base = xmlMemBlocks();
! 9349: buf = gen_xmlBufferPtr(n_buf, 0);
! 9350: ent = gen_xmlEntityPtr(n_ent, 1);
! 9351:
! 9352: xmlDumpEntityDecl(buf, ent);
! 9353: call_tests++;
! 9354: des_xmlBufferPtr(n_buf, buf, 0);
! 9355: des_xmlEntityPtr(n_ent, ent, 1);
! 9356: xmlResetLastError();
! 9357: if (mem_base != xmlMemBlocks()) {
! 9358: printf("Leak of %d blocks found in xmlDumpEntityDecl",
! 9359: xmlMemBlocks() - mem_base);
! 9360: test_ret++;
! 9361: printf(" %d", n_buf);
! 9362: printf(" %d", n_ent);
! 9363: printf("\n");
! 9364: }
! 9365: }
! 9366: }
! 9367: function_tests++;
! 9368: #endif
! 9369:
! 9370: return(test_ret);
! 9371: }
! 9372:
! 9373:
! 9374: static int
! 9375: test_xmlEncodeEntitiesReentrant(void) {
! 9376: int test_ret = 0;
! 9377:
! 9378: int mem_base;
! 9379: xmlChar * ret_val;
! 9380: xmlDocPtr doc; /* the document containing the string */
! 9381: int n_doc;
! 9382: xmlChar * input; /* A string to convert to XML. */
! 9383: int n_input;
! 9384:
! 9385: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 9386: for (n_input = 0;n_input < gen_nb_const_xmlChar_ptr;n_input++) {
! 9387: mem_base = xmlMemBlocks();
! 9388: doc = gen_xmlDocPtr(n_doc, 0);
! 9389: input = gen_const_xmlChar_ptr(n_input, 1);
! 9390:
! 9391: ret_val = xmlEncodeEntitiesReentrant(doc, (const xmlChar *)input);
! 9392: desret_xmlChar_ptr(ret_val);
! 9393: call_tests++;
! 9394: des_xmlDocPtr(n_doc, doc, 0);
! 9395: des_const_xmlChar_ptr(n_input, (const xmlChar *)input, 1);
! 9396: xmlResetLastError();
! 9397: if (mem_base != xmlMemBlocks()) {
! 9398: printf("Leak of %d blocks found in xmlEncodeEntitiesReentrant",
! 9399: xmlMemBlocks() - mem_base);
! 9400: test_ret++;
! 9401: printf(" %d", n_doc);
! 9402: printf(" %d", n_input);
! 9403: printf("\n");
! 9404: }
! 9405: }
! 9406: }
! 9407: function_tests++;
! 9408:
! 9409: return(test_ret);
! 9410: }
! 9411:
! 9412:
! 9413: static int
! 9414: test_xmlEncodeSpecialChars(void) {
! 9415: int test_ret = 0;
! 9416:
! 9417: int mem_base;
! 9418: xmlChar * ret_val;
! 9419: xmlDocPtr doc; /* the document containing the string */
! 9420: int n_doc;
! 9421: xmlChar * input; /* A string to convert to XML. */
! 9422: int n_input;
! 9423:
! 9424: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 9425: for (n_input = 0;n_input < gen_nb_const_xmlChar_ptr;n_input++) {
! 9426: mem_base = xmlMemBlocks();
! 9427: doc = gen_xmlDocPtr(n_doc, 0);
! 9428: input = gen_const_xmlChar_ptr(n_input, 1);
! 9429:
! 9430: ret_val = xmlEncodeSpecialChars(doc, (const xmlChar *)input);
! 9431: desret_xmlChar_ptr(ret_val);
! 9432: call_tests++;
! 9433: des_xmlDocPtr(n_doc, doc, 0);
! 9434: des_const_xmlChar_ptr(n_input, (const xmlChar *)input, 1);
! 9435: xmlResetLastError();
! 9436: if (mem_base != xmlMemBlocks()) {
! 9437: printf("Leak of %d blocks found in xmlEncodeSpecialChars",
! 9438: xmlMemBlocks() - mem_base);
! 9439: test_ret++;
! 9440: printf(" %d", n_doc);
! 9441: printf(" %d", n_input);
! 9442: printf("\n");
! 9443: }
! 9444: }
! 9445: }
! 9446: function_tests++;
! 9447:
! 9448: return(test_ret);
! 9449: }
! 9450:
! 9451:
! 9452: static int
! 9453: test_xmlGetDocEntity(void) {
! 9454: int test_ret = 0;
! 9455:
! 9456: int mem_base;
! 9457: xmlEntityPtr ret_val;
! 9458: xmlDocPtr doc; /* the document referencing the entity */
! 9459: int n_doc;
! 9460: xmlChar * name; /* the entity name */
! 9461: int n_name;
! 9462:
! 9463: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 9464: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 9465: mem_base = xmlMemBlocks();
! 9466: doc = gen_xmlDocPtr(n_doc, 0);
! 9467: name = gen_const_xmlChar_ptr(n_name, 1);
! 9468:
! 9469: ret_val = xmlGetDocEntity(doc, (const xmlChar *)name);
! 9470: desret_xmlEntityPtr(ret_val);
! 9471: call_tests++;
! 9472: des_xmlDocPtr(n_doc, doc, 0);
! 9473: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 9474: xmlResetLastError();
! 9475: if (mem_base != xmlMemBlocks()) {
! 9476: printf("Leak of %d blocks found in xmlGetDocEntity",
! 9477: xmlMemBlocks() - mem_base);
! 9478: test_ret++;
! 9479: printf(" %d", n_doc);
! 9480: printf(" %d", n_name);
! 9481: printf("\n");
! 9482: }
! 9483: }
! 9484: }
! 9485: function_tests++;
! 9486:
! 9487: return(test_ret);
! 9488: }
! 9489:
! 9490:
! 9491: static int
! 9492: test_xmlGetDtdEntity(void) {
! 9493: int test_ret = 0;
! 9494:
! 9495: int mem_base;
! 9496: xmlEntityPtr ret_val;
! 9497: xmlDocPtr doc; /* the document referencing the entity */
! 9498: int n_doc;
! 9499: xmlChar * name; /* the entity name */
! 9500: int n_name;
! 9501:
! 9502: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 9503: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 9504: mem_base = xmlMemBlocks();
! 9505: doc = gen_xmlDocPtr(n_doc, 0);
! 9506: name = gen_const_xmlChar_ptr(n_name, 1);
! 9507:
! 9508: ret_val = xmlGetDtdEntity(doc, (const xmlChar *)name);
! 9509: desret_xmlEntityPtr(ret_val);
! 9510: call_tests++;
! 9511: des_xmlDocPtr(n_doc, doc, 0);
! 9512: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 9513: xmlResetLastError();
! 9514: if (mem_base != xmlMemBlocks()) {
! 9515: printf("Leak of %d blocks found in xmlGetDtdEntity",
! 9516: xmlMemBlocks() - mem_base);
! 9517: test_ret++;
! 9518: printf(" %d", n_doc);
! 9519: printf(" %d", n_name);
! 9520: printf("\n");
! 9521: }
! 9522: }
! 9523: }
! 9524: function_tests++;
! 9525:
! 9526: return(test_ret);
! 9527: }
! 9528:
! 9529:
! 9530: static int
! 9531: test_xmlGetParameterEntity(void) {
! 9532: int test_ret = 0;
! 9533:
! 9534: int mem_base;
! 9535: xmlEntityPtr ret_val;
! 9536: xmlDocPtr doc; /* the document referencing the entity */
! 9537: int n_doc;
! 9538: xmlChar * name; /* the entity name */
! 9539: int n_name;
! 9540:
! 9541: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 9542: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 9543: mem_base = xmlMemBlocks();
! 9544: doc = gen_xmlDocPtr(n_doc, 0);
! 9545: name = gen_const_xmlChar_ptr(n_name, 1);
! 9546:
! 9547: ret_val = xmlGetParameterEntity(doc, (const xmlChar *)name);
! 9548: desret_xmlEntityPtr(ret_val);
! 9549: call_tests++;
! 9550: des_xmlDocPtr(n_doc, doc, 0);
! 9551: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 9552: xmlResetLastError();
! 9553: if (mem_base != xmlMemBlocks()) {
! 9554: printf("Leak of %d blocks found in xmlGetParameterEntity",
! 9555: xmlMemBlocks() - mem_base);
! 9556: test_ret++;
! 9557: printf(" %d", n_doc);
! 9558: printf(" %d", n_name);
! 9559: printf("\n");
! 9560: }
! 9561: }
! 9562: }
! 9563: function_tests++;
! 9564:
! 9565: return(test_ret);
! 9566: }
! 9567:
! 9568:
! 9569: static int
! 9570: test_xmlGetPredefinedEntity(void) {
! 9571: int test_ret = 0;
! 9572:
! 9573: int mem_base;
! 9574: xmlEntityPtr ret_val;
! 9575: xmlChar * name; /* the entity name */
! 9576: int n_name;
! 9577:
! 9578: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 9579: mem_base = xmlMemBlocks();
! 9580: name = gen_const_xmlChar_ptr(n_name, 0);
! 9581:
! 9582: ret_val = xmlGetPredefinedEntity((const xmlChar *)name);
! 9583: desret_xmlEntityPtr(ret_val);
! 9584: call_tests++;
! 9585: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
! 9586: xmlResetLastError();
! 9587: if (mem_base != xmlMemBlocks()) {
! 9588: printf("Leak of %d blocks found in xmlGetPredefinedEntity",
! 9589: xmlMemBlocks() - mem_base);
! 9590: test_ret++;
! 9591: printf(" %d", n_name);
! 9592: printf("\n");
! 9593: }
! 9594: }
! 9595: function_tests++;
! 9596:
! 9597: return(test_ret);
! 9598: }
! 9599:
! 9600:
! 9601: static int
! 9602: test_xmlInitializePredefinedEntities(void) {
! 9603: int test_ret = 0;
! 9604:
! 9605: #if defined(LIBXML_LEGACY_ENABLED)
! 9606: #ifdef LIBXML_LEGACY_ENABLED
! 9607: int mem_base;
! 9608:
! 9609: mem_base = xmlMemBlocks();
! 9610:
! 9611: xmlInitializePredefinedEntities();
! 9612: call_tests++;
! 9613: xmlResetLastError();
! 9614: if (mem_base != xmlMemBlocks()) {
! 9615: printf("Leak of %d blocks found in xmlInitializePredefinedEntities",
! 9616: xmlMemBlocks() - mem_base);
! 9617: test_ret++;
! 9618: printf("\n");
! 9619: }
! 9620: function_tests++;
! 9621: #endif
! 9622: #endif
! 9623:
! 9624: return(test_ret);
! 9625: }
! 9626:
! 9627:
! 9628: static int
! 9629: test_xmlNewEntity(void) {
! 9630: int test_ret = 0;
! 9631:
! 9632: int mem_base;
! 9633: xmlEntityPtr ret_val;
! 9634: xmlDocPtr doc; /* the document */
! 9635: int n_doc;
! 9636: xmlChar * name; /* the entity name */
! 9637: int n_name;
! 9638: int type; /* the entity type XML_xxx_yyy_ENTITY */
! 9639: int n_type;
! 9640: xmlChar * ExternalID; /* the entity external ID if available */
! 9641: int n_ExternalID;
! 9642: xmlChar * SystemID; /* the entity system ID if available */
! 9643: int n_SystemID;
! 9644: xmlChar * content; /* the entity content */
! 9645: int n_content;
! 9646:
! 9647: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 9648: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 9649: for (n_type = 0;n_type < gen_nb_int;n_type++) {
! 9650: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
! 9651: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
! 9652: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 9653: mem_base = xmlMemBlocks();
! 9654: doc = gen_xmlDocPtr(n_doc, 0);
! 9655: name = gen_const_xmlChar_ptr(n_name, 1);
! 9656: type = gen_int(n_type, 2);
! 9657: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3);
! 9658: SystemID = gen_const_xmlChar_ptr(n_SystemID, 4);
! 9659: content = gen_const_xmlChar_ptr(n_content, 5);
! 9660:
! 9661: ret_val = xmlNewEntity(doc, (const xmlChar *)name, type, (const xmlChar *)ExternalID, (const xmlChar *)SystemID, (const xmlChar *)content);
! 9662: desret_xmlEntityPtr(ret_val);
! 9663: call_tests++;
! 9664: des_xmlDocPtr(n_doc, doc, 0);
! 9665: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 9666: des_int(n_type, type, 2);
! 9667: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 3);
! 9668: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 4);
! 9669: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 5);
! 9670: xmlResetLastError();
! 9671: if (mem_base != xmlMemBlocks()) {
! 9672: printf("Leak of %d blocks found in xmlNewEntity",
! 9673: xmlMemBlocks() - mem_base);
! 9674: test_ret++;
! 9675: printf(" %d", n_doc);
! 9676: printf(" %d", n_name);
! 9677: printf(" %d", n_type);
! 9678: printf(" %d", n_ExternalID);
! 9679: printf(" %d", n_SystemID);
! 9680: printf(" %d", n_content);
! 9681: printf("\n");
! 9682: }
! 9683: }
! 9684: }
! 9685: }
! 9686: }
! 9687: }
! 9688: }
! 9689: function_tests++;
! 9690:
! 9691: return(test_ret);
! 9692: }
! 9693:
! 9694: static int
! 9695: test_entities(void) {
! 9696: int test_ret = 0;
! 9697:
! 9698: if (quiet == 0) printf("Testing entities : 13 of 17 functions ...\n");
! 9699: test_ret += test_xmlAddDocEntity();
! 9700: test_ret += test_xmlAddDtdEntity();
! 9701: test_ret += test_xmlCleanupPredefinedEntities();
! 9702: test_ret += test_xmlCopyEntitiesTable();
! 9703: test_ret += test_xmlCreateEntitiesTable();
! 9704: test_ret += test_xmlDumpEntitiesTable();
! 9705: test_ret += test_xmlDumpEntityDecl();
! 9706: test_ret += test_xmlEncodeEntitiesReentrant();
! 9707: test_ret += test_xmlEncodeSpecialChars();
! 9708: test_ret += test_xmlGetDocEntity();
! 9709: test_ret += test_xmlGetDtdEntity();
! 9710: test_ret += test_xmlGetParameterEntity();
! 9711: test_ret += test_xmlGetPredefinedEntity();
! 9712: test_ret += test_xmlInitializePredefinedEntities();
! 9713: test_ret += test_xmlNewEntity();
! 9714:
! 9715: if (test_ret != 0)
! 9716: printf("Module entities: %d errors\n", test_ret);
! 9717: return(test_ret);
! 9718: }
! 9719:
! 9720: static int
! 9721: test_xmlHashAddEntry(void) {
! 9722: int test_ret = 0;
! 9723:
! 9724: int mem_base;
! 9725: int ret_val;
! 9726: xmlHashTablePtr table; /* the hash table */
! 9727: int n_table;
! 9728: xmlChar * name; /* the name of the userdata */
! 9729: int n_name;
! 9730: void * userdata; /* a pointer to the userdata */
! 9731: int n_userdata;
! 9732:
! 9733: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
! 9734: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 9735: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
! 9736: mem_base = xmlMemBlocks();
! 9737: table = gen_xmlHashTablePtr(n_table, 0);
! 9738: name = gen_const_xmlChar_ptr(n_name, 1);
! 9739: userdata = gen_userdata(n_userdata, 2);
! 9740:
! 9741: ret_val = xmlHashAddEntry(table, (const xmlChar *)name, userdata);
! 9742: desret_int(ret_val);
! 9743: call_tests++;
! 9744: des_xmlHashTablePtr(n_table, table, 0);
! 9745: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 9746: des_userdata(n_userdata, userdata, 2);
! 9747: xmlResetLastError();
! 9748: if (mem_base != xmlMemBlocks()) {
! 9749: printf("Leak of %d blocks found in xmlHashAddEntry",
! 9750: xmlMemBlocks() - mem_base);
! 9751: test_ret++;
! 9752: printf(" %d", n_table);
! 9753: printf(" %d", n_name);
! 9754: printf(" %d", n_userdata);
! 9755: printf("\n");
! 9756: }
! 9757: }
! 9758: }
! 9759: }
! 9760: function_tests++;
! 9761:
! 9762: return(test_ret);
! 9763: }
! 9764:
! 9765:
! 9766: static int
! 9767: test_xmlHashAddEntry2(void) {
! 9768: int test_ret = 0;
! 9769:
! 9770: int mem_base;
! 9771: int ret_val;
! 9772: xmlHashTablePtr table; /* the hash table */
! 9773: int n_table;
! 9774: xmlChar * name; /* the name of the userdata */
! 9775: int n_name;
! 9776: xmlChar * name2; /* a second name of the userdata */
! 9777: int n_name2;
! 9778: void * userdata; /* a pointer to the userdata */
! 9779: int n_userdata;
! 9780:
! 9781: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
! 9782: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 9783: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
! 9784: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
! 9785: mem_base = xmlMemBlocks();
! 9786: table = gen_xmlHashTablePtr(n_table, 0);
! 9787: name = gen_const_xmlChar_ptr(n_name, 1);
! 9788: name2 = gen_const_xmlChar_ptr(n_name2, 2);
! 9789: userdata = gen_userdata(n_userdata, 3);
! 9790:
! 9791: ret_val = xmlHashAddEntry2(table, (const xmlChar *)name, (const xmlChar *)name2, userdata);
! 9792: desret_int(ret_val);
! 9793: call_tests++;
! 9794: des_xmlHashTablePtr(n_table, table, 0);
! 9795: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 9796: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
! 9797: des_userdata(n_userdata, userdata, 3);
! 9798: xmlResetLastError();
! 9799: if (mem_base != xmlMemBlocks()) {
! 9800: printf("Leak of %d blocks found in xmlHashAddEntry2",
! 9801: xmlMemBlocks() - mem_base);
! 9802: test_ret++;
! 9803: printf(" %d", n_table);
! 9804: printf(" %d", n_name);
! 9805: printf(" %d", n_name2);
! 9806: printf(" %d", n_userdata);
! 9807: printf("\n");
! 9808: }
! 9809: }
! 9810: }
! 9811: }
! 9812: }
! 9813: function_tests++;
! 9814:
! 9815: return(test_ret);
! 9816: }
! 9817:
! 9818:
! 9819: static int
! 9820: test_xmlHashAddEntry3(void) {
! 9821: int test_ret = 0;
! 9822:
! 9823: int mem_base;
! 9824: int ret_val;
! 9825: xmlHashTablePtr table; /* the hash table */
! 9826: int n_table;
! 9827: xmlChar * name; /* the name of the userdata */
! 9828: int n_name;
! 9829: xmlChar * name2; /* a second name of the userdata */
! 9830: int n_name2;
! 9831: xmlChar * name3; /* a third name of the userdata */
! 9832: int n_name3;
! 9833: void * userdata; /* a pointer to the userdata */
! 9834: int n_userdata;
! 9835:
! 9836: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
! 9837: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 9838: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
! 9839: for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
! 9840: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
! 9841: mem_base = xmlMemBlocks();
! 9842: table = gen_xmlHashTablePtr(n_table, 0);
! 9843: name = gen_const_xmlChar_ptr(n_name, 1);
! 9844: name2 = gen_const_xmlChar_ptr(n_name2, 2);
! 9845: name3 = gen_const_xmlChar_ptr(n_name3, 3);
! 9846: userdata = gen_userdata(n_userdata, 4);
! 9847:
! 9848: ret_val = xmlHashAddEntry3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3, userdata);
! 9849: desret_int(ret_val);
! 9850: call_tests++;
! 9851: des_xmlHashTablePtr(n_table, table, 0);
! 9852: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 9853: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
! 9854: des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3);
! 9855: des_userdata(n_userdata, userdata, 4);
! 9856: xmlResetLastError();
! 9857: if (mem_base != xmlMemBlocks()) {
! 9858: printf("Leak of %d blocks found in xmlHashAddEntry3",
! 9859: xmlMemBlocks() - mem_base);
! 9860: test_ret++;
! 9861: printf(" %d", n_table);
! 9862: printf(" %d", n_name);
! 9863: printf(" %d", n_name2);
! 9864: printf(" %d", n_name3);
! 9865: printf(" %d", n_userdata);
! 9866: printf("\n");
! 9867: }
! 9868: }
! 9869: }
! 9870: }
! 9871: }
! 9872: }
! 9873: function_tests++;
! 9874:
! 9875: return(test_ret);
! 9876: }
! 9877:
! 9878:
! 9879: static int
! 9880: test_xmlHashCopy(void) {
! 9881: int test_ret = 0;
! 9882:
! 9883:
! 9884: /* missing type support */
! 9885: return(test_ret);
! 9886: }
! 9887:
! 9888:
! 9889: static int
! 9890: test_xmlHashCreate(void) {
! 9891: int test_ret = 0;
! 9892:
! 9893:
! 9894: /* missing type support */
! 9895: return(test_ret);
! 9896: }
! 9897:
! 9898:
! 9899: static int
! 9900: test_xmlHashCreateDict(void) {
! 9901: int test_ret = 0;
! 9902:
! 9903:
! 9904: /* missing type support */
! 9905: return(test_ret);
! 9906: }
! 9907:
! 9908:
! 9909: static int
! 9910: test_xmlHashLookup(void) {
! 9911: int test_ret = 0;
! 9912:
! 9913: int mem_base;
! 9914: void * ret_val;
! 9915: xmlHashTablePtr table; /* the hash table */
! 9916: int n_table;
! 9917: xmlChar * name; /* the name of the userdata */
! 9918: int n_name;
! 9919:
! 9920: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
! 9921: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 9922: mem_base = xmlMemBlocks();
! 9923: table = gen_xmlHashTablePtr(n_table, 0);
! 9924: name = gen_const_xmlChar_ptr(n_name, 1);
! 9925:
! 9926: ret_val = xmlHashLookup(table, (const xmlChar *)name);
! 9927: desret_void_ptr(ret_val);
! 9928: call_tests++;
! 9929: des_xmlHashTablePtr(n_table, table, 0);
! 9930: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 9931: xmlResetLastError();
! 9932: if (mem_base != xmlMemBlocks()) {
! 9933: printf("Leak of %d blocks found in xmlHashLookup",
! 9934: xmlMemBlocks() - mem_base);
! 9935: test_ret++;
! 9936: printf(" %d", n_table);
! 9937: printf(" %d", n_name);
! 9938: printf("\n");
! 9939: }
! 9940: }
! 9941: }
! 9942: function_tests++;
! 9943:
! 9944: return(test_ret);
! 9945: }
! 9946:
! 9947:
! 9948: static int
! 9949: test_xmlHashLookup2(void) {
! 9950: int test_ret = 0;
! 9951:
! 9952: int mem_base;
! 9953: void * ret_val;
! 9954: xmlHashTablePtr table; /* the hash table */
! 9955: int n_table;
! 9956: xmlChar * name; /* the name of the userdata */
! 9957: int n_name;
! 9958: xmlChar * name2; /* a second name of the userdata */
! 9959: int n_name2;
! 9960:
! 9961: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
! 9962: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 9963: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
! 9964: mem_base = xmlMemBlocks();
! 9965: table = gen_xmlHashTablePtr(n_table, 0);
! 9966: name = gen_const_xmlChar_ptr(n_name, 1);
! 9967: name2 = gen_const_xmlChar_ptr(n_name2, 2);
! 9968:
! 9969: ret_val = xmlHashLookup2(table, (const xmlChar *)name, (const xmlChar *)name2);
! 9970: desret_void_ptr(ret_val);
! 9971: call_tests++;
! 9972: des_xmlHashTablePtr(n_table, table, 0);
! 9973: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 9974: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
! 9975: xmlResetLastError();
! 9976: if (mem_base != xmlMemBlocks()) {
! 9977: printf("Leak of %d blocks found in xmlHashLookup2",
! 9978: xmlMemBlocks() - mem_base);
! 9979: test_ret++;
! 9980: printf(" %d", n_table);
! 9981: printf(" %d", n_name);
! 9982: printf(" %d", n_name2);
! 9983: printf("\n");
! 9984: }
! 9985: }
! 9986: }
! 9987: }
! 9988: function_tests++;
! 9989:
! 9990: return(test_ret);
! 9991: }
! 9992:
! 9993:
! 9994: static int
! 9995: test_xmlHashLookup3(void) {
! 9996: int test_ret = 0;
! 9997:
! 9998: int mem_base;
! 9999: void * ret_val;
! 10000: xmlHashTablePtr table; /* the hash table */
! 10001: int n_table;
! 10002: xmlChar * name; /* the name of the userdata */
! 10003: int n_name;
! 10004: xmlChar * name2; /* a second name of the userdata */
! 10005: int n_name2;
! 10006: xmlChar * name3; /* a third name of the userdata */
! 10007: int n_name3;
! 10008:
! 10009: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
! 10010: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 10011: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
! 10012: for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
! 10013: mem_base = xmlMemBlocks();
! 10014: table = gen_xmlHashTablePtr(n_table, 0);
! 10015: name = gen_const_xmlChar_ptr(n_name, 1);
! 10016: name2 = gen_const_xmlChar_ptr(n_name2, 2);
! 10017: name3 = gen_const_xmlChar_ptr(n_name3, 3);
! 10018:
! 10019: ret_val = xmlHashLookup3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3);
! 10020: desret_void_ptr(ret_val);
! 10021: call_tests++;
! 10022: des_xmlHashTablePtr(n_table, table, 0);
! 10023: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 10024: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
! 10025: des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3);
! 10026: xmlResetLastError();
! 10027: if (mem_base != xmlMemBlocks()) {
! 10028: printf("Leak of %d blocks found in xmlHashLookup3",
! 10029: xmlMemBlocks() - mem_base);
! 10030: test_ret++;
! 10031: printf(" %d", n_table);
! 10032: printf(" %d", n_name);
! 10033: printf(" %d", n_name2);
! 10034: printf(" %d", n_name3);
! 10035: printf("\n");
! 10036: }
! 10037: }
! 10038: }
! 10039: }
! 10040: }
! 10041: function_tests++;
! 10042:
! 10043: return(test_ret);
! 10044: }
! 10045:
! 10046:
! 10047: static int
! 10048: test_xmlHashQLookup(void) {
! 10049: int test_ret = 0;
! 10050:
! 10051: int mem_base;
! 10052: void * ret_val;
! 10053: xmlHashTablePtr table; /* the hash table */
! 10054: int n_table;
! 10055: xmlChar * prefix; /* the prefix of the userdata */
! 10056: int n_prefix;
! 10057: xmlChar * name; /* the name of the userdata */
! 10058: int n_name;
! 10059:
! 10060: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
! 10061: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
! 10062: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 10063: mem_base = xmlMemBlocks();
! 10064: table = gen_xmlHashTablePtr(n_table, 0);
! 10065: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
! 10066: name = gen_const_xmlChar_ptr(n_name, 2);
! 10067:
! 10068: ret_val = xmlHashQLookup(table, (const xmlChar *)prefix, (const xmlChar *)name);
! 10069: desret_void_ptr(ret_val);
! 10070: call_tests++;
! 10071: des_xmlHashTablePtr(n_table, table, 0);
! 10072: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
! 10073: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 10074: xmlResetLastError();
! 10075: if (mem_base != xmlMemBlocks()) {
! 10076: printf("Leak of %d blocks found in xmlHashQLookup",
! 10077: xmlMemBlocks() - mem_base);
! 10078: test_ret++;
! 10079: printf(" %d", n_table);
! 10080: printf(" %d", n_prefix);
! 10081: printf(" %d", n_name);
! 10082: printf("\n");
! 10083: }
! 10084: }
! 10085: }
! 10086: }
! 10087: function_tests++;
! 10088:
! 10089: return(test_ret);
! 10090: }
! 10091:
! 10092:
! 10093: static int
! 10094: test_xmlHashQLookup2(void) {
! 10095: int test_ret = 0;
! 10096:
! 10097: int mem_base;
! 10098: void * ret_val;
! 10099: xmlHashTablePtr table; /* the hash table */
! 10100: int n_table;
! 10101: xmlChar * prefix; /* the prefix of the userdata */
! 10102: int n_prefix;
! 10103: xmlChar * name; /* the name of the userdata */
! 10104: int n_name;
! 10105: xmlChar * prefix2; /* the second prefix of the userdata */
! 10106: int n_prefix2;
! 10107: xmlChar * name2; /* a second name of the userdata */
! 10108: int n_name2;
! 10109:
! 10110: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
! 10111: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
! 10112: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 10113: for (n_prefix2 = 0;n_prefix2 < gen_nb_const_xmlChar_ptr;n_prefix2++) {
! 10114: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
! 10115: mem_base = xmlMemBlocks();
! 10116: table = gen_xmlHashTablePtr(n_table, 0);
! 10117: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
! 10118: name = gen_const_xmlChar_ptr(n_name, 2);
! 10119: prefix2 = gen_const_xmlChar_ptr(n_prefix2, 3);
! 10120: name2 = gen_const_xmlChar_ptr(n_name2, 4);
! 10121:
! 10122: ret_val = xmlHashQLookup2(table, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)prefix2, (const xmlChar *)name2);
! 10123: desret_void_ptr(ret_val);
! 10124: call_tests++;
! 10125: des_xmlHashTablePtr(n_table, table, 0);
! 10126: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
! 10127: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 10128: des_const_xmlChar_ptr(n_prefix2, (const xmlChar *)prefix2, 3);
! 10129: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 4);
! 10130: xmlResetLastError();
! 10131: if (mem_base != xmlMemBlocks()) {
! 10132: printf("Leak of %d blocks found in xmlHashQLookup2",
! 10133: xmlMemBlocks() - mem_base);
! 10134: test_ret++;
! 10135: printf(" %d", n_table);
! 10136: printf(" %d", n_prefix);
! 10137: printf(" %d", n_name);
! 10138: printf(" %d", n_prefix2);
! 10139: printf(" %d", n_name2);
! 10140: printf("\n");
! 10141: }
! 10142: }
! 10143: }
! 10144: }
! 10145: }
! 10146: }
! 10147: function_tests++;
! 10148:
! 10149: return(test_ret);
! 10150: }
! 10151:
! 10152:
! 10153: static int
! 10154: test_xmlHashQLookup3(void) {
! 10155: int test_ret = 0;
! 10156:
! 10157: int mem_base;
! 10158: void * ret_val;
! 10159: xmlHashTablePtr table; /* the hash table */
! 10160: int n_table;
! 10161: xmlChar * prefix; /* the prefix of the userdata */
! 10162: int n_prefix;
! 10163: xmlChar * name; /* the name of the userdata */
! 10164: int n_name;
! 10165: xmlChar * prefix2; /* the second prefix of the userdata */
! 10166: int n_prefix2;
! 10167: xmlChar * name2; /* a second name of the userdata */
! 10168: int n_name2;
! 10169: xmlChar * prefix3; /* the third prefix of the userdata */
! 10170: int n_prefix3;
! 10171: xmlChar * name3; /* a third name of the userdata */
! 10172: int n_name3;
! 10173:
! 10174: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
! 10175: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
! 10176: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 10177: for (n_prefix2 = 0;n_prefix2 < gen_nb_const_xmlChar_ptr;n_prefix2++) {
! 10178: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
! 10179: for (n_prefix3 = 0;n_prefix3 < gen_nb_const_xmlChar_ptr;n_prefix3++) {
! 10180: for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
! 10181: mem_base = xmlMemBlocks();
! 10182: table = gen_xmlHashTablePtr(n_table, 0);
! 10183: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
! 10184: name = gen_const_xmlChar_ptr(n_name, 2);
! 10185: prefix2 = gen_const_xmlChar_ptr(n_prefix2, 3);
! 10186: name2 = gen_const_xmlChar_ptr(n_name2, 4);
! 10187: prefix3 = gen_const_xmlChar_ptr(n_prefix3, 5);
! 10188: name3 = gen_const_xmlChar_ptr(n_name3, 6);
! 10189:
! 10190: ret_val = xmlHashQLookup3(table, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)prefix2, (const xmlChar *)name2, (const xmlChar *)prefix3, (const xmlChar *)name3);
! 10191: desret_void_ptr(ret_val);
! 10192: call_tests++;
! 10193: des_xmlHashTablePtr(n_table, table, 0);
! 10194: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
! 10195: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 10196: des_const_xmlChar_ptr(n_prefix2, (const xmlChar *)prefix2, 3);
! 10197: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 4);
! 10198: des_const_xmlChar_ptr(n_prefix3, (const xmlChar *)prefix3, 5);
! 10199: des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 6);
! 10200: xmlResetLastError();
! 10201: if (mem_base != xmlMemBlocks()) {
! 10202: printf("Leak of %d blocks found in xmlHashQLookup3",
! 10203: xmlMemBlocks() - mem_base);
! 10204: test_ret++;
! 10205: printf(" %d", n_table);
! 10206: printf(" %d", n_prefix);
! 10207: printf(" %d", n_name);
! 10208: printf(" %d", n_prefix2);
! 10209: printf(" %d", n_name2);
! 10210: printf(" %d", n_prefix3);
! 10211: printf(" %d", n_name3);
! 10212: printf("\n");
! 10213: }
! 10214: }
! 10215: }
! 10216: }
! 10217: }
! 10218: }
! 10219: }
! 10220: }
! 10221: function_tests++;
! 10222:
! 10223: return(test_ret);
! 10224: }
! 10225:
! 10226:
! 10227: static int
! 10228: test_xmlHashRemoveEntry(void) {
! 10229: int test_ret = 0;
! 10230:
! 10231: int mem_base;
! 10232: int ret_val;
! 10233: xmlHashTablePtr table; /* the hash table */
! 10234: int n_table;
! 10235: xmlChar * name; /* the name of the userdata */
! 10236: int n_name;
! 10237: xmlHashDeallocator f; /* the deallocator function for removed item (if any) */
! 10238: int n_f;
! 10239:
! 10240: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
! 10241: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 10242: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
! 10243: mem_base = xmlMemBlocks();
! 10244: table = gen_xmlHashTablePtr(n_table, 0);
! 10245: name = gen_const_xmlChar_ptr(n_name, 1);
! 10246: f = gen_xmlHashDeallocator(n_f, 2);
! 10247:
! 10248: ret_val = xmlHashRemoveEntry(table, (const xmlChar *)name, f);
! 10249: desret_int(ret_val);
! 10250: call_tests++;
! 10251: des_xmlHashTablePtr(n_table, table, 0);
! 10252: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 10253: des_xmlHashDeallocator(n_f, f, 2);
! 10254: xmlResetLastError();
! 10255: if (mem_base != xmlMemBlocks()) {
! 10256: printf("Leak of %d blocks found in xmlHashRemoveEntry",
! 10257: xmlMemBlocks() - mem_base);
! 10258: test_ret++;
! 10259: printf(" %d", n_table);
! 10260: printf(" %d", n_name);
! 10261: printf(" %d", n_f);
! 10262: printf("\n");
! 10263: }
! 10264: }
! 10265: }
! 10266: }
! 10267: function_tests++;
! 10268:
! 10269: return(test_ret);
! 10270: }
! 10271:
! 10272:
! 10273: static int
! 10274: test_xmlHashRemoveEntry2(void) {
! 10275: int test_ret = 0;
! 10276:
! 10277: int mem_base;
! 10278: int ret_val;
! 10279: xmlHashTablePtr table; /* the hash table */
! 10280: int n_table;
! 10281: xmlChar * name; /* the name of the userdata */
! 10282: int n_name;
! 10283: xmlChar * name2; /* a second name of the userdata */
! 10284: int n_name2;
! 10285: xmlHashDeallocator f; /* the deallocator function for removed item (if any) */
! 10286: int n_f;
! 10287:
! 10288: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
! 10289: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 10290: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
! 10291: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
! 10292: mem_base = xmlMemBlocks();
! 10293: table = gen_xmlHashTablePtr(n_table, 0);
! 10294: name = gen_const_xmlChar_ptr(n_name, 1);
! 10295: name2 = gen_const_xmlChar_ptr(n_name2, 2);
! 10296: f = gen_xmlHashDeallocator(n_f, 3);
! 10297:
! 10298: ret_val = xmlHashRemoveEntry2(table, (const xmlChar *)name, (const xmlChar *)name2, f);
! 10299: desret_int(ret_val);
! 10300: call_tests++;
! 10301: des_xmlHashTablePtr(n_table, table, 0);
! 10302: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 10303: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
! 10304: des_xmlHashDeallocator(n_f, f, 3);
! 10305: xmlResetLastError();
! 10306: if (mem_base != xmlMemBlocks()) {
! 10307: printf("Leak of %d blocks found in xmlHashRemoveEntry2",
! 10308: xmlMemBlocks() - mem_base);
! 10309: test_ret++;
! 10310: printf(" %d", n_table);
! 10311: printf(" %d", n_name);
! 10312: printf(" %d", n_name2);
! 10313: printf(" %d", n_f);
! 10314: printf("\n");
! 10315: }
! 10316: }
! 10317: }
! 10318: }
! 10319: }
! 10320: function_tests++;
! 10321:
! 10322: return(test_ret);
! 10323: }
! 10324:
! 10325:
! 10326: static int
! 10327: test_xmlHashRemoveEntry3(void) {
! 10328: int test_ret = 0;
! 10329:
! 10330: int mem_base;
! 10331: int ret_val;
! 10332: xmlHashTablePtr table; /* the hash table */
! 10333: int n_table;
! 10334: xmlChar * name; /* the name of the userdata */
! 10335: int n_name;
! 10336: xmlChar * name2; /* a second name of the userdata */
! 10337: int n_name2;
! 10338: xmlChar * name3; /* a third name of the userdata */
! 10339: int n_name3;
! 10340: xmlHashDeallocator f; /* the deallocator function for removed item (if any) */
! 10341: int n_f;
! 10342:
! 10343: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
! 10344: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 10345: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
! 10346: for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
! 10347: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
! 10348: mem_base = xmlMemBlocks();
! 10349: table = gen_xmlHashTablePtr(n_table, 0);
! 10350: name = gen_const_xmlChar_ptr(n_name, 1);
! 10351: name2 = gen_const_xmlChar_ptr(n_name2, 2);
! 10352: name3 = gen_const_xmlChar_ptr(n_name3, 3);
! 10353: f = gen_xmlHashDeallocator(n_f, 4);
! 10354:
! 10355: ret_val = xmlHashRemoveEntry3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3, f);
! 10356: desret_int(ret_val);
! 10357: call_tests++;
! 10358: des_xmlHashTablePtr(n_table, table, 0);
! 10359: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 10360: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
! 10361: des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3);
! 10362: des_xmlHashDeallocator(n_f, f, 4);
! 10363: xmlResetLastError();
! 10364: if (mem_base != xmlMemBlocks()) {
! 10365: printf("Leak of %d blocks found in xmlHashRemoveEntry3",
! 10366: xmlMemBlocks() - mem_base);
! 10367: test_ret++;
! 10368: printf(" %d", n_table);
! 10369: printf(" %d", n_name);
! 10370: printf(" %d", n_name2);
! 10371: printf(" %d", n_name3);
! 10372: printf(" %d", n_f);
! 10373: printf("\n");
! 10374: }
! 10375: }
! 10376: }
! 10377: }
! 10378: }
! 10379: }
! 10380: function_tests++;
! 10381:
! 10382: return(test_ret);
! 10383: }
! 10384:
! 10385:
! 10386: static int
! 10387: test_xmlHashScan(void) {
! 10388: int test_ret = 0;
! 10389:
! 10390:
! 10391: /* missing type support */
! 10392: return(test_ret);
! 10393: }
! 10394:
! 10395:
! 10396: static int
! 10397: test_xmlHashScan3(void) {
! 10398: int test_ret = 0;
! 10399:
! 10400:
! 10401: /* missing type support */
! 10402: return(test_ret);
! 10403: }
! 10404:
! 10405:
! 10406: static int
! 10407: test_xmlHashScanFull(void) {
! 10408: int test_ret = 0;
! 10409:
! 10410:
! 10411: /* missing type support */
! 10412: return(test_ret);
! 10413: }
! 10414:
! 10415:
! 10416: static int
! 10417: test_xmlHashScanFull3(void) {
! 10418: int test_ret = 0;
! 10419:
! 10420:
! 10421: /* missing type support */
! 10422: return(test_ret);
! 10423: }
! 10424:
! 10425:
! 10426: static int
! 10427: test_xmlHashSize(void) {
! 10428: int test_ret = 0;
! 10429:
! 10430: int mem_base;
! 10431: int ret_val;
! 10432: xmlHashTablePtr table; /* the hash table */
! 10433: int n_table;
! 10434:
! 10435: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
! 10436: mem_base = xmlMemBlocks();
! 10437: table = gen_xmlHashTablePtr(n_table, 0);
! 10438:
! 10439: ret_val = xmlHashSize(table);
! 10440: desret_int(ret_val);
! 10441: call_tests++;
! 10442: des_xmlHashTablePtr(n_table, table, 0);
! 10443: xmlResetLastError();
! 10444: if (mem_base != xmlMemBlocks()) {
! 10445: printf("Leak of %d blocks found in xmlHashSize",
! 10446: xmlMemBlocks() - mem_base);
! 10447: test_ret++;
! 10448: printf(" %d", n_table);
! 10449: printf("\n");
! 10450: }
! 10451: }
! 10452: function_tests++;
! 10453:
! 10454: return(test_ret);
! 10455: }
! 10456:
! 10457:
! 10458: static int
! 10459: test_xmlHashUpdateEntry(void) {
! 10460: int test_ret = 0;
! 10461:
! 10462: int mem_base;
! 10463: int ret_val;
! 10464: xmlHashTablePtr table; /* the hash table */
! 10465: int n_table;
! 10466: xmlChar * name; /* the name of the userdata */
! 10467: int n_name;
! 10468: void * userdata; /* a pointer to the userdata */
! 10469: int n_userdata;
! 10470: xmlHashDeallocator f; /* the deallocator function for replaced item (if any) */
! 10471: int n_f;
! 10472:
! 10473: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
! 10474: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 10475: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
! 10476: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
! 10477: mem_base = xmlMemBlocks();
! 10478: table = gen_xmlHashTablePtr(n_table, 0);
! 10479: name = gen_const_xmlChar_ptr(n_name, 1);
! 10480: userdata = gen_userdata(n_userdata, 2);
! 10481: f = gen_xmlHashDeallocator(n_f, 3);
! 10482:
! 10483: ret_val = xmlHashUpdateEntry(table, (const xmlChar *)name, userdata, f);
! 10484: desret_int(ret_val);
! 10485: call_tests++;
! 10486: des_xmlHashTablePtr(n_table, table, 0);
! 10487: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 10488: des_userdata(n_userdata, userdata, 2);
! 10489: des_xmlHashDeallocator(n_f, f, 3);
! 10490: xmlResetLastError();
! 10491: if (mem_base != xmlMemBlocks()) {
! 10492: printf("Leak of %d blocks found in xmlHashUpdateEntry",
! 10493: xmlMemBlocks() - mem_base);
! 10494: test_ret++;
! 10495: printf(" %d", n_table);
! 10496: printf(" %d", n_name);
! 10497: printf(" %d", n_userdata);
! 10498: printf(" %d", n_f);
! 10499: printf("\n");
! 10500: }
! 10501: }
! 10502: }
! 10503: }
! 10504: }
! 10505: function_tests++;
! 10506:
! 10507: return(test_ret);
! 10508: }
! 10509:
! 10510:
! 10511: static int
! 10512: test_xmlHashUpdateEntry2(void) {
! 10513: int test_ret = 0;
! 10514:
! 10515: int mem_base;
! 10516: int ret_val;
! 10517: xmlHashTablePtr table; /* the hash table */
! 10518: int n_table;
! 10519: xmlChar * name; /* the name of the userdata */
! 10520: int n_name;
! 10521: xmlChar * name2; /* a second name of the userdata */
! 10522: int n_name2;
! 10523: void * userdata; /* a pointer to the userdata */
! 10524: int n_userdata;
! 10525: xmlHashDeallocator f; /* the deallocator function for replaced item (if any) */
! 10526: int n_f;
! 10527:
! 10528: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
! 10529: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 10530: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
! 10531: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
! 10532: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
! 10533: mem_base = xmlMemBlocks();
! 10534: table = gen_xmlHashTablePtr(n_table, 0);
! 10535: name = gen_const_xmlChar_ptr(n_name, 1);
! 10536: name2 = gen_const_xmlChar_ptr(n_name2, 2);
! 10537: userdata = gen_userdata(n_userdata, 3);
! 10538: f = gen_xmlHashDeallocator(n_f, 4);
! 10539:
! 10540: ret_val = xmlHashUpdateEntry2(table, (const xmlChar *)name, (const xmlChar *)name2, userdata, f);
! 10541: desret_int(ret_val);
! 10542: call_tests++;
! 10543: des_xmlHashTablePtr(n_table, table, 0);
! 10544: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 10545: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
! 10546: des_userdata(n_userdata, userdata, 3);
! 10547: des_xmlHashDeallocator(n_f, f, 4);
! 10548: xmlResetLastError();
! 10549: if (mem_base != xmlMemBlocks()) {
! 10550: printf("Leak of %d blocks found in xmlHashUpdateEntry2",
! 10551: xmlMemBlocks() - mem_base);
! 10552: test_ret++;
! 10553: printf(" %d", n_table);
! 10554: printf(" %d", n_name);
! 10555: printf(" %d", n_name2);
! 10556: printf(" %d", n_userdata);
! 10557: printf(" %d", n_f);
! 10558: printf("\n");
! 10559: }
! 10560: }
! 10561: }
! 10562: }
! 10563: }
! 10564: }
! 10565: function_tests++;
! 10566:
! 10567: return(test_ret);
! 10568: }
! 10569:
! 10570:
! 10571: static int
! 10572: test_xmlHashUpdateEntry3(void) {
! 10573: int test_ret = 0;
! 10574:
! 10575: int mem_base;
! 10576: int ret_val;
! 10577: xmlHashTablePtr table; /* the hash table */
! 10578: int n_table;
! 10579: xmlChar * name; /* the name of the userdata */
! 10580: int n_name;
! 10581: xmlChar * name2; /* a second name of the userdata */
! 10582: int n_name2;
! 10583: xmlChar * name3; /* a third name of the userdata */
! 10584: int n_name3;
! 10585: void * userdata; /* a pointer to the userdata */
! 10586: int n_userdata;
! 10587: xmlHashDeallocator f; /* the deallocator function for replaced item (if any) */
! 10588: int n_f;
! 10589:
! 10590: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
! 10591: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 10592: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
! 10593: for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
! 10594: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
! 10595: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
! 10596: mem_base = xmlMemBlocks();
! 10597: table = gen_xmlHashTablePtr(n_table, 0);
! 10598: name = gen_const_xmlChar_ptr(n_name, 1);
! 10599: name2 = gen_const_xmlChar_ptr(n_name2, 2);
! 10600: name3 = gen_const_xmlChar_ptr(n_name3, 3);
! 10601: userdata = gen_userdata(n_userdata, 4);
! 10602: f = gen_xmlHashDeallocator(n_f, 5);
! 10603:
! 10604: ret_val = xmlHashUpdateEntry3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3, userdata, f);
! 10605: desret_int(ret_val);
! 10606: call_tests++;
! 10607: des_xmlHashTablePtr(n_table, table, 0);
! 10608: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 10609: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
! 10610: des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3);
! 10611: des_userdata(n_userdata, userdata, 4);
! 10612: des_xmlHashDeallocator(n_f, f, 5);
! 10613: xmlResetLastError();
! 10614: if (mem_base != xmlMemBlocks()) {
! 10615: printf("Leak of %d blocks found in xmlHashUpdateEntry3",
! 10616: xmlMemBlocks() - mem_base);
! 10617: test_ret++;
! 10618: printf(" %d", n_table);
! 10619: printf(" %d", n_name);
! 10620: printf(" %d", n_name2);
! 10621: printf(" %d", n_name3);
! 10622: printf(" %d", n_userdata);
! 10623: printf(" %d", n_f);
! 10624: printf("\n");
! 10625: }
! 10626: }
! 10627: }
! 10628: }
! 10629: }
! 10630: }
! 10631: }
! 10632: function_tests++;
! 10633:
! 10634: return(test_ret);
! 10635: }
! 10636:
! 10637: static int
! 10638: test_hash(void) {
! 10639: int test_ret = 0;
! 10640:
! 10641: if (quiet == 0) printf("Testing hash : 16 of 24 functions ...\n");
! 10642: test_ret += test_xmlHashAddEntry();
! 10643: test_ret += test_xmlHashAddEntry2();
! 10644: test_ret += test_xmlHashAddEntry3();
! 10645: test_ret += test_xmlHashCopy();
! 10646: test_ret += test_xmlHashCreate();
! 10647: test_ret += test_xmlHashCreateDict();
! 10648: test_ret += test_xmlHashLookup();
! 10649: test_ret += test_xmlHashLookup2();
! 10650: test_ret += test_xmlHashLookup3();
! 10651: test_ret += test_xmlHashQLookup();
! 10652: test_ret += test_xmlHashQLookup2();
! 10653: test_ret += test_xmlHashQLookup3();
! 10654: test_ret += test_xmlHashRemoveEntry();
! 10655: test_ret += test_xmlHashRemoveEntry2();
! 10656: test_ret += test_xmlHashRemoveEntry3();
! 10657: test_ret += test_xmlHashScan();
! 10658: test_ret += test_xmlHashScan3();
! 10659: test_ret += test_xmlHashScanFull();
! 10660: test_ret += test_xmlHashScanFull3();
! 10661: test_ret += test_xmlHashSize();
! 10662: test_ret += test_xmlHashUpdateEntry();
! 10663: test_ret += test_xmlHashUpdateEntry2();
! 10664: test_ret += test_xmlHashUpdateEntry3();
! 10665:
! 10666: if (test_ret != 0)
! 10667: printf("Module hash: %d errors\n", test_ret);
! 10668: return(test_ret);
! 10669: }
! 10670:
! 10671: #define gen_nb_xmlLinkPtr 1
! 10672: static xmlLinkPtr gen_xmlLinkPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 10673: return(NULL);
! 10674: }
! 10675: static void des_xmlLinkPtr(int no ATTRIBUTE_UNUSED, xmlLinkPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 10676: }
! 10677:
! 10678: static int
! 10679: test_xmlLinkGetData(void) {
! 10680: int test_ret = 0;
! 10681:
! 10682: int mem_base;
! 10683: void * ret_val;
! 10684: xmlLinkPtr lk; /* a link */
! 10685: int n_lk;
! 10686:
! 10687: for (n_lk = 0;n_lk < gen_nb_xmlLinkPtr;n_lk++) {
! 10688: mem_base = xmlMemBlocks();
! 10689: lk = gen_xmlLinkPtr(n_lk, 0);
! 10690:
! 10691: ret_val = xmlLinkGetData(lk);
! 10692: desret_void_ptr(ret_val);
! 10693: call_tests++;
! 10694: des_xmlLinkPtr(n_lk, lk, 0);
! 10695: xmlResetLastError();
! 10696: if (mem_base != xmlMemBlocks()) {
! 10697: printf("Leak of %d blocks found in xmlLinkGetData",
! 10698: xmlMemBlocks() - mem_base);
! 10699: test_ret++;
! 10700: printf(" %d", n_lk);
! 10701: printf("\n");
! 10702: }
! 10703: }
! 10704: function_tests++;
! 10705:
! 10706: return(test_ret);
! 10707: }
! 10708:
! 10709:
! 10710: static int
! 10711: test_xmlListAppend(void) {
! 10712: int test_ret = 0;
! 10713:
! 10714: int mem_base;
! 10715: int ret_val;
! 10716: xmlListPtr l; /* a list */
! 10717: int n_l;
! 10718: void * data; /* the data */
! 10719: int n_data;
! 10720:
! 10721: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
! 10722: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
! 10723: mem_base = xmlMemBlocks();
! 10724: l = gen_xmlListPtr(n_l, 0);
! 10725: data = gen_userdata(n_data, 1);
! 10726:
! 10727: ret_val = xmlListAppend(l, data);
! 10728: desret_int(ret_val);
! 10729: call_tests++;
! 10730: des_xmlListPtr(n_l, l, 0);
! 10731: des_userdata(n_data, data, 1);
! 10732: xmlResetLastError();
! 10733: if (mem_base != xmlMemBlocks()) {
! 10734: printf("Leak of %d blocks found in xmlListAppend",
! 10735: xmlMemBlocks() - mem_base);
! 10736: test_ret++;
! 10737: printf(" %d", n_l);
! 10738: printf(" %d", n_data);
! 10739: printf("\n");
! 10740: }
! 10741: }
! 10742: }
! 10743: function_tests++;
! 10744:
! 10745: return(test_ret);
! 10746: }
! 10747:
! 10748:
! 10749: static int
! 10750: test_xmlListClear(void) {
! 10751: int test_ret = 0;
! 10752:
! 10753: int mem_base;
! 10754: xmlListPtr l; /* a list */
! 10755: int n_l;
! 10756:
! 10757: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
! 10758: mem_base = xmlMemBlocks();
! 10759: l = gen_xmlListPtr(n_l, 0);
! 10760:
! 10761: xmlListClear(l);
! 10762: call_tests++;
! 10763: des_xmlListPtr(n_l, l, 0);
! 10764: xmlResetLastError();
! 10765: if (mem_base != xmlMemBlocks()) {
! 10766: printf("Leak of %d blocks found in xmlListClear",
! 10767: xmlMemBlocks() - mem_base);
! 10768: test_ret++;
! 10769: printf(" %d", n_l);
! 10770: printf("\n");
! 10771: }
! 10772: }
! 10773: function_tests++;
! 10774:
! 10775: return(test_ret);
! 10776: }
! 10777:
! 10778:
! 10779: #define gen_nb_const_xmlListPtr 1
! 10780: static xmlListPtr gen_const_xmlListPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 10781: return(NULL);
! 10782: }
! 10783: static void des_const_xmlListPtr(int no ATTRIBUTE_UNUSED, const xmlListPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 10784: }
! 10785:
! 10786: static int
! 10787: test_xmlListCopy(void) {
! 10788: int test_ret = 0;
! 10789:
! 10790: int mem_base;
! 10791: int ret_val;
! 10792: xmlListPtr cur; /* the new list */
! 10793: int n_cur;
! 10794: xmlListPtr old; /* the old list */
! 10795: int n_old;
! 10796:
! 10797: for (n_cur = 0;n_cur < gen_nb_xmlListPtr;n_cur++) {
! 10798: for (n_old = 0;n_old < gen_nb_const_xmlListPtr;n_old++) {
! 10799: mem_base = xmlMemBlocks();
! 10800: cur = gen_xmlListPtr(n_cur, 0);
! 10801: old = gen_const_xmlListPtr(n_old, 1);
! 10802:
! 10803: ret_val = xmlListCopy(cur, (const xmlListPtr)old);
! 10804: desret_int(ret_val);
! 10805: call_tests++;
! 10806: des_xmlListPtr(n_cur, cur, 0);
! 10807: des_const_xmlListPtr(n_old, (const xmlListPtr)old, 1);
! 10808: xmlResetLastError();
! 10809: if (mem_base != xmlMemBlocks()) {
! 10810: printf("Leak of %d blocks found in xmlListCopy",
! 10811: xmlMemBlocks() - mem_base);
! 10812: test_ret++;
! 10813: printf(" %d", n_cur);
! 10814: printf(" %d", n_old);
! 10815: printf("\n");
! 10816: }
! 10817: }
! 10818: }
! 10819: function_tests++;
! 10820:
! 10821: return(test_ret);
! 10822: }
! 10823:
! 10824:
! 10825: static int
! 10826: test_xmlListCreate(void) {
! 10827: int test_ret = 0;
! 10828:
! 10829:
! 10830: /* missing type support */
! 10831: return(test_ret);
! 10832: }
! 10833:
! 10834:
! 10835: static int
! 10836: test_xmlListDup(void) {
! 10837: int test_ret = 0;
! 10838:
! 10839:
! 10840: /* missing type support */
! 10841: return(test_ret);
! 10842: }
! 10843:
! 10844:
! 10845: static int
! 10846: test_xmlListEmpty(void) {
! 10847: int test_ret = 0;
! 10848:
! 10849: int mem_base;
! 10850: int ret_val;
! 10851: xmlListPtr l; /* a list */
! 10852: int n_l;
! 10853:
! 10854: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
! 10855: mem_base = xmlMemBlocks();
! 10856: l = gen_xmlListPtr(n_l, 0);
! 10857:
! 10858: ret_val = xmlListEmpty(l);
! 10859: desret_int(ret_val);
! 10860: call_tests++;
! 10861: des_xmlListPtr(n_l, l, 0);
! 10862: xmlResetLastError();
! 10863: if (mem_base != xmlMemBlocks()) {
! 10864: printf("Leak of %d blocks found in xmlListEmpty",
! 10865: xmlMemBlocks() - mem_base);
! 10866: test_ret++;
! 10867: printf(" %d", n_l);
! 10868: printf("\n");
! 10869: }
! 10870: }
! 10871: function_tests++;
! 10872:
! 10873: return(test_ret);
! 10874: }
! 10875:
! 10876:
! 10877: static int
! 10878: test_xmlListEnd(void) {
! 10879: int test_ret = 0;
! 10880:
! 10881:
! 10882: /* missing type support */
! 10883: return(test_ret);
! 10884: }
! 10885:
! 10886:
! 10887: static int
! 10888: test_xmlListFront(void) {
! 10889: int test_ret = 0;
! 10890:
! 10891:
! 10892: /* missing type support */
! 10893: return(test_ret);
! 10894: }
! 10895:
! 10896:
! 10897: static int
! 10898: test_xmlListInsert(void) {
! 10899: int test_ret = 0;
! 10900:
! 10901: int mem_base;
! 10902: int ret_val;
! 10903: xmlListPtr l; /* a list */
! 10904: int n_l;
! 10905: void * data; /* the data */
! 10906: int n_data;
! 10907:
! 10908: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
! 10909: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
! 10910: mem_base = xmlMemBlocks();
! 10911: l = gen_xmlListPtr(n_l, 0);
! 10912: data = gen_userdata(n_data, 1);
! 10913:
! 10914: ret_val = xmlListInsert(l, data);
! 10915: desret_int(ret_val);
! 10916: call_tests++;
! 10917: des_xmlListPtr(n_l, l, 0);
! 10918: des_userdata(n_data, data, 1);
! 10919: xmlResetLastError();
! 10920: if (mem_base != xmlMemBlocks()) {
! 10921: printf("Leak of %d blocks found in xmlListInsert",
! 10922: xmlMemBlocks() - mem_base);
! 10923: test_ret++;
! 10924: printf(" %d", n_l);
! 10925: printf(" %d", n_data);
! 10926: printf("\n");
! 10927: }
! 10928: }
! 10929: }
! 10930: function_tests++;
! 10931:
! 10932: return(test_ret);
! 10933: }
! 10934:
! 10935:
! 10936: static int
! 10937: test_xmlListMerge(void) {
! 10938: int test_ret = 0;
! 10939:
! 10940: int mem_base;
! 10941: xmlListPtr l1; /* the original list */
! 10942: int n_l1;
! 10943: xmlListPtr l2; /* the new list */
! 10944: int n_l2;
! 10945:
! 10946: for (n_l1 = 0;n_l1 < gen_nb_xmlListPtr;n_l1++) {
! 10947: for (n_l2 = 0;n_l2 < gen_nb_xmlListPtr;n_l2++) {
! 10948: mem_base = xmlMemBlocks();
! 10949: l1 = gen_xmlListPtr(n_l1, 0);
! 10950: l2 = gen_xmlListPtr(n_l2, 1);
! 10951:
! 10952: xmlListMerge(l1, l2);
! 10953: call_tests++;
! 10954: des_xmlListPtr(n_l1, l1, 0);
! 10955: des_xmlListPtr(n_l2, l2, 1);
! 10956: xmlResetLastError();
! 10957: if (mem_base != xmlMemBlocks()) {
! 10958: printf("Leak of %d blocks found in xmlListMerge",
! 10959: xmlMemBlocks() - mem_base);
! 10960: test_ret++;
! 10961: printf(" %d", n_l1);
! 10962: printf(" %d", n_l2);
! 10963: printf("\n");
! 10964: }
! 10965: }
! 10966: }
! 10967: function_tests++;
! 10968:
! 10969: return(test_ret);
! 10970: }
! 10971:
! 10972:
! 10973: static int
! 10974: test_xmlListPopBack(void) {
! 10975: int test_ret = 0;
! 10976:
! 10977: int mem_base;
! 10978: xmlListPtr l; /* a list */
! 10979: int n_l;
! 10980:
! 10981: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
! 10982: mem_base = xmlMemBlocks();
! 10983: l = gen_xmlListPtr(n_l, 0);
! 10984:
! 10985: xmlListPopBack(l);
! 10986: call_tests++;
! 10987: des_xmlListPtr(n_l, l, 0);
! 10988: xmlResetLastError();
! 10989: if (mem_base != xmlMemBlocks()) {
! 10990: printf("Leak of %d blocks found in xmlListPopBack",
! 10991: xmlMemBlocks() - mem_base);
! 10992: test_ret++;
! 10993: printf(" %d", n_l);
! 10994: printf("\n");
! 10995: }
! 10996: }
! 10997: function_tests++;
! 10998:
! 10999: return(test_ret);
! 11000: }
! 11001:
! 11002:
! 11003: static int
! 11004: test_xmlListPopFront(void) {
! 11005: int test_ret = 0;
! 11006:
! 11007: int mem_base;
! 11008: xmlListPtr l; /* a list */
! 11009: int n_l;
! 11010:
! 11011: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
! 11012: mem_base = xmlMemBlocks();
! 11013: l = gen_xmlListPtr(n_l, 0);
! 11014:
! 11015: xmlListPopFront(l);
! 11016: call_tests++;
! 11017: des_xmlListPtr(n_l, l, 0);
! 11018: xmlResetLastError();
! 11019: if (mem_base != xmlMemBlocks()) {
! 11020: printf("Leak of %d blocks found in xmlListPopFront",
! 11021: xmlMemBlocks() - mem_base);
! 11022: test_ret++;
! 11023: printf(" %d", n_l);
! 11024: printf("\n");
! 11025: }
! 11026: }
! 11027: function_tests++;
! 11028:
! 11029: return(test_ret);
! 11030: }
! 11031:
! 11032:
! 11033: static int
! 11034: test_xmlListPushBack(void) {
! 11035: int test_ret = 0;
! 11036:
! 11037: int mem_base;
! 11038: int ret_val;
! 11039: xmlListPtr l; /* a list */
! 11040: int n_l;
! 11041: void * data; /* new data */
! 11042: int n_data;
! 11043:
! 11044: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
! 11045: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
! 11046: mem_base = xmlMemBlocks();
! 11047: l = gen_xmlListPtr(n_l, 0);
! 11048: data = gen_userdata(n_data, 1);
! 11049:
! 11050: ret_val = xmlListPushBack(l, data);
! 11051: desret_int(ret_val);
! 11052: call_tests++;
! 11053: des_xmlListPtr(n_l, l, 0);
! 11054: des_userdata(n_data, data, 1);
! 11055: xmlResetLastError();
! 11056: if (mem_base != xmlMemBlocks()) {
! 11057: printf("Leak of %d blocks found in xmlListPushBack",
! 11058: xmlMemBlocks() - mem_base);
! 11059: test_ret++;
! 11060: printf(" %d", n_l);
! 11061: printf(" %d", n_data);
! 11062: printf("\n");
! 11063: }
! 11064: }
! 11065: }
! 11066: function_tests++;
! 11067:
! 11068: return(test_ret);
! 11069: }
! 11070:
! 11071:
! 11072: static int
! 11073: test_xmlListPushFront(void) {
! 11074: int test_ret = 0;
! 11075:
! 11076: int mem_base;
! 11077: int ret_val;
! 11078: xmlListPtr l; /* a list */
! 11079: int n_l;
! 11080: void * data; /* new data */
! 11081: int n_data;
! 11082:
! 11083: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
! 11084: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
! 11085: mem_base = xmlMemBlocks();
! 11086: l = gen_xmlListPtr(n_l, 0);
! 11087: data = gen_userdata(n_data, 1);
! 11088:
! 11089: ret_val = xmlListPushFront(l, data);
! 11090: desret_int(ret_val);
! 11091: call_tests++;
! 11092: des_xmlListPtr(n_l, l, 0);
! 11093: des_userdata(n_data, data, 1);
! 11094: xmlResetLastError();
! 11095: if (mem_base != xmlMemBlocks()) {
! 11096: printf("Leak of %d blocks found in xmlListPushFront",
! 11097: xmlMemBlocks() - mem_base);
! 11098: test_ret++;
! 11099: printf(" %d", n_l);
! 11100: printf(" %d", n_data);
! 11101: printf("\n");
! 11102: }
! 11103: }
! 11104: }
! 11105: function_tests++;
! 11106:
! 11107: return(test_ret);
! 11108: }
! 11109:
! 11110:
! 11111: static int
! 11112: test_xmlListRemoveAll(void) {
! 11113: int test_ret = 0;
! 11114:
! 11115: int mem_base;
! 11116: int ret_val;
! 11117: xmlListPtr l; /* a list */
! 11118: int n_l;
! 11119: void * data; /* list data */
! 11120: int n_data;
! 11121:
! 11122: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
! 11123: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
! 11124: mem_base = xmlMemBlocks();
! 11125: l = gen_xmlListPtr(n_l, 0);
! 11126: data = gen_userdata(n_data, 1);
! 11127:
! 11128: ret_val = xmlListRemoveAll(l, data);
! 11129: desret_int(ret_val);
! 11130: call_tests++;
! 11131: des_xmlListPtr(n_l, l, 0);
! 11132: des_userdata(n_data, data, 1);
! 11133: xmlResetLastError();
! 11134: if (mem_base != xmlMemBlocks()) {
! 11135: printf("Leak of %d blocks found in xmlListRemoveAll",
! 11136: xmlMemBlocks() - mem_base);
! 11137: test_ret++;
! 11138: printf(" %d", n_l);
! 11139: printf(" %d", n_data);
! 11140: printf("\n");
! 11141: }
! 11142: }
! 11143: }
! 11144: function_tests++;
! 11145:
! 11146: return(test_ret);
! 11147: }
! 11148:
! 11149:
! 11150: static int
! 11151: test_xmlListRemoveFirst(void) {
! 11152: int test_ret = 0;
! 11153:
! 11154: int mem_base;
! 11155: int ret_val;
! 11156: xmlListPtr l; /* a list */
! 11157: int n_l;
! 11158: void * data; /* list data */
! 11159: int n_data;
! 11160:
! 11161: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
! 11162: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
! 11163: mem_base = xmlMemBlocks();
! 11164: l = gen_xmlListPtr(n_l, 0);
! 11165: data = gen_userdata(n_data, 1);
! 11166:
! 11167: ret_val = xmlListRemoveFirst(l, data);
! 11168: desret_int(ret_val);
! 11169: call_tests++;
! 11170: des_xmlListPtr(n_l, l, 0);
! 11171: des_userdata(n_data, data, 1);
! 11172: xmlResetLastError();
! 11173: if (mem_base != xmlMemBlocks()) {
! 11174: printf("Leak of %d blocks found in xmlListRemoveFirst",
! 11175: xmlMemBlocks() - mem_base);
! 11176: test_ret++;
! 11177: printf(" %d", n_l);
! 11178: printf(" %d", n_data);
! 11179: printf("\n");
! 11180: }
! 11181: }
! 11182: }
! 11183: function_tests++;
! 11184:
! 11185: return(test_ret);
! 11186: }
! 11187:
! 11188:
! 11189: static int
! 11190: test_xmlListRemoveLast(void) {
! 11191: int test_ret = 0;
! 11192:
! 11193: int mem_base;
! 11194: int ret_val;
! 11195: xmlListPtr l; /* a list */
! 11196: int n_l;
! 11197: void * data; /* list data */
! 11198: int n_data;
! 11199:
! 11200: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
! 11201: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
! 11202: mem_base = xmlMemBlocks();
! 11203: l = gen_xmlListPtr(n_l, 0);
! 11204: data = gen_userdata(n_data, 1);
! 11205:
! 11206: ret_val = xmlListRemoveLast(l, data);
! 11207: desret_int(ret_val);
! 11208: call_tests++;
! 11209: des_xmlListPtr(n_l, l, 0);
! 11210: des_userdata(n_data, data, 1);
! 11211: xmlResetLastError();
! 11212: if (mem_base != xmlMemBlocks()) {
! 11213: printf("Leak of %d blocks found in xmlListRemoveLast",
! 11214: xmlMemBlocks() - mem_base);
! 11215: test_ret++;
! 11216: printf(" %d", n_l);
! 11217: printf(" %d", n_data);
! 11218: printf("\n");
! 11219: }
! 11220: }
! 11221: }
! 11222: function_tests++;
! 11223:
! 11224: return(test_ret);
! 11225: }
! 11226:
! 11227:
! 11228: static int
! 11229: test_xmlListReverse(void) {
! 11230: int test_ret = 0;
! 11231:
! 11232: int mem_base;
! 11233: xmlListPtr l; /* a list */
! 11234: int n_l;
! 11235:
! 11236: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
! 11237: mem_base = xmlMemBlocks();
! 11238: l = gen_xmlListPtr(n_l, 0);
! 11239:
! 11240: xmlListReverse(l);
! 11241: call_tests++;
! 11242: des_xmlListPtr(n_l, l, 0);
! 11243: xmlResetLastError();
! 11244: if (mem_base != xmlMemBlocks()) {
! 11245: printf("Leak of %d blocks found in xmlListReverse",
! 11246: xmlMemBlocks() - mem_base);
! 11247: test_ret++;
! 11248: printf(" %d", n_l);
! 11249: printf("\n");
! 11250: }
! 11251: }
! 11252: function_tests++;
! 11253:
! 11254: return(test_ret);
! 11255: }
! 11256:
! 11257:
! 11258: static int
! 11259: test_xmlListReverseSearch(void) {
! 11260: int test_ret = 0;
! 11261:
! 11262: int mem_base;
! 11263: void * ret_val;
! 11264: xmlListPtr l; /* a list */
! 11265: int n_l;
! 11266: void * data; /* a search value */
! 11267: int n_data;
! 11268:
! 11269: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
! 11270: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
! 11271: mem_base = xmlMemBlocks();
! 11272: l = gen_xmlListPtr(n_l, 0);
! 11273: data = gen_userdata(n_data, 1);
! 11274:
! 11275: ret_val = xmlListReverseSearch(l, data);
! 11276: desret_void_ptr(ret_val);
! 11277: call_tests++;
! 11278: des_xmlListPtr(n_l, l, 0);
! 11279: des_userdata(n_data, data, 1);
! 11280: xmlResetLastError();
! 11281: if (mem_base != xmlMemBlocks()) {
! 11282: printf("Leak of %d blocks found in xmlListReverseSearch",
! 11283: xmlMemBlocks() - mem_base);
! 11284: test_ret++;
! 11285: printf(" %d", n_l);
! 11286: printf(" %d", n_data);
! 11287: printf("\n");
! 11288: }
! 11289: }
! 11290: }
! 11291: function_tests++;
! 11292:
! 11293: return(test_ret);
! 11294: }
! 11295:
! 11296:
! 11297: static int
! 11298: test_xmlListReverseWalk(void) {
! 11299: int test_ret = 0;
! 11300:
! 11301:
! 11302: /* missing type support */
! 11303: return(test_ret);
! 11304: }
! 11305:
! 11306:
! 11307: static int
! 11308: test_xmlListSearch(void) {
! 11309: int test_ret = 0;
! 11310:
! 11311: int mem_base;
! 11312: void * ret_val;
! 11313: xmlListPtr l; /* a list */
! 11314: int n_l;
! 11315: void * data; /* a search value */
! 11316: int n_data;
! 11317:
! 11318: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
! 11319: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
! 11320: mem_base = xmlMemBlocks();
! 11321: l = gen_xmlListPtr(n_l, 0);
! 11322: data = gen_userdata(n_data, 1);
! 11323:
! 11324: ret_val = xmlListSearch(l, data);
! 11325: desret_void_ptr(ret_val);
! 11326: call_tests++;
! 11327: des_xmlListPtr(n_l, l, 0);
! 11328: des_userdata(n_data, data, 1);
! 11329: xmlResetLastError();
! 11330: if (mem_base != xmlMemBlocks()) {
! 11331: printf("Leak of %d blocks found in xmlListSearch",
! 11332: xmlMemBlocks() - mem_base);
! 11333: test_ret++;
! 11334: printf(" %d", n_l);
! 11335: printf(" %d", n_data);
! 11336: printf("\n");
! 11337: }
! 11338: }
! 11339: }
! 11340: function_tests++;
! 11341:
! 11342: return(test_ret);
! 11343: }
! 11344:
! 11345:
! 11346: static int
! 11347: test_xmlListSize(void) {
! 11348: int test_ret = 0;
! 11349:
! 11350: int mem_base;
! 11351: int ret_val;
! 11352: xmlListPtr l; /* a list */
! 11353: int n_l;
! 11354:
! 11355: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
! 11356: mem_base = xmlMemBlocks();
! 11357: l = gen_xmlListPtr(n_l, 0);
! 11358:
! 11359: ret_val = xmlListSize(l);
! 11360: desret_int(ret_val);
! 11361: call_tests++;
! 11362: des_xmlListPtr(n_l, l, 0);
! 11363: xmlResetLastError();
! 11364: if (mem_base != xmlMemBlocks()) {
! 11365: printf("Leak of %d blocks found in xmlListSize",
! 11366: xmlMemBlocks() - mem_base);
! 11367: test_ret++;
! 11368: printf(" %d", n_l);
! 11369: printf("\n");
! 11370: }
! 11371: }
! 11372: function_tests++;
! 11373:
! 11374: return(test_ret);
! 11375: }
! 11376:
! 11377:
! 11378: static int
! 11379: test_xmlListSort(void) {
! 11380: int test_ret = 0;
! 11381:
! 11382: int mem_base;
! 11383: xmlListPtr l; /* a list */
! 11384: int n_l;
! 11385:
! 11386: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
! 11387: mem_base = xmlMemBlocks();
! 11388: l = gen_xmlListPtr(n_l, 0);
! 11389:
! 11390: xmlListSort(l);
! 11391: call_tests++;
! 11392: des_xmlListPtr(n_l, l, 0);
! 11393: xmlResetLastError();
! 11394: if (mem_base != xmlMemBlocks()) {
! 11395: printf("Leak of %d blocks found in xmlListSort",
! 11396: xmlMemBlocks() - mem_base);
! 11397: test_ret++;
! 11398: printf(" %d", n_l);
! 11399: printf("\n");
! 11400: }
! 11401: }
! 11402: function_tests++;
! 11403:
! 11404: return(test_ret);
! 11405: }
! 11406:
! 11407:
! 11408: static int
! 11409: test_xmlListWalk(void) {
! 11410: int test_ret = 0;
! 11411:
! 11412:
! 11413: /* missing type support */
! 11414: return(test_ret);
! 11415: }
! 11416:
! 11417: static int
! 11418: test_list(void) {
! 11419: int test_ret = 0;
! 11420:
! 11421: if (quiet == 0) printf("Testing list : 19 of 26 functions ...\n");
! 11422: test_ret += test_xmlLinkGetData();
! 11423: test_ret += test_xmlListAppend();
! 11424: test_ret += test_xmlListClear();
! 11425: test_ret += test_xmlListCopy();
! 11426: test_ret += test_xmlListCreate();
! 11427: test_ret += test_xmlListDup();
! 11428: test_ret += test_xmlListEmpty();
! 11429: test_ret += test_xmlListEnd();
! 11430: test_ret += test_xmlListFront();
! 11431: test_ret += test_xmlListInsert();
! 11432: test_ret += test_xmlListMerge();
! 11433: test_ret += test_xmlListPopBack();
! 11434: test_ret += test_xmlListPopFront();
! 11435: test_ret += test_xmlListPushBack();
! 11436: test_ret += test_xmlListPushFront();
! 11437: test_ret += test_xmlListRemoveAll();
! 11438: test_ret += test_xmlListRemoveFirst();
! 11439: test_ret += test_xmlListRemoveLast();
! 11440: test_ret += test_xmlListReverse();
! 11441: test_ret += test_xmlListReverseSearch();
! 11442: test_ret += test_xmlListReverseWalk();
! 11443: test_ret += test_xmlListSearch();
! 11444: test_ret += test_xmlListSize();
! 11445: test_ret += test_xmlListSort();
! 11446: test_ret += test_xmlListWalk();
! 11447:
! 11448: if (test_ret != 0)
! 11449: printf("Module list: %d errors\n", test_ret);
! 11450: return(test_ret);
! 11451: }
! 11452:
! 11453: static int
! 11454: test_xmlNanoFTPCheckResponse(void) {
! 11455: int test_ret = 0;
! 11456:
! 11457: #if defined(LIBXML_FTP_ENABLED)
! 11458: int mem_base;
! 11459: int ret_val;
! 11460: void * ctx; /* an FTP context */
! 11461: int n_ctx;
! 11462:
! 11463: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
! 11464: mem_base = xmlMemBlocks();
! 11465: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
! 11466:
! 11467: ret_val = xmlNanoFTPCheckResponse(ctx);
! 11468: desret_int(ret_val);
! 11469: call_tests++;
! 11470: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
! 11471: xmlResetLastError();
! 11472: if (mem_base != xmlMemBlocks()) {
! 11473: printf("Leak of %d blocks found in xmlNanoFTPCheckResponse",
! 11474: xmlMemBlocks() - mem_base);
! 11475: test_ret++;
! 11476: printf(" %d", n_ctx);
! 11477: printf("\n");
! 11478: }
! 11479: }
! 11480: function_tests++;
! 11481: #endif
! 11482:
! 11483: return(test_ret);
! 11484: }
! 11485:
! 11486:
! 11487: static int
! 11488: test_xmlNanoFTPCleanup(void) {
! 11489: int test_ret = 0;
! 11490:
! 11491: #if defined(LIBXML_FTP_ENABLED)
! 11492: int mem_base;
! 11493:
! 11494: mem_base = xmlMemBlocks();
! 11495:
! 11496: xmlNanoFTPCleanup();
! 11497: call_tests++;
! 11498: xmlResetLastError();
! 11499: if (mem_base != xmlMemBlocks()) {
! 11500: printf("Leak of %d blocks found in xmlNanoFTPCleanup",
! 11501: xmlMemBlocks() - mem_base);
! 11502: test_ret++;
! 11503: printf("\n");
! 11504: }
! 11505: function_tests++;
! 11506: #endif
! 11507:
! 11508: return(test_ret);
! 11509: }
! 11510:
! 11511:
! 11512: static int
! 11513: test_xmlNanoFTPCloseConnection(void) {
! 11514: int test_ret = 0;
! 11515:
! 11516: #if defined(LIBXML_FTP_ENABLED)
! 11517: int mem_base;
! 11518: int ret_val;
! 11519: void * ctx; /* an FTP context */
! 11520: int n_ctx;
! 11521:
! 11522: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
! 11523: mem_base = xmlMemBlocks();
! 11524: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
! 11525:
! 11526: ret_val = xmlNanoFTPCloseConnection(ctx);
! 11527: desret_int(ret_val);
! 11528: call_tests++;
! 11529: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
! 11530: xmlResetLastError();
! 11531: if (mem_base != xmlMemBlocks()) {
! 11532: printf("Leak of %d blocks found in xmlNanoFTPCloseConnection",
! 11533: xmlMemBlocks() - mem_base);
! 11534: test_ret++;
! 11535: printf(" %d", n_ctx);
! 11536: printf("\n");
! 11537: }
! 11538: }
! 11539: function_tests++;
! 11540: #endif
! 11541:
! 11542: return(test_ret);
! 11543: }
! 11544:
! 11545:
! 11546: static int
! 11547: test_xmlNanoFTPCwd(void) {
! 11548: int test_ret = 0;
! 11549:
! 11550: #if defined(LIBXML_FTP_ENABLED)
! 11551: int mem_base;
! 11552: int ret_val;
! 11553: void * ctx; /* an FTP context */
! 11554: int n_ctx;
! 11555: char * directory; /* a directory on the server */
! 11556: int n_directory;
! 11557:
! 11558: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
! 11559: for (n_directory = 0;n_directory < gen_nb_const_char_ptr;n_directory++) {
! 11560: mem_base = xmlMemBlocks();
! 11561: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
! 11562: directory = gen_const_char_ptr(n_directory, 1);
! 11563:
! 11564: ret_val = xmlNanoFTPCwd(ctx, (const char *)directory);
! 11565: desret_int(ret_val);
! 11566: call_tests++;
! 11567: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
! 11568: des_const_char_ptr(n_directory, (const char *)directory, 1);
! 11569: xmlResetLastError();
! 11570: if (mem_base != xmlMemBlocks()) {
! 11571: printf("Leak of %d blocks found in xmlNanoFTPCwd",
! 11572: xmlMemBlocks() - mem_base);
! 11573: test_ret++;
! 11574: printf(" %d", n_ctx);
! 11575: printf(" %d", n_directory);
! 11576: printf("\n");
! 11577: }
! 11578: }
! 11579: }
! 11580: function_tests++;
! 11581: #endif
! 11582:
! 11583: return(test_ret);
! 11584: }
! 11585:
! 11586:
! 11587: static int
! 11588: test_xmlNanoFTPDele(void) {
! 11589: int test_ret = 0;
! 11590:
! 11591: #if defined(LIBXML_FTP_ENABLED)
! 11592: int mem_base;
! 11593: int ret_val;
! 11594: void * ctx; /* an FTP context */
! 11595: int n_ctx;
! 11596: const char * file; /* a file or directory on the server */
! 11597: int n_file;
! 11598:
! 11599: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
! 11600: for (n_file = 0;n_file < gen_nb_filepath;n_file++) {
! 11601: mem_base = xmlMemBlocks();
! 11602: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
! 11603: file = gen_filepath(n_file, 1);
! 11604:
! 11605: ret_val = xmlNanoFTPDele(ctx, file);
! 11606: desret_int(ret_val);
! 11607: call_tests++;
! 11608: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
! 11609: des_filepath(n_file, file, 1);
! 11610: xmlResetLastError();
! 11611: if (mem_base != xmlMemBlocks()) {
! 11612: printf("Leak of %d blocks found in xmlNanoFTPDele",
! 11613: xmlMemBlocks() - mem_base);
! 11614: test_ret++;
! 11615: printf(" %d", n_ctx);
! 11616: printf(" %d", n_file);
! 11617: printf("\n");
! 11618: }
! 11619: }
! 11620: }
! 11621: function_tests++;
! 11622: #endif
! 11623:
! 11624: return(test_ret);
! 11625: }
! 11626:
! 11627:
! 11628: static int
! 11629: test_xmlNanoFTPGet(void) {
! 11630: int test_ret = 0;
! 11631:
! 11632:
! 11633: /* missing type support */
! 11634: return(test_ret);
! 11635: }
! 11636:
! 11637:
! 11638: static int
! 11639: test_xmlNanoFTPGetConnection(void) {
! 11640: int test_ret = 0;
! 11641:
! 11642:
! 11643: /* missing type support */
! 11644: return(test_ret);
! 11645: }
! 11646:
! 11647:
! 11648: static int
! 11649: test_xmlNanoFTPGetResponse(void) {
! 11650: int test_ret = 0;
! 11651:
! 11652: #if defined(LIBXML_FTP_ENABLED)
! 11653: int mem_base;
! 11654: int ret_val;
! 11655: void * ctx; /* an FTP context */
! 11656: int n_ctx;
! 11657:
! 11658: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
! 11659: mem_base = xmlMemBlocks();
! 11660: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
! 11661:
! 11662: ret_val = xmlNanoFTPGetResponse(ctx);
! 11663: desret_int(ret_val);
! 11664: call_tests++;
! 11665: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
! 11666: xmlResetLastError();
! 11667: if (mem_base != xmlMemBlocks()) {
! 11668: printf("Leak of %d blocks found in xmlNanoFTPGetResponse",
! 11669: xmlMemBlocks() - mem_base);
! 11670: test_ret++;
! 11671: printf(" %d", n_ctx);
! 11672: printf("\n");
! 11673: }
! 11674: }
! 11675: function_tests++;
! 11676: #endif
! 11677:
! 11678: return(test_ret);
! 11679: }
! 11680:
! 11681:
! 11682: static int
! 11683: test_xmlNanoFTPGetSocket(void) {
! 11684: int test_ret = 0;
! 11685:
! 11686:
! 11687: /* missing type support */
! 11688: return(test_ret);
! 11689: }
! 11690:
! 11691:
! 11692: static int
! 11693: test_xmlNanoFTPInit(void) {
! 11694: int test_ret = 0;
! 11695:
! 11696: #if defined(LIBXML_FTP_ENABLED)
! 11697: int mem_base;
! 11698:
! 11699: mem_base = xmlMemBlocks();
! 11700:
! 11701: xmlNanoFTPInit();
! 11702: call_tests++;
! 11703: xmlResetLastError();
! 11704: if (mem_base != xmlMemBlocks()) {
! 11705: printf("Leak of %d blocks found in xmlNanoFTPInit",
! 11706: xmlMemBlocks() - mem_base);
! 11707: test_ret++;
! 11708: printf("\n");
! 11709: }
! 11710: function_tests++;
! 11711: #endif
! 11712:
! 11713: return(test_ret);
! 11714: }
! 11715:
! 11716:
! 11717: static int
! 11718: test_xmlNanoFTPList(void) {
! 11719: int test_ret = 0;
! 11720:
! 11721:
! 11722: /* missing type support */
! 11723: return(test_ret);
! 11724: }
! 11725:
! 11726:
! 11727: static int
! 11728: test_xmlNanoFTPNewCtxt(void) {
! 11729: int test_ret = 0;
! 11730:
! 11731: #if defined(LIBXML_FTP_ENABLED)
! 11732: int mem_base;
! 11733: void * ret_val;
! 11734: const char * URL; /* The URL used to initialize the context */
! 11735: int n_URL;
! 11736:
! 11737: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 11738: mem_base = xmlMemBlocks();
! 11739: URL = gen_filepath(n_URL, 0);
! 11740:
! 11741: ret_val = xmlNanoFTPNewCtxt(URL);
! 11742: desret_xmlNanoFTPCtxtPtr(ret_val);
! 11743: call_tests++;
! 11744: des_filepath(n_URL, URL, 0);
! 11745: xmlResetLastError();
! 11746: if (mem_base != xmlMemBlocks()) {
! 11747: printf("Leak of %d blocks found in xmlNanoFTPNewCtxt",
! 11748: xmlMemBlocks() - mem_base);
! 11749: test_ret++;
! 11750: printf(" %d", n_URL);
! 11751: printf("\n");
! 11752: }
! 11753: }
! 11754: function_tests++;
! 11755: #endif
! 11756:
! 11757: return(test_ret);
! 11758: }
! 11759:
! 11760:
! 11761: static int
! 11762: test_xmlNanoFTPOpen(void) {
! 11763: int test_ret = 0;
! 11764:
! 11765: #if defined(LIBXML_FTP_ENABLED)
! 11766: int mem_base;
! 11767: void * ret_val;
! 11768: const char * URL; /* the URL to the resource */
! 11769: int n_URL;
! 11770:
! 11771: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 11772: mem_base = xmlMemBlocks();
! 11773: URL = gen_filepath(n_URL, 0);
! 11774:
! 11775: ret_val = xmlNanoFTPOpen(URL);
! 11776: desret_xmlNanoFTPCtxtPtr(ret_val);
! 11777: call_tests++;
! 11778: des_filepath(n_URL, URL, 0);
! 11779: xmlResetLastError();
! 11780: if (mem_base != xmlMemBlocks()) {
! 11781: printf("Leak of %d blocks found in xmlNanoFTPOpen",
! 11782: xmlMemBlocks() - mem_base);
! 11783: test_ret++;
! 11784: printf(" %d", n_URL);
! 11785: printf("\n");
! 11786: }
! 11787: }
! 11788: function_tests++;
! 11789: #endif
! 11790:
! 11791: return(test_ret);
! 11792: }
! 11793:
! 11794:
! 11795: static int
! 11796: test_xmlNanoFTPProxy(void) {
! 11797: int test_ret = 0;
! 11798:
! 11799: #if defined(LIBXML_FTP_ENABLED)
! 11800: char * host; /* the proxy host name */
! 11801: int n_host;
! 11802: int port; /* the proxy port */
! 11803: int n_port;
! 11804: char * user; /* the proxy user name */
! 11805: int n_user;
! 11806: char * passwd; /* the proxy password */
! 11807: int n_passwd;
! 11808: int type; /* the type of proxy 1 for using SITE, 2 for USER a@b */
! 11809: int n_type;
! 11810:
! 11811: for (n_host = 0;n_host < gen_nb_const_char_ptr;n_host++) {
! 11812: for (n_port = 0;n_port < gen_nb_int;n_port++) {
! 11813: for (n_user = 0;n_user < gen_nb_const_char_ptr;n_user++) {
! 11814: for (n_passwd = 0;n_passwd < gen_nb_const_char_ptr;n_passwd++) {
! 11815: for (n_type = 0;n_type < gen_nb_int;n_type++) {
! 11816: host = gen_const_char_ptr(n_host, 0);
! 11817: port = gen_int(n_port, 1);
! 11818: user = gen_const_char_ptr(n_user, 2);
! 11819: passwd = gen_const_char_ptr(n_passwd, 3);
! 11820: type = gen_int(n_type, 4);
! 11821:
! 11822: xmlNanoFTPProxy((const char *)host, port, (const char *)user, (const char *)passwd, type);
! 11823: call_tests++;
! 11824: des_const_char_ptr(n_host, (const char *)host, 0);
! 11825: des_int(n_port, port, 1);
! 11826: des_const_char_ptr(n_user, (const char *)user, 2);
! 11827: des_const_char_ptr(n_passwd, (const char *)passwd, 3);
! 11828: des_int(n_type, type, 4);
! 11829: xmlResetLastError();
! 11830: }
! 11831: }
! 11832: }
! 11833: }
! 11834: }
! 11835: function_tests++;
! 11836: #endif
! 11837:
! 11838: return(test_ret);
! 11839: }
! 11840:
! 11841:
! 11842: static int
! 11843: test_xmlNanoFTPQuit(void) {
! 11844: int test_ret = 0;
! 11845:
! 11846: #if defined(LIBXML_FTP_ENABLED)
! 11847: int mem_base;
! 11848: int ret_val;
! 11849: void * ctx; /* an FTP context */
! 11850: int n_ctx;
! 11851:
! 11852: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
! 11853: mem_base = xmlMemBlocks();
! 11854: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
! 11855:
! 11856: ret_val = xmlNanoFTPQuit(ctx);
! 11857: desret_int(ret_val);
! 11858: call_tests++;
! 11859: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
! 11860: xmlResetLastError();
! 11861: if (mem_base != xmlMemBlocks()) {
! 11862: printf("Leak of %d blocks found in xmlNanoFTPQuit",
! 11863: xmlMemBlocks() - mem_base);
! 11864: test_ret++;
! 11865: printf(" %d", n_ctx);
! 11866: printf("\n");
! 11867: }
! 11868: }
! 11869: function_tests++;
! 11870: #endif
! 11871:
! 11872: return(test_ret);
! 11873: }
! 11874:
! 11875:
! 11876: static int
! 11877: test_xmlNanoFTPRead(void) {
! 11878: int test_ret = 0;
! 11879:
! 11880: #if defined(LIBXML_FTP_ENABLED)
! 11881: int mem_base;
! 11882: int ret_val;
! 11883: void * ctx; /* the FTP context */
! 11884: int n_ctx;
! 11885: void * dest; /* a buffer */
! 11886: int n_dest;
! 11887: int len; /* the buffer length */
! 11888: int n_len;
! 11889:
! 11890: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
! 11891: for (n_dest = 0;n_dest < gen_nb_void_ptr;n_dest++) {
! 11892: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 11893: mem_base = xmlMemBlocks();
! 11894: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
! 11895: dest = gen_void_ptr(n_dest, 1);
! 11896: len = gen_int(n_len, 2);
! 11897:
! 11898: ret_val = xmlNanoFTPRead(ctx, dest, len);
! 11899: desret_int(ret_val);
! 11900: call_tests++;
! 11901: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
! 11902: des_void_ptr(n_dest, dest, 1);
! 11903: des_int(n_len, len, 2);
! 11904: xmlResetLastError();
! 11905: if (mem_base != xmlMemBlocks()) {
! 11906: printf("Leak of %d blocks found in xmlNanoFTPRead",
! 11907: xmlMemBlocks() - mem_base);
! 11908: test_ret++;
! 11909: printf(" %d", n_ctx);
! 11910: printf(" %d", n_dest);
! 11911: printf(" %d", n_len);
! 11912: printf("\n");
! 11913: }
! 11914: }
! 11915: }
! 11916: }
! 11917: function_tests++;
! 11918: #endif
! 11919:
! 11920: return(test_ret);
! 11921: }
! 11922:
! 11923:
! 11924: static int
! 11925: test_xmlNanoFTPScanProxy(void) {
! 11926: int test_ret = 0;
! 11927:
! 11928: #if defined(LIBXML_FTP_ENABLED)
! 11929: const char * URL; /* The proxy URL used to initialize the proxy context */
! 11930: int n_URL;
! 11931:
! 11932: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 11933: URL = gen_filepath(n_URL, 0);
! 11934:
! 11935: xmlNanoFTPScanProxy(URL);
! 11936: call_tests++;
! 11937: des_filepath(n_URL, URL, 0);
! 11938: xmlResetLastError();
! 11939: }
! 11940: function_tests++;
! 11941: #endif
! 11942:
! 11943: return(test_ret);
! 11944: }
! 11945:
! 11946:
! 11947: static int
! 11948: test_xmlNanoFTPUpdateURL(void) {
! 11949: int test_ret = 0;
! 11950:
! 11951: #if defined(LIBXML_FTP_ENABLED)
! 11952: int mem_base;
! 11953: int ret_val;
! 11954: void * ctx; /* an FTP context */
! 11955: int n_ctx;
! 11956: const char * URL; /* The URL used to update the context */
! 11957: int n_URL;
! 11958:
! 11959: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
! 11960: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 11961: mem_base = xmlMemBlocks();
! 11962: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
! 11963: URL = gen_filepath(n_URL, 1);
! 11964:
! 11965: ret_val = xmlNanoFTPUpdateURL(ctx, URL);
! 11966: desret_int(ret_val);
! 11967: call_tests++;
! 11968: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
! 11969: des_filepath(n_URL, URL, 1);
! 11970: xmlResetLastError();
! 11971: if (mem_base != xmlMemBlocks()) {
! 11972: printf("Leak of %d blocks found in xmlNanoFTPUpdateURL",
! 11973: xmlMemBlocks() - mem_base);
! 11974: test_ret++;
! 11975: printf(" %d", n_ctx);
! 11976: printf(" %d", n_URL);
! 11977: printf("\n");
! 11978: }
! 11979: }
! 11980: }
! 11981: function_tests++;
! 11982: #endif
! 11983:
! 11984: return(test_ret);
! 11985: }
! 11986:
! 11987: static int
! 11988: test_nanoftp(void) {
! 11989: int test_ret = 0;
! 11990:
! 11991: if (quiet == 0) printf("Testing nanoftp : 14 of 22 functions ...\n");
! 11992: test_ret += test_xmlNanoFTPCheckResponse();
! 11993: test_ret += test_xmlNanoFTPCleanup();
! 11994: test_ret += test_xmlNanoFTPCloseConnection();
! 11995: test_ret += test_xmlNanoFTPCwd();
! 11996: test_ret += test_xmlNanoFTPDele();
! 11997: test_ret += test_xmlNanoFTPGet();
! 11998: test_ret += test_xmlNanoFTPGetConnection();
! 11999: test_ret += test_xmlNanoFTPGetResponse();
! 12000: test_ret += test_xmlNanoFTPGetSocket();
! 12001: test_ret += test_xmlNanoFTPInit();
! 12002: test_ret += test_xmlNanoFTPList();
! 12003: test_ret += test_xmlNanoFTPNewCtxt();
! 12004: test_ret += test_xmlNanoFTPOpen();
! 12005: test_ret += test_xmlNanoFTPProxy();
! 12006: test_ret += test_xmlNanoFTPQuit();
! 12007: test_ret += test_xmlNanoFTPRead();
! 12008: test_ret += test_xmlNanoFTPScanProxy();
! 12009: test_ret += test_xmlNanoFTPUpdateURL();
! 12010:
! 12011: if (test_ret != 0)
! 12012: printf("Module nanoftp: %d errors\n", test_ret);
! 12013: return(test_ret);
! 12014: }
! 12015:
! 12016: static int
! 12017: test_xmlNanoHTTPAuthHeader(void) {
! 12018: int test_ret = 0;
! 12019:
! 12020: #if defined(LIBXML_HTTP_ENABLED)
! 12021: int mem_base;
! 12022: const char * ret_val;
! 12023: void * ctx; /* the HTTP context */
! 12024: int n_ctx;
! 12025:
! 12026: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
! 12027: mem_base = xmlMemBlocks();
! 12028: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
! 12029:
! 12030: ret_val = xmlNanoHTTPAuthHeader(ctx);
! 12031: desret_const_char_ptr(ret_val);
! 12032: call_tests++;
! 12033: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
! 12034: xmlResetLastError();
! 12035: if (mem_base != xmlMemBlocks()) {
! 12036: printf("Leak of %d blocks found in xmlNanoHTTPAuthHeader",
! 12037: xmlMemBlocks() - mem_base);
! 12038: test_ret++;
! 12039: printf(" %d", n_ctx);
! 12040: printf("\n");
! 12041: }
! 12042: }
! 12043: function_tests++;
! 12044: #endif
! 12045:
! 12046: return(test_ret);
! 12047: }
! 12048:
! 12049:
! 12050: static int
! 12051: test_xmlNanoHTTPCleanup(void) {
! 12052: int test_ret = 0;
! 12053:
! 12054: #if defined(LIBXML_HTTP_ENABLED)
! 12055: int mem_base;
! 12056:
! 12057: mem_base = xmlMemBlocks();
! 12058:
! 12059: xmlNanoHTTPCleanup();
! 12060: call_tests++;
! 12061: xmlResetLastError();
! 12062: if (mem_base != xmlMemBlocks()) {
! 12063: printf("Leak of %d blocks found in xmlNanoHTTPCleanup",
! 12064: xmlMemBlocks() - mem_base);
! 12065: test_ret++;
! 12066: printf("\n");
! 12067: }
! 12068: function_tests++;
! 12069: #endif
! 12070:
! 12071: return(test_ret);
! 12072: }
! 12073:
! 12074:
! 12075: static int
! 12076: test_xmlNanoHTTPContentLength(void) {
! 12077: int test_ret = 0;
! 12078:
! 12079: #if defined(LIBXML_HTTP_ENABLED)
! 12080: int mem_base;
! 12081: int ret_val;
! 12082: void * ctx; /* the HTTP context */
! 12083: int n_ctx;
! 12084:
! 12085: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
! 12086: mem_base = xmlMemBlocks();
! 12087: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
! 12088:
! 12089: ret_val = xmlNanoHTTPContentLength(ctx);
! 12090: desret_int(ret_val);
! 12091: call_tests++;
! 12092: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
! 12093: xmlResetLastError();
! 12094: if (mem_base != xmlMemBlocks()) {
! 12095: printf("Leak of %d blocks found in xmlNanoHTTPContentLength",
! 12096: xmlMemBlocks() - mem_base);
! 12097: test_ret++;
! 12098: printf(" %d", n_ctx);
! 12099: printf("\n");
! 12100: }
! 12101: }
! 12102: function_tests++;
! 12103: #endif
! 12104:
! 12105: return(test_ret);
! 12106: }
! 12107:
! 12108:
! 12109: static int
! 12110: test_xmlNanoHTTPEncoding(void) {
! 12111: int test_ret = 0;
! 12112:
! 12113: #if defined(LIBXML_HTTP_ENABLED)
! 12114: int mem_base;
! 12115: const char * ret_val;
! 12116: void * ctx; /* the HTTP context */
! 12117: int n_ctx;
! 12118:
! 12119: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
! 12120: mem_base = xmlMemBlocks();
! 12121: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
! 12122:
! 12123: ret_val = xmlNanoHTTPEncoding(ctx);
! 12124: desret_const_char_ptr(ret_val);
! 12125: call_tests++;
! 12126: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
! 12127: xmlResetLastError();
! 12128: if (mem_base != xmlMemBlocks()) {
! 12129: printf("Leak of %d blocks found in xmlNanoHTTPEncoding",
! 12130: xmlMemBlocks() - mem_base);
! 12131: test_ret++;
! 12132: printf(" %d", n_ctx);
! 12133: printf("\n");
! 12134: }
! 12135: }
! 12136: function_tests++;
! 12137: #endif
! 12138:
! 12139: return(test_ret);
! 12140: }
! 12141:
! 12142:
! 12143: #define gen_nb_char_ptr_ptr 1
! 12144: static char ** gen_char_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 12145: return(NULL);
! 12146: }
! 12147: static void des_char_ptr_ptr(int no ATTRIBUTE_UNUSED, char ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 12148: }
! 12149:
! 12150: static int
! 12151: test_xmlNanoHTTPFetch(void) {
! 12152: int test_ret = 0;
! 12153:
! 12154: #if defined(LIBXML_HTTP_ENABLED)
! 12155: int mem_base;
! 12156: int ret_val;
! 12157: const char * URL; /* The URL to load */
! 12158: int n_URL;
! 12159: const char * filename; /* the filename where the content should be saved */
! 12160: int n_filename;
! 12161: char ** contentType; /* if available the Content-Type information will be returned at that location */
! 12162: int n_contentType;
! 12163:
! 12164: for (n_URL = 0;n_URL < gen_nb_fileoutput;n_URL++) {
! 12165: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
! 12166: for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) {
! 12167: mem_base = xmlMemBlocks();
! 12168: URL = gen_fileoutput(n_URL, 0);
! 12169: filename = gen_fileoutput(n_filename, 1);
! 12170: contentType = gen_char_ptr_ptr(n_contentType, 2);
! 12171:
! 12172: ret_val = xmlNanoHTTPFetch(URL, filename, contentType);
! 12173: desret_int(ret_val);
! 12174: call_tests++;
! 12175: des_fileoutput(n_URL, URL, 0);
! 12176: des_fileoutput(n_filename, filename, 1);
! 12177: des_char_ptr_ptr(n_contentType, contentType, 2);
! 12178: xmlResetLastError();
! 12179: if (mem_base != xmlMemBlocks()) {
! 12180: printf("Leak of %d blocks found in xmlNanoHTTPFetch",
! 12181: xmlMemBlocks() - mem_base);
! 12182: test_ret++;
! 12183: printf(" %d", n_URL);
! 12184: printf(" %d", n_filename);
! 12185: printf(" %d", n_contentType);
! 12186: printf("\n");
! 12187: }
! 12188: }
! 12189: }
! 12190: }
! 12191: function_tests++;
! 12192: #endif
! 12193:
! 12194: return(test_ret);
! 12195: }
! 12196:
! 12197:
! 12198: static int
! 12199: test_xmlNanoHTTPInit(void) {
! 12200: int test_ret = 0;
! 12201:
! 12202: #if defined(LIBXML_HTTP_ENABLED)
! 12203: int mem_base;
! 12204:
! 12205: mem_base = xmlMemBlocks();
! 12206:
! 12207: xmlNanoHTTPInit();
! 12208: call_tests++;
! 12209: xmlResetLastError();
! 12210: if (mem_base != xmlMemBlocks()) {
! 12211: printf("Leak of %d blocks found in xmlNanoHTTPInit",
! 12212: xmlMemBlocks() - mem_base);
! 12213: test_ret++;
! 12214: printf("\n");
! 12215: }
! 12216: function_tests++;
! 12217: #endif
! 12218:
! 12219: return(test_ret);
! 12220: }
! 12221:
! 12222:
! 12223: static int
! 12224: test_xmlNanoHTTPMimeType(void) {
! 12225: int test_ret = 0;
! 12226:
! 12227: #if defined(LIBXML_HTTP_ENABLED)
! 12228: int mem_base;
! 12229: const char * ret_val;
! 12230: void * ctx; /* the HTTP context */
! 12231: int n_ctx;
! 12232:
! 12233: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
! 12234: mem_base = xmlMemBlocks();
! 12235: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
! 12236:
! 12237: ret_val = xmlNanoHTTPMimeType(ctx);
! 12238: desret_const_char_ptr(ret_val);
! 12239: call_tests++;
! 12240: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
! 12241: xmlResetLastError();
! 12242: if (mem_base != xmlMemBlocks()) {
! 12243: printf("Leak of %d blocks found in xmlNanoHTTPMimeType",
! 12244: xmlMemBlocks() - mem_base);
! 12245: test_ret++;
! 12246: printf(" %d", n_ctx);
! 12247: printf("\n");
! 12248: }
! 12249: }
! 12250: function_tests++;
! 12251: #endif
! 12252:
! 12253: return(test_ret);
! 12254: }
! 12255:
! 12256:
! 12257: static int
! 12258: test_xmlNanoHTTPOpen(void) {
! 12259: int test_ret = 0;
! 12260:
! 12261: #if defined(LIBXML_HTTP_ENABLED)
! 12262: int mem_base;
! 12263: void * ret_val;
! 12264: const char * URL; /* The URL to load */
! 12265: int n_URL;
! 12266: char ** contentType; /* if available the Content-Type information will be returned at that location */
! 12267: int n_contentType;
! 12268:
! 12269: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 12270: for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) {
! 12271: mem_base = xmlMemBlocks();
! 12272: URL = gen_filepath(n_URL, 0);
! 12273: contentType = gen_char_ptr_ptr(n_contentType, 1);
! 12274:
! 12275: ret_val = xmlNanoHTTPOpen(URL, contentType);
! 12276: desret_xmlNanoHTTPCtxtPtr(ret_val);
! 12277: call_tests++;
! 12278: des_filepath(n_URL, URL, 0);
! 12279: des_char_ptr_ptr(n_contentType, contentType, 1);
! 12280: xmlResetLastError();
! 12281: if (mem_base != xmlMemBlocks()) {
! 12282: printf("Leak of %d blocks found in xmlNanoHTTPOpen",
! 12283: xmlMemBlocks() - mem_base);
! 12284: test_ret++;
! 12285: printf(" %d", n_URL);
! 12286: printf(" %d", n_contentType);
! 12287: printf("\n");
! 12288: }
! 12289: }
! 12290: }
! 12291: function_tests++;
! 12292: #endif
! 12293:
! 12294: return(test_ret);
! 12295: }
! 12296:
! 12297:
! 12298: static int
! 12299: test_xmlNanoHTTPOpenRedir(void) {
! 12300: int test_ret = 0;
! 12301:
! 12302: #if defined(LIBXML_HTTP_ENABLED)
! 12303: int mem_base;
! 12304: void * ret_val;
! 12305: const char * URL; /* The URL to load */
! 12306: int n_URL;
! 12307: char ** contentType; /* if available the Content-Type information will be returned at that location */
! 12308: int n_contentType;
! 12309: char ** redir; /* if available the redirected URL will be returned */
! 12310: int n_redir;
! 12311:
! 12312: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 12313: for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) {
! 12314: for (n_redir = 0;n_redir < gen_nb_char_ptr_ptr;n_redir++) {
! 12315: mem_base = xmlMemBlocks();
! 12316: URL = gen_filepath(n_URL, 0);
! 12317: contentType = gen_char_ptr_ptr(n_contentType, 1);
! 12318: redir = gen_char_ptr_ptr(n_redir, 2);
! 12319:
! 12320: ret_val = xmlNanoHTTPOpenRedir(URL, contentType, redir);
! 12321: desret_xmlNanoHTTPCtxtPtr(ret_val);
! 12322: call_tests++;
! 12323: des_filepath(n_URL, URL, 0);
! 12324: des_char_ptr_ptr(n_contentType, contentType, 1);
! 12325: des_char_ptr_ptr(n_redir, redir, 2);
! 12326: xmlResetLastError();
! 12327: if (mem_base != xmlMemBlocks()) {
! 12328: printf("Leak of %d blocks found in xmlNanoHTTPOpenRedir",
! 12329: xmlMemBlocks() - mem_base);
! 12330: test_ret++;
! 12331: printf(" %d", n_URL);
! 12332: printf(" %d", n_contentType);
! 12333: printf(" %d", n_redir);
! 12334: printf("\n");
! 12335: }
! 12336: }
! 12337: }
! 12338: }
! 12339: function_tests++;
! 12340: #endif
! 12341:
! 12342: return(test_ret);
! 12343: }
! 12344:
! 12345:
! 12346: static int
! 12347: test_xmlNanoHTTPRead(void) {
! 12348: int test_ret = 0;
! 12349:
! 12350: #if defined(LIBXML_HTTP_ENABLED)
! 12351: int mem_base;
! 12352: int ret_val;
! 12353: void * ctx; /* the HTTP context */
! 12354: int n_ctx;
! 12355: void * dest; /* a buffer */
! 12356: int n_dest;
! 12357: int len; /* the buffer length */
! 12358: int n_len;
! 12359:
! 12360: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
! 12361: for (n_dest = 0;n_dest < gen_nb_void_ptr;n_dest++) {
! 12362: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 12363: mem_base = xmlMemBlocks();
! 12364: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
! 12365: dest = gen_void_ptr(n_dest, 1);
! 12366: len = gen_int(n_len, 2);
! 12367:
! 12368: ret_val = xmlNanoHTTPRead(ctx, dest, len);
! 12369: desret_int(ret_val);
! 12370: call_tests++;
! 12371: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
! 12372: des_void_ptr(n_dest, dest, 1);
! 12373: des_int(n_len, len, 2);
! 12374: xmlResetLastError();
! 12375: if (mem_base != xmlMemBlocks()) {
! 12376: printf("Leak of %d blocks found in xmlNanoHTTPRead",
! 12377: xmlMemBlocks() - mem_base);
! 12378: test_ret++;
! 12379: printf(" %d", n_ctx);
! 12380: printf(" %d", n_dest);
! 12381: printf(" %d", n_len);
! 12382: printf("\n");
! 12383: }
! 12384: }
! 12385: }
! 12386: }
! 12387: function_tests++;
! 12388: #endif
! 12389:
! 12390: return(test_ret);
! 12391: }
! 12392:
! 12393:
! 12394: static int
! 12395: test_xmlNanoHTTPRedir(void) {
! 12396: int test_ret = 0;
! 12397:
! 12398:
! 12399: /* missing type support */
! 12400: return(test_ret);
! 12401: }
! 12402:
! 12403:
! 12404: static int
! 12405: test_xmlNanoHTTPReturnCode(void) {
! 12406: int test_ret = 0;
! 12407:
! 12408: #if defined(LIBXML_HTTP_ENABLED)
! 12409: int mem_base;
! 12410: int ret_val;
! 12411: void * ctx; /* the HTTP context */
! 12412: int n_ctx;
! 12413:
! 12414: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
! 12415: mem_base = xmlMemBlocks();
! 12416: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
! 12417:
! 12418: ret_val = xmlNanoHTTPReturnCode(ctx);
! 12419: desret_int(ret_val);
! 12420: call_tests++;
! 12421: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
! 12422: xmlResetLastError();
! 12423: if (mem_base != xmlMemBlocks()) {
! 12424: printf("Leak of %d blocks found in xmlNanoHTTPReturnCode",
! 12425: xmlMemBlocks() - mem_base);
! 12426: test_ret++;
! 12427: printf(" %d", n_ctx);
! 12428: printf("\n");
! 12429: }
! 12430: }
! 12431: function_tests++;
! 12432: #endif
! 12433:
! 12434: return(test_ret);
! 12435: }
! 12436:
! 12437:
! 12438: static int
! 12439: test_xmlNanoHTTPSave(void) {
! 12440: int test_ret = 0;
! 12441:
! 12442: #if defined(LIBXML_HTTP_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 12443: int mem_base;
! 12444: int ret_val;
! 12445: void * ctxt; /* the HTTP context */
! 12446: int n_ctxt;
! 12447: const char * filename; /* the filename where the content should be saved */
! 12448: int n_filename;
! 12449:
! 12450: for (n_ctxt = 0;n_ctxt < gen_nb_void_ptr;n_ctxt++) {
! 12451: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
! 12452: mem_base = xmlMemBlocks();
! 12453: ctxt = gen_void_ptr(n_ctxt, 0);
! 12454: filename = gen_fileoutput(n_filename, 1);
! 12455:
! 12456: ret_val = xmlNanoHTTPSave(ctxt, filename);
! 12457: desret_int(ret_val);
! 12458: call_tests++;
! 12459: des_void_ptr(n_ctxt, ctxt, 0);
! 12460: des_fileoutput(n_filename, filename, 1);
! 12461: xmlResetLastError();
! 12462: if (mem_base != xmlMemBlocks()) {
! 12463: printf("Leak of %d blocks found in xmlNanoHTTPSave",
! 12464: xmlMemBlocks() - mem_base);
! 12465: test_ret++;
! 12466: printf(" %d", n_ctxt);
! 12467: printf(" %d", n_filename);
! 12468: printf("\n");
! 12469: }
! 12470: }
! 12471: }
! 12472: function_tests++;
! 12473: #endif
! 12474:
! 12475: return(test_ret);
! 12476: }
! 12477:
! 12478:
! 12479: static int
! 12480: test_xmlNanoHTTPScanProxy(void) {
! 12481: int test_ret = 0;
! 12482:
! 12483: #if defined(LIBXML_HTTP_ENABLED)
! 12484: const char * URL; /* The proxy URL used to initialize the proxy context */
! 12485: int n_URL;
! 12486:
! 12487: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 12488: URL = gen_filepath(n_URL, 0);
! 12489:
! 12490: xmlNanoHTTPScanProxy(URL);
! 12491: call_tests++;
! 12492: des_filepath(n_URL, URL, 0);
! 12493: xmlResetLastError();
! 12494: }
! 12495: function_tests++;
! 12496: #endif
! 12497:
! 12498: return(test_ret);
! 12499: }
! 12500:
! 12501: static int
! 12502: test_nanohttp(void) {
! 12503: int test_ret = 0;
! 12504:
! 12505: if (quiet == 0) printf("Testing nanohttp : 13 of 17 functions ...\n");
! 12506: test_ret += test_xmlNanoHTTPAuthHeader();
! 12507: test_ret += test_xmlNanoHTTPCleanup();
! 12508: test_ret += test_xmlNanoHTTPContentLength();
! 12509: test_ret += test_xmlNanoHTTPEncoding();
! 12510: test_ret += test_xmlNanoHTTPFetch();
! 12511: test_ret += test_xmlNanoHTTPInit();
! 12512: test_ret += test_xmlNanoHTTPMimeType();
! 12513: test_ret += test_xmlNanoHTTPOpen();
! 12514: test_ret += test_xmlNanoHTTPOpenRedir();
! 12515: test_ret += test_xmlNanoHTTPRead();
! 12516: test_ret += test_xmlNanoHTTPRedir();
! 12517: test_ret += test_xmlNanoHTTPReturnCode();
! 12518: test_ret += test_xmlNanoHTTPSave();
! 12519: test_ret += test_xmlNanoHTTPScanProxy();
! 12520:
! 12521: if (test_ret != 0)
! 12522: printf("Module nanohttp: %d errors\n", test_ret);
! 12523: return(test_ret);
! 12524: }
! 12525:
! 12526: static int
! 12527: test_xmlByteConsumed(void) {
! 12528: int test_ret = 0;
! 12529:
! 12530: int mem_base;
! 12531: long ret_val;
! 12532: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 12533: int n_ctxt;
! 12534:
! 12535: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 12536: mem_base = xmlMemBlocks();
! 12537: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 12538:
! 12539: ret_val = xmlByteConsumed(ctxt);
! 12540: desret_long(ret_val);
! 12541: call_tests++;
! 12542: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 12543: xmlResetLastError();
! 12544: if (mem_base != xmlMemBlocks()) {
! 12545: printf("Leak of %d blocks found in xmlByteConsumed",
! 12546: xmlMemBlocks() - mem_base);
! 12547: test_ret++;
! 12548: printf(" %d", n_ctxt);
! 12549: printf("\n");
! 12550: }
! 12551: }
! 12552: function_tests++;
! 12553:
! 12554: return(test_ret);
! 12555: }
! 12556:
! 12557:
! 12558: static int
! 12559: test_xmlClearNodeInfoSeq(void) {
! 12560: int test_ret = 0;
! 12561:
! 12562: int mem_base;
! 12563: xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */
! 12564: int n_seq;
! 12565:
! 12566: for (n_seq = 0;n_seq < gen_nb_xmlParserNodeInfoSeqPtr;n_seq++) {
! 12567: mem_base = xmlMemBlocks();
! 12568: seq = gen_xmlParserNodeInfoSeqPtr(n_seq, 0);
! 12569:
! 12570: xmlClearNodeInfoSeq(seq);
! 12571: call_tests++;
! 12572: des_xmlParserNodeInfoSeqPtr(n_seq, seq, 0);
! 12573: xmlResetLastError();
! 12574: if (mem_base != xmlMemBlocks()) {
! 12575: printf("Leak of %d blocks found in xmlClearNodeInfoSeq",
! 12576: xmlMemBlocks() - mem_base);
! 12577: test_ret++;
! 12578: printf(" %d", n_seq);
! 12579: printf("\n");
! 12580: }
! 12581: }
! 12582: function_tests++;
! 12583:
! 12584: return(test_ret);
! 12585: }
! 12586:
! 12587:
! 12588: static int
! 12589: test_xmlClearParserCtxt(void) {
! 12590: int test_ret = 0;
! 12591:
! 12592: int mem_base;
! 12593: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 12594: int n_ctxt;
! 12595:
! 12596: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 12597: mem_base = xmlMemBlocks();
! 12598: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 12599:
! 12600: xmlClearParserCtxt(ctxt);
! 12601: call_tests++;
! 12602: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 12603: xmlResetLastError();
! 12604: if (mem_base != xmlMemBlocks()) {
! 12605: printf("Leak of %d blocks found in xmlClearParserCtxt",
! 12606: xmlMemBlocks() - mem_base);
! 12607: test_ret++;
! 12608: printf(" %d", n_ctxt);
! 12609: printf("\n");
! 12610: }
! 12611: }
! 12612: function_tests++;
! 12613:
! 12614: return(test_ret);
! 12615: }
! 12616:
! 12617:
! 12618: static int
! 12619: test_xmlCreateDocParserCtxt(void) {
! 12620: int test_ret = 0;
! 12621:
! 12622: int mem_base;
! 12623: xmlParserCtxtPtr ret_val;
! 12624: xmlChar * cur; /* a pointer to an array of xmlChar */
! 12625: int n_cur;
! 12626:
! 12627: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
! 12628: mem_base = xmlMemBlocks();
! 12629: cur = gen_const_xmlChar_ptr(n_cur, 0);
! 12630:
! 12631: ret_val = xmlCreateDocParserCtxt((const xmlChar *)cur);
! 12632: desret_xmlParserCtxtPtr(ret_val);
! 12633: call_tests++;
! 12634: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
! 12635: xmlResetLastError();
! 12636: if (mem_base != xmlMemBlocks()) {
! 12637: printf("Leak of %d blocks found in xmlCreateDocParserCtxt",
! 12638: xmlMemBlocks() - mem_base);
! 12639: test_ret++;
! 12640: printf(" %d", n_cur);
! 12641: printf("\n");
! 12642: }
! 12643: }
! 12644: function_tests++;
! 12645:
! 12646: return(test_ret);
! 12647: }
! 12648:
! 12649:
! 12650: static int
! 12651: test_xmlCreatePushParserCtxt(void) {
! 12652: int test_ret = 0;
! 12653:
! 12654: #if defined(LIBXML_PUSH_ENABLED)
! 12655: int mem_base;
! 12656: xmlParserCtxtPtr ret_val;
! 12657: xmlSAXHandlerPtr sax; /* a SAX handler */
! 12658: int n_sax;
! 12659: void * user_data; /* The user data returned on SAX callbacks */
! 12660: int n_user_data;
! 12661: char * chunk; /* a pointer to an array of chars */
! 12662: int n_chunk;
! 12663: int size; /* number of chars in the array */
! 12664: int n_size;
! 12665: const char * filename; /* an optional file name or URI */
! 12666: int n_filename;
! 12667:
! 12668: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
! 12669: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
! 12670: for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
! 12671: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 12672: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
! 12673: mem_base = xmlMemBlocks();
! 12674: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
! 12675: user_data = gen_userdata(n_user_data, 1);
! 12676: chunk = gen_const_char_ptr(n_chunk, 2);
! 12677: size = gen_int(n_size, 3);
! 12678: filename = gen_fileoutput(n_filename, 4);
! 12679:
! 12680: ret_val = xmlCreatePushParserCtxt(sax, user_data, (const char *)chunk, size, filename);
! 12681: desret_xmlParserCtxtPtr(ret_val);
! 12682: call_tests++;
! 12683: des_xmlSAXHandlerPtr(n_sax, sax, 0);
! 12684: des_userdata(n_user_data, user_data, 1);
! 12685: des_const_char_ptr(n_chunk, (const char *)chunk, 2);
! 12686: des_int(n_size, size, 3);
! 12687: des_fileoutput(n_filename, filename, 4);
! 12688: xmlResetLastError();
! 12689: if (mem_base != xmlMemBlocks()) {
! 12690: printf("Leak of %d blocks found in xmlCreatePushParserCtxt",
! 12691: xmlMemBlocks() - mem_base);
! 12692: test_ret++;
! 12693: printf(" %d", n_sax);
! 12694: printf(" %d", n_user_data);
! 12695: printf(" %d", n_chunk);
! 12696: printf(" %d", n_size);
! 12697: printf(" %d", n_filename);
! 12698: printf("\n");
! 12699: }
! 12700: }
! 12701: }
! 12702: }
! 12703: }
! 12704: }
! 12705: function_tests++;
! 12706: #endif
! 12707:
! 12708: return(test_ret);
! 12709: }
! 12710:
! 12711:
! 12712: static int
! 12713: test_xmlCtxtReadDoc(void) {
! 12714: int test_ret = 0;
! 12715:
! 12716: int mem_base;
! 12717: xmlDocPtr ret_val;
! 12718: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 12719: int n_ctxt;
! 12720: xmlChar * cur; /* a pointer to a zero terminated string */
! 12721: int n_cur;
! 12722: const char * URL; /* the base URL to use for the document */
! 12723: int n_URL;
! 12724: char * encoding; /* the document encoding, or NULL */
! 12725: int n_encoding;
! 12726: int options; /* a combination of xmlParserOption */
! 12727: int n_options;
! 12728:
! 12729: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 12730: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
! 12731: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 12732: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 12733: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
! 12734: mem_base = xmlMemBlocks();
! 12735: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 12736: cur = gen_const_xmlChar_ptr(n_cur, 1);
! 12737: URL = gen_filepath(n_URL, 2);
! 12738: encoding = gen_const_char_ptr(n_encoding, 3);
! 12739: options = gen_parseroptions(n_options, 4);
! 12740:
! 12741: ret_val = xmlCtxtReadDoc(ctxt, (const xmlChar *)cur, URL, (const char *)encoding, options);
! 12742: desret_xmlDocPtr(ret_val);
! 12743: call_tests++;
! 12744: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 12745: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
! 12746: des_filepath(n_URL, URL, 2);
! 12747: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
! 12748: des_parseroptions(n_options, options, 4);
! 12749: xmlResetLastError();
! 12750: if (mem_base != xmlMemBlocks()) {
! 12751: printf("Leak of %d blocks found in xmlCtxtReadDoc",
! 12752: xmlMemBlocks() - mem_base);
! 12753: test_ret++;
! 12754: printf(" %d", n_ctxt);
! 12755: printf(" %d", n_cur);
! 12756: printf(" %d", n_URL);
! 12757: printf(" %d", n_encoding);
! 12758: printf(" %d", n_options);
! 12759: printf("\n");
! 12760: }
! 12761: }
! 12762: }
! 12763: }
! 12764: }
! 12765: }
! 12766: function_tests++;
! 12767:
! 12768: return(test_ret);
! 12769: }
! 12770:
! 12771:
! 12772: static int
! 12773: test_xmlCtxtReadFile(void) {
! 12774: int test_ret = 0;
! 12775:
! 12776: int mem_base;
! 12777: xmlDocPtr ret_val;
! 12778: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 12779: int n_ctxt;
! 12780: const char * filename; /* a file or URL */
! 12781: int n_filename;
! 12782: char * encoding; /* the document encoding, or NULL */
! 12783: int n_encoding;
! 12784: int options; /* a combination of xmlParserOption */
! 12785: int n_options;
! 12786:
! 12787: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 12788: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 12789: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 12790: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
! 12791: mem_base = xmlMemBlocks();
! 12792: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 12793: filename = gen_filepath(n_filename, 1);
! 12794: encoding = gen_const_char_ptr(n_encoding, 2);
! 12795: options = gen_parseroptions(n_options, 3);
! 12796:
! 12797: ret_val = xmlCtxtReadFile(ctxt, filename, (const char *)encoding, options);
! 12798: desret_xmlDocPtr(ret_val);
! 12799: call_tests++;
! 12800: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 12801: des_filepath(n_filename, filename, 1);
! 12802: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
! 12803: des_parseroptions(n_options, options, 3);
! 12804: xmlResetLastError();
! 12805: if (mem_base != xmlMemBlocks()) {
! 12806: printf("Leak of %d blocks found in xmlCtxtReadFile",
! 12807: xmlMemBlocks() - mem_base);
! 12808: test_ret++;
! 12809: printf(" %d", n_ctxt);
! 12810: printf(" %d", n_filename);
! 12811: printf(" %d", n_encoding);
! 12812: printf(" %d", n_options);
! 12813: printf("\n");
! 12814: }
! 12815: }
! 12816: }
! 12817: }
! 12818: }
! 12819: function_tests++;
! 12820:
! 12821: return(test_ret);
! 12822: }
! 12823:
! 12824:
! 12825: static int
! 12826: test_xmlCtxtReadMemory(void) {
! 12827: int test_ret = 0;
! 12828:
! 12829: int mem_base;
! 12830: xmlDocPtr ret_val;
! 12831: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 12832: int n_ctxt;
! 12833: char * buffer; /* a pointer to a char array */
! 12834: int n_buffer;
! 12835: int size; /* the size of the array */
! 12836: int n_size;
! 12837: const char * URL; /* the base URL to use for the document */
! 12838: int n_URL;
! 12839: char * encoding; /* the document encoding, or NULL */
! 12840: int n_encoding;
! 12841: int options; /* a combination of xmlParserOption */
! 12842: int n_options;
! 12843:
! 12844: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 12845: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
! 12846: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 12847: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 12848: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 12849: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
! 12850: mem_base = xmlMemBlocks();
! 12851: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 12852: buffer = gen_const_char_ptr(n_buffer, 1);
! 12853: size = gen_int(n_size, 2);
! 12854: URL = gen_filepath(n_URL, 3);
! 12855: encoding = gen_const_char_ptr(n_encoding, 4);
! 12856: options = gen_parseroptions(n_options, 5);
! 12857:
! 12858: ret_val = xmlCtxtReadMemory(ctxt, (const char *)buffer, size, URL, (const char *)encoding, options);
! 12859: desret_xmlDocPtr(ret_val);
! 12860: call_tests++;
! 12861: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 12862: des_const_char_ptr(n_buffer, (const char *)buffer, 1);
! 12863: des_int(n_size, size, 2);
! 12864: des_filepath(n_URL, URL, 3);
! 12865: des_const_char_ptr(n_encoding, (const char *)encoding, 4);
! 12866: des_parseroptions(n_options, options, 5);
! 12867: xmlResetLastError();
! 12868: if (mem_base != xmlMemBlocks()) {
! 12869: printf("Leak of %d blocks found in xmlCtxtReadMemory",
! 12870: xmlMemBlocks() - mem_base);
! 12871: test_ret++;
! 12872: printf(" %d", n_ctxt);
! 12873: printf(" %d", n_buffer);
! 12874: printf(" %d", n_size);
! 12875: printf(" %d", n_URL);
! 12876: printf(" %d", n_encoding);
! 12877: printf(" %d", n_options);
! 12878: printf("\n");
! 12879: }
! 12880: }
! 12881: }
! 12882: }
! 12883: }
! 12884: }
! 12885: }
! 12886: function_tests++;
! 12887:
! 12888: return(test_ret);
! 12889: }
! 12890:
! 12891:
! 12892: static int
! 12893: test_xmlCtxtReset(void) {
! 12894: int test_ret = 0;
! 12895:
! 12896: int mem_base;
! 12897: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 12898: int n_ctxt;
! 12899:
! 12900: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 12901: mem_base = xmlMemBlocks();
! 12902: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 12903:
! 12904: xmlCtxtReset(ctxt);
! 12905: call_tests++;
! 12906: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 12907: xmlResetLastError();
! 12908: if (mem_base != xmlMemBlocks()) {
! 12909: printf("Leak of %d blocks found in xmlCtxtReset",
! 12910: xmlMemBlocks() - mem_base);
! 12911: test_ret++;
! 12912: printf(" %d", n_ctxt);
! 12913: printf("\n");
! 12914: }
! 12915: }
! 12916: function_tests++;
! 12917:
! 12918: return(test_ret);
! 12919: }
! 12920:
! 12921:
! 12922: static int
! 12923: test_xmlCtxtResetPush(void) {
! 12924: int test_ret = 0;
! 12925:
! 12926: int mem_base;
! 12927: int ret_val;
! 12928: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 12929: int n_ctxt;
! 12930: char * chunk; /* a pointer to an array of chars */
! 12931: int n_chunk;
! 12932: int size; /* number of chars in the array */
! 12933: int n_size;
! 12934: const char * filename; /* an optional file name or URI */
! 12935: int n_filename;
! 12936: char * encoding; /* the document encoding, or NULL */
! 12937: int n_encoding;
! 12938:
! 12939: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 12940: for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
! 12941: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 12942: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 12943: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 12944: mem_base = xmlMemBlocks();
! 12945: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 12946: chunk = gen_const_char_ptr(n_chunk, 1);
! 12947: size = gen_int(n_size, 2);
! 12948: filename = gen_filepath(n_filename, 3);
! 12949: encoding = gen_const_char_ptr(n_encoding, 4);
! 12950:
! 12951: ret_val = xmlCtxtResetPush(ctxt, (const char *)chunk, size, filename, (const char *)encoding);
! 12952: desret_int(ret_val);
! 12953: call_tests++;
! 12954: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 12955: des_const_char_ptr(n_chunk, (const char *)chunk, 1);
! 12956: des_int(n_size, size, 2);
! 12957: des_filepath(n_filename, filename, 3);
! 12958: des_const_char_ptr(n_encoding, (const char *)encoding, 4);
! 12959: xmlResetLastError();
! 12960: if (mem_base != xmlMemBlocks()) {
! 12961: printf("Leak of %d blocks found in xmlCtxtResetPush",
! 12962: xmlMemBlocks() - mem_base);
! 12963: test_ret++;
! 12964: printf(" %d", n_ctxt);
! 12965: printf(" %d", n_chunk);
! 12966: printf(" %d", n_size);
! 12967: printf(" %d", n_filename);
! 12968: printf(" %d", n_encoding);
! 12969: printf("\n");
! 12970: }
! 12971: }
! 12972: }
! 12973: }
! 12974: }
! 12975: }
! 12976: function_tests++;
! 12977:
! 12978: return(test_ret);
! 12979: }
! 12980:
! 12981:
! 12982: static int
! 12983: test_xmlCtxtUseOptions(void) {
! 12984: int test_ret = 0;
! 12985:
! 12986: int mem_base;
! 12987: int ret_val;
! 12988: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 12989: int n_ctxt;
! 12990: int options; /* a combination of xmlParserOption */
! 12991: int n_options;
! 12992:
! 12993: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 12994: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
! 12995: mem_base = xmlMemBlocks();
! 12996: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 12997: options = gen_parseroptions(n_options, 1);
! 12998:
! 12999: ret_val = xmlCtxtUseOptions(ctxt, options);
! 13000: desret_int(ret_val);
! 13001: call_tests++;
! 13002: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 13003: des_parseroptions(n_options, options, 1);
! 13004: xmlResetLastError();
! 13005: if (mem_base != xmlMemBlocks()) {
! 13006: printf("Leak of %d blocks found in xmlCtxtUseOptions",
! 13007: xmlMemBlocks() - mem_base);
! 13008: test_ret++;
! 13009: printf(" %d", n_ctxt);
! 13010: printf(" %d", n_options);
! 13011: printf("\n");
! 13012: }
! 13013: }
! 13014: }
! 13015: function_tests++;
! 13016:
! 13017: return(test_ret);
! 13018: }
! 13019:
! 13020:
! 13021: static int
! 13022: test_xmlGetExternalEntityLoader(void) {
! 13023: int test_ret = 0;
! 13024:
! 13025:
! 13026: /* missing type support */
! 13027: return(test_ret);
! 13028: }
! 13029:
! 13030:
! 13031: static int
! 13032: test_xmlGetFeature(void) {
! 13033: int test_ret = 0;
! 13034:
! 13035: #if defined(LIBXML_LEGACY_ENABLED)
! 13036: #ifdef LIBXML_LEGACY_ENABLED
! 13037: int mem_base;
! 13038: int ret_val;
! 13039: xmlParserCtxtPtr ctxt; /* an XML/HTML parser context */
! 13040: int n_ctxt;
! 13041: char * name; /* the feature name */
! 13042: int n_name;
! 13043: void * result; /* location to store the result */
! 13044: int n_result;
! 13045:
! 13046: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 13047: for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
! 13048: for (n_result = 0;n_result < gen_nb_void_ptr;n_result++) {
! 13049: mem_base = xmlMemBlocks();
! 13050: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 13051: name = gen_const_char_ptr(n_name, 1);
! 13052: result = gen_void_ptr(n_result, 2);
! 13053:
! 13054: ret_val = xmlGetFeature(ctxt, (const char *)name, result);
! 13055: desret_int(ret_val);
! 13056: call_tests++;
! 13057: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 13058: des_const_char_ptr(n_name, (const char *)name, 1);
! 13059: des_void_ptr(n_result, result, 2);
! 13060: xmlResetLastError();
! 13061: if (mem_base != xmlMemBlocks()) {
! 13062: printf("Leak of %d blocks found in xmlGetFeature",
! 13063: xmlMemBlocks() - mem_base);
! 13064: test_ret++;
! 13065: printf(" %d", n_ctxt);
! 13066: printf(" %d", n_name);
! 13067: printf(" %d", n_result);
! 13068: printf("\n");
! 13069: }
! 13070: }
! 13071: }
! 13072: }
! 13073: function_tests++;
! 13074: #endif
! 13075: #endif
! 13076:
! 13077: return(test_ret);
! 13078: }
! 13079:
! 13080:
! 13081: #define gen_nb_const_char_ptr_ptr 1
! 13082: static char ** gen_const_char_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 13083: return(NULL);
! 13084: }
! 13085: static void des_const_char_ptr_ptr(int no ATTRIBUTE_UNUSED, const char ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 13086: }
! 13087:
! 13088: static int
! 13089: test_xmlGetFeaturesList(void) {
! 13090: int test_ret = 0;
! 13091:
! 13092: #if defined(LIBXML_LEGACY_ENABLED)
! 13093: #ifdef LIBXML_LEGACY_ENABLED
! 13094: int mem_base;
! 13095: int ret_val;
! 13096: int * len; /* the length of the features name array (input/output) */
! 13097: int n_len;
! 13098: char ** result; /* an array of string to be filled with the features name. */
! 13099: int n_result;
! 13100:
! 13101: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
! 13102: for (n_result = 0;n_result < gen_nb_const_char_ptr_ptr;n_result++) {
! 13103: mem_base = xmlMemBlocks();
! 13104: len = gen_int_ptr(n_len, 0);
! 13105: result = gen_const_char_ptr_ptr(n_result, 1);
! 13106:
! 13107: ret_val = xmlGetFeaturesList(len, (const char **)result);
! 13108: desret_int(ret_val);
! 13109: call_tests++;
! 13110: des_int_ptr(n_len, len, 0);
! 13111: des_const_char_ptr_ptr(n_result, (const char **)result, 1);
! 13112: xmlResetLastError();
! 13113: if (mem_base != xmlMemBlocks()) {
! 13114: printf("Leak of %d blocks found in xmlGetFeaturesList",
! 13115: xmlMemBlocks() - mem_base);
! 13116: test_ret++;
! 13117: printf(" %d", n_len);
! 13118: printf(" %d", n_result);
! 13119: printf("\n");
! 13120: }
! 13121: }
! 13122: }
! 13123: function_tests++;
! 13124: #endif
! 13125: #endif
! 13126:
! 13127: return(test_ret);
! 13128: }
! 13129:
! 13130:
! 13131: static int
! 13132: test_xmlHasFeature(void) {
! 13133: int test_ret = 0;
! 13134:
! 13135: int mem_base;
! 13136: int ret_val;
! 13137: xmlFeature feature; /* the feature to be examined */
! 13138: int n_feature;
! 13139:
! 13140: for (n_feature = 0;n_feature < gen_nb_xmlFeature;n_feature++) {
! 13141: mem_base = xmlMemBlocks();
! 13142: feature = gen_xmlFeature(n_feature, 0);
! 13143:
! 13144: ret_val = xmlHasFeature(feature);
! 13145: desret_int(ret_val);
! 13146: call_tests++;
! 13147: des_xmlFeature(n_feature, feature, 0);
! 13148: xmlResetLastError();
! 13149: if (mem_base != xmlMemBlocks()) {
! 13150: printf("Leak of %d blocks found in xmlHasFeature",
! 13151: xmlMemBlocks() - mem_base);
! 13152: test_ret++;
! 13153: printf(" %d", n_feature);
! 13154: printf("\n");
! 13155: }
! 13156: }
! 13157: function_tests++;
! 13158:
! 13159: return(test_ret);
! 13160: }
! 13161:
! 13162:
! 13163: static int
! 13164: test_xmlIOParseDTD(void) {
! 13165: int test_ret = 0;
! 13166:
! 13167: #if defined(LIBXML_VALID_ENABLED)
! 13168: #ifdef LIBXML_VALID_ENABLED
! 13169: xmlDtdPtr ret_val;
! 13170: xmlSAXHandlerPtr sax; /* the SAX handler block or NULL */
! 13171: int n_sax;
! 13172: xmlParserInputBufferPtr input; /* an Input Buffer */
! 13173: int n_input;
! 13174: xmlCharEncoding enc; /* the charset encoding if known */
! 13175: int n_enc;
! 13176:
! 13177: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
! 13178: for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
! 13179: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
! 13180: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
! 13181: input = gen_xmlParserInputBufferPtr(n_input, 1);
! 13182: enc = gen_xmlCharEncoding(n_enc, 2);
! 13183:
! 13184: ret_val = xmlIOParseDTD(sax, input, enc);
! 13185: input = NULL;
! 13186: desret_xmlDtdPtr(ret_val);
! 13187: call_tests++;
! 13188: des_xmlSAXHandlerPtr(n_sax, sax, 0);
! 13189: des_xmlParserInputBufferPtr(n_input, input, 1);
! 13190: des_xmlCharEncoding(n_enc, enc, 2);
! 13191: xmlResetLastError();
! 13192: }
! 13193: }
! 13194: }
! 13195: function_tests++;
! 13196: #endif
! 13197: #endif
! 13198:
! 13199: return(test_ret);
! 13200: }
! 13201:
! 13202:
! 13203: static int
! 13204: test_xmlInitNodeInfoSeq(void) {
! 13205: int test_ret = 0;
! 13206:
! 13207: int mem_base;
! 13208: xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */
! 13209: int n_seq;
! 13210:
! 13211: for (n_seq = 0;n_seq < gen_nb_xmlParserNodeInfoSeqPtr;n_seq++) {
! 13212: mem_base = xmlMemBlocks();
! 13213: seq = gen_xmlParserNodeInfoSeqPtr(n_seq, 0);
! 13214:
! 13215: xmlInitNodeInfoSeq(seq);
! 13216: call_tests++;
! 13217: des_xmlParserNodeInfoSeqPtr(n_seq, seq, 0);
! 13218: xmlResetLastError();
! 13219: if (mem_base != xmlMemBlocks()) {
! 13220: printf("Leak of %d blocks found in xmlInitNodeInfoSeq",
! 13221: xmlMemBlocks() - mem_base);
! 13222: test_ret++;
! 13223: printf(" %d", n_seq);
! 13224: printf("\n");
! 13225: }
! 13226: }
! 13227: function_tests++;
! 13228:
! 13229: return(test_ret);
! 13230: }
! 13231:
! 13232:
! 13233: static int
! 13234: test_xmlInitParser(void) {
! 13235: int test_ret = 0;
! 13236:
! 13237: int mem_base;
! 13238:
! 13239: mem_base = xmlMemBlocks();
! 13240:
! 13241: xmlInitParser();
! 13242: call_tests++;
! 13243: xmlResetLastError();
! 13244: if (mem_base != xmlMemBlocks()) {
! 13245: printf("Leak of %d blocks found in xmlInitParser",
! 13246: xmlMemBlocks() - mem_base);
! 13247: test_ret++;
! 13248: printf("\n");
! 13249: }
! 13250: function_tests++;
! 13251:
! 13252: return(test_ret);
! 13253: }
! 13254:
! 13255:
! 13256: static int
! 13257: test_xmlInitParserCtxt(void) {
! 13258: int test_ret = 0;
! 13259:
! 13260: int mem_base;
! 13261: int ret_val;
! 13262: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 13263: int n_ctxt;
! 13264:
! 13265: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 13266: mem_base = xmlMemBlocks();
! 13267: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 13268:
! 13269: ret_val = xmlInitParserCtxt(ctxt);
! 13270: desret_int(ret_val);
! 13271: call_tests++;
! 13272: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 13273: xmlResetLastError();
! 13274: if (mem_base != xmlMemBlocks()) {
! 13275: printf("Leak of %d blocks found in xmlInitParserCtxt",
! 13276: xmlMemBlocks() - mem_base);
! 13277: test_ret++;
! 13278: printf(" %d", n_ctxt);
! 13279: printf("\n");
! 13280: }
! 13281: }
! 13282: function_tests++;
! 13283:
! 13284: return(test_ret);
! 13285: }
! 13286:
! 13287:
! 13288: static int
! 13289: test_xmlKeepBlanksDefault(void) {
! 13290: int test_ret = 0;
! 13291:
! 13292: int mem_base;
! 13293: int ret_val;
! 13294: int val; /* int 0 or 1 */
! 13295: int n_val;
! 13296:
! 13297: for (n_val = 0;n_val < gen_nb_int;n_val++) {
! 13298: mem_base = xmlMemBlocks();
! 13299: val = gen_int(n_val, 0);
! 13300:
! 13301: ret_val = xmlKeepBlanksDefault(val);
! 13302: desret_int(ret_val);
! 13303: call_tests++;
! 13304: des_int(n_val, val, 0);
! 13305: xmlResetLastError();
! 13306: if (mem_base != xmlMemBlocks()) {
! 13307: printf("Leak of %d blocks found in xmlKeepBlanksDefault",
! 13308: xmlMemBlocks() - mem_base);
! 13309: test_ret++;
! 13310: printf(" %d", n_val);
! 13311: printf("\n");
! 13312: }
! 13313: }
! 13314: function_tests++;
! 13315:
! 13316: return(test_ret);
! 13317: }
! 13318:
! 13319:
! 13320: static int
! 13321: test_xmlLineNumbersDefault(void) {
! 13322: int test_ret = 0;
! 13323:
! 13324: int mem_base;
! 13325: int ret_val;
! 13326: int val; /* int 0 or 1 */
! 13327: int n_val;
! 13328:
! 13329: for (n_val = 0;n_val < gen_nb_int;n_val++) {
! 13330: mem_base = xmlMemBlocks();
! 13331: val = gen_int(n_val, 0);
! 13332:
! 13333: ret_val = xmlLineNumbersDefault(val);
! 13334: desret_int(ret_val);
! 13335: call_tests++;
! 13336: des_int(n_val, val, 0);
! 13337: xmlResetLastError();
! 13338: if (mem_base != xmlMemBlocks()) {
! 13339: printf("Leak of %d blocks found in xmlLineNumbersDefault",
! 13340: xmlMemBlocks() - mem_base);
! 13341: test_ret++;
! 13342: printf(" %d", n_val);
! 13343: printf("\n");
! 13344: }
! 13345: }
! 13346: function_tests++;
! 13347:
! 13348: return(test_ret);
! 13349: }
! 13350:
! 13351:
! 13352: static int
! 13353: test_xmlLoadExternalEntity(void) {
! 13354: int test_ret = 0;
! 13355:
! 13356: int mem_base;
! 13357: xmlParserInputPtr ret_val;
! 13358: const char * URL; /* the URL for the entity to load */
! 13359: int n_URL;
! 13360: char * ID; /* the Public ID for the entity to load */
! 13361: int n_ID;
! 13362: xmlParserCtxtPtr ctxt; /* the context in which the entity is called or NULL */
! 13363: int n_ctxt;
! 13364:
! 13365: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 13366: for (n_ID = 0;n_ID < gen_nb_const_char_ptr;n_ID++) {
! 13367: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 13368: mem_base = xmlMemBlocks();
! 13369: URL = gen_filepath(n_URL, 0);
! 13370: ID = gen_const_char_ptr(n_ID, 1);
! 13371: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 2);
! 13372:
! 13373: ret_val = xmlLoadExternalEntity(URL, (const char *)ID, ctxt);
! 13374: desret_xmlParserInputPtr(ret_val);
! 13375: call_tests++;
! 13376: des_filepath(n_URL, URL, 0);
! 13377: des_const_char_ptr(n_ID, (const char *)ID, 1);
! 13378: des_xmlParserCtxtPtr(n_ctxt, ctxt, 2);
! 13379: xmlResetLastError();
! 13380: if (mem_base != xmlMemBlocks()) {
! 13381: printf("Leak of %d blocks found in xmlLoadExternalEntity",
! 13382: xmlMemBlocks() - mem_base);
! 13383: test_ret++;
! 13384: printf(" %d", n_URL);
! 13385: printf(" %d", n_ID);
! 13386: printf(" %d", n_ctxt);
! 13387: printf("\n");
! 13388: }
! 13389: }
! 13390: }
! 13391: }
! 13392: function_tests++;
! 13393:
! 13394: return(test_ret);
! 13395: }
! 13396:
! 13397:
! 13398: static int
! 13399: test_xmlNewIOInputStream(void) {
! 13400: int test_ret = 0;
! 13401:
! 13402: int mem_base;
! 13403: xmlParserInputPtr ret_val;
! 13404: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 13405: int n_ctxt;
! 13406: xmlParserInputBufferPtr input; /* an I/O Input */
! 13407: int n_input;
! 13408: xmlCharEncoding enc; /* the charset encoding if known */
! 13409: int n_enc;
! 13410:
! 13411: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 13412: for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
! 13413: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
! 13414: mem_base = xmlMemBlocks();
! 13415: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 13416: input = gen_xmlParserInputBufferPtr(n_input, 1);
! 13417: enc = gen_xmlCharEncoding(n_enc, 2);
! 13418:
! 13419: ret_val = xmlNewIOInputStream(ctxt, input, enc);
! 13420: if (ret_val != NULL) input = NULL;
! 13421: desret_xmlParserInputPtr(ret_val);
! 13422: call_tests++;
! 13423: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 13424: des_xmlParserInputBufferPtr(n_input, input, 1);
! 13425: des_xmlCharEncoding(n_enc, enc, 2);
! 13426: xmlResetLastError();
! 13427: if (mem_base != xmlMemBlocks()) {
! 13428: printf("Leak of %d blocks found in xmlNewIOInputStream",
! 13429: xmlMemBlocks() - mem_base);
! 13430: test_ret++;
! 13431: printf(" %d", n_ctxt);
! 13432: printf(" %d", n_input);
! 13433: printf(" %d", n_enc);
! 13434: printf("\n");
! 13435: }
! 13436: }
! 13437: }
! 13438: }
! 13439: function_tests++;
! 13440:
! 13441: return(test_ret);
! 13442: }
! 13443:
! 13444:
! 13445: static int
! 13446: test_xmlNewParserCtxt(void) {
! 13447: int test_ret = 0;
! 13448:
! 13449: int mem_base;
! 13450: xmlParserCtxtPtr ret_val;
! 13451:
! 13452: mem_base = xmlMemBlocks();
! 13453:
! 13454: ret_val = xmlNewParserCtxt();
! 13455: desret_xmlParserCtxtPtr(ret_val);
! 13456: call_tests++;
! 13457: xmlResetLastError();
! 13458: if (mem_base != xmlMemBlocks()) {
! 13459: printf("Leak of %d blocks found in xmlNewParserCtxt",
! 13460: xmlMemBlocks() - mem_base);
! 13461: test_ret++;
! 13462: printf("\n");
! 13463: }
! 13464: function_tests++;
! 13465:
! 13466: return(test_ret);
! 13467: }
! 13468:
! 13469:
! 13470: #define gen_nb_xmlNodePtr_ptr 1
! 13471: static xmlNodePtr * gen_xmlNodePtr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 13472: return(NULL);
! 13473: }
! 13474: static void des_xmlNodePtr_ptr(int no ATTRIBUTE_UNUSED, xmlNodePtr * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 13475: }
! 13476:
! 13477: static int
! 13478: test_xmlParseBalancedChunkMemory(void) {
! 13479: int test_ret = 0;
! 13480:
! 13481: #if defined(LIBXML_SAX1_ENABLED)
! 13482: #ifdef LIBXML_SAX1_ENABLED
! 13483: int mem_base;
! 13484: int ret_val;
! 13485: xmlDocPtr doc; /* the document the chunk pertains to */
! 13486: int n_doc;
! 13487: xmlSAXHandlerPtr sax; /* the SAX handler bloc (possibly NULL) */
! 13488: int n_sax;
! 13489: void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */
! 13490: int n_user_data;
! 13491: int depth; /* Used for loop detection, use 0 */
! 13492: int n_depth;
! 13493: xmlChar * string; /* the input string in UTF8 or ISO-Latin (zero terminated) */
! 13494: int n_string;
! 13495: xmlNodePtr * lst; /* the return value for the set of parsed nodes */
! 13496: int n_lst;
! 13497:
! 13498: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 13499: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
! 13500: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
! 13501: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
! 13502: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
! 13503: for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
! 13504: mem_base = xmlMemBlocks();
! 13505: doc = gen_xmlDocPtr(n_doc, 0);
! 13506: sax = gen_xmlSAXHandlerPtr(n_sax, 1);
! 13507: user_data = gen_userdata(n_user_data, 2);
! 13508: depth = gen_int(n_depth, 3);
! 13509: string = gen_const_xmlChar_ptr(n_string, 4);
! 13510: lst = gen_xmlNodePtr_ptr(n_lst, 5);
! 13511:
! 13512: #ifdef LIBXML_SAX1_ENABLED
! 13513: if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
! 13514: #endif
! 13515:
! 13516:
! 13517: ret_val = xmlParseBalancedChunkMemory(doc, sax, user_data, depth, (const xmlChar *)string, lst);
! 13518: desret_int(ret_val);
! 13519: call_tests++;
! 13520: des_xmlDocPtr(n_doc, doc, 0);
! 13521: des_xmlSAXHandlerPtr(n_sax, sax, 1);
! 13522: des_userdata(n_user_data, user_data, 2);
! 13523: des_int(n_depth, depth, 3);
! 13524: des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 4);
! 13525: des_xmlNodePtr_ptr(n_lst, lst, 5);
! 13526: xmlResetLastError();
! 13527: if (mem_base != xmlMemBlocks()) {
! 13528: printf("Leak of %d blocks found in xmlParseBalancedChunkMemory",
! 13529: xmlMemBlocks() - mem_base);
! 13530: test_ret++;
! 13531: printf(" %d", n_doc);
! 13532: printf(" %d", n_sax);
! 13533: printf(" %d", n_user_data);
! 13534: printf(" %d", n_depth);
! 13535: printf(" %d", n_string);
! 13536: printf(" %d", n_lst);
! 13537: printf("\n");
! 13538: }
! 13539: }
! 13540: }
! 13541: }
! 13542: }
! 13543: }
! 13544: }
! 13545: function_tests++;
! 13546: #endif
! 13547: #endif
! 13548:
! 13549: return(test_ret);
! 13550: }
! 13551:
! 13552:
! 13553: static int
! 13554: test_xmlParseBalancedChunkMemoryRecover(void) {
! 13555: int test_ret = 0;
! 13556:
! 13557: #if defined(LIBXML_SAX1_ENABLED)
! 13558: #ifdef LIBXML_SAX1_ENABLED
! 13559: int mem_base;
! 13560: int ret_val;
! 13561: xmlDocPtr doc; /* the document the chunk pertains to */
! 13562: int n_doc;
! 13563: xmlSAXHandlerPtr sax; /* the SAX handler bloc (possibly NULL) */
! 13564: int n_sax;
! 13565: void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */
! 13566: int n_user_data;
! 13567: int depth; /* Used for loop detection, use 0 */
! 13568: int n_depth;
! 13569: xmlChar * string; /* the input string in UTF8 or ISO-Latin (zero terminated) */
! 13570: int n_string;
! 13571: xmlNodePtr * lst; /* the return value for the set of parsed nodes */
! 13572: int n_lst;
! 13573: int recover; /* return nodes even if the data is broken (use 0) */
! 13574: int n_recover;
! 13575:
! 13576: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 13577: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
! 13578: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
! 13579: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
! 13580: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
! 13581: for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
! 13582: for (n_recover = 0;n_recover < gen_nb_int;n_recover++) {
! 13583: mem_base = xmlMemBlocks();
! 13584: doc = gen_xmlDocPtr(n_doc, 0);
! 13585: sax = gen_xmlSAXHandlerPtr(n_sax, 1);
! 13586: user_data = gen_userdata(n_user_data, 2);
! 13587: depth = gen_int(n_depth, 3);
! 13588: string = gen_const_xmlChar_ptr(n_string, 4);
! 13589: lst = gen_xmlNodePtr_ptr(n_lst, 5);
! 13590: recover = gen_int(n_recover, 6);
! 13591:
! 13592: #ifdef LIBXML_SAX1_ENABLED
! 13593: if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
! 13594: #endif
! 13595:
! 13596:
! 13597: ret_val = xmlParseBalancedChunkMemoryRecover(doc, sax, user_data, depth, (const xmlChar *)string, lst, recover);
! 13598: desret_int(ret_val);
! 13599: call_tests++;
! 13600: des_xmlDocPtr(n_doc, doc, 0);
! 13601: des_xmlSAXHandlerPtr(n_sax, sax, 1);
! 13602: des_userdata(n_user_data, user_data, 2);
! 13603: des_int(n_depth, depth, 3);
! 13604: des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 4);
! 13605: des_xmlNodePtr_ptr(n_lst, lst, 5);
! 13606: des_int(n_recover, recover, 6);
! 13607: xmlResetLastError();
! 13608: if (mem_base != xmlMemBlocks()) {
! 13609: printf("Leak of %d blocks found in xmlParseBalancedChunkMemoryRecover",
! 13610: xmlMemBlocks() - mem_base);
! 13611: test_ret++;
! 13612: printf(" %d", n_doc);
! 13613: printf(" %d", n_sax);
! 13614: printf(" %d", n_user_data);
! 13615: printf(" %d", n_depth);
! 13616: printf(" %d", n_string);
! 13617: printf(" %d", n_lst);
! 13618: printf(" %d", n_recover);
! 13619: printf("\n");
! 13620: }
! 13621: }
! 13622: }
! 13623: }
! 13624: }
! 13625: }
! 13626: }
! 13627: }
! 13628: function_tests++;
! 13629: #endif
! 13630: #endif
! 13631:
! 13632: return(test_ret);
! 13633: }
! 13634:
! 13635:
! 13636: static int
! 13637: test_xmlParseChunk(void) {
! 13638: int test_ret = 0;
! 13639:
! 13640: #if defined(LIBXML_PUSH_ENABLED)
! 13641: int mem_base;
! 13642: int ret_val;
! 13643: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 13644: int n_ctxt;
! 13645: char * chunk; /* an char array */
! 13646: int n_chunk;
! 13647: int size; /* the size in byte of the chunk */
! 13648: int n_size;
! 13649: int terminate; /* last chunk indicator */
! 13650: int n_terminate;
! 13651:
! 13652: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 13653: for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
! 13654: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 13655: for (n_terminate = 0;n_terminate < gen_nb_int;n_terminate++) {
! 13656: mem_base = xmlMemBlocks();
! 13657: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 13658: chunk = gen_const_char_ptr(n_chunk, 1);
! 13659: size = gen_int(n_size, 2);
! 13660: terminate = gen_int(n_terminate, 3);
! 13661:
! 13662: ret_val = xmlParseChunk(ctxt, (const char *)chunk, size, terminate);
! 13663: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
! 13664: desret_int(ret_val);
! 13665: call_tests++;
! 13666: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 13667: des_const_char_ptr(n_chunk, (const char *)chunk, 1);
! 13668: des_int(n_size, size, 2);
! 13669: des_int(n_terminate, terminate, 3);
! 13670: xmlResetLastError();
! 13671: if (mem_base != xmlMemBlocks()) {
! 13672: printf("Leak of %d blocks found in xmlParseChunk",
! 13673: xmlMemBlocks() - mem_base);
! 13674: test_ret++;
! 13675: printf(" %d", n_ctxt);
! 13676: printf(" %d", n_chunk);
! 13677: printf(" %d", n_size);
! 13678: printf(" %d", n_terminate);
! 13679: printf("\n");
! 13680: }
! 13681: }
! 13682: }
! 13683: }
! 13684: }
! 13685: function_tests++;
! 13686: #endif
! 13687:
! 13688: return(test_ret);
! 13689: }
! 13690:
! 13691:
! 13692: static int
! 13693: test_xmlParseCtxtExternalEntity(void) {
! 13694: int test_ret = 0;
! 13695:
! 13696: int mem_base;
! 13697: int ret_val;
! 13698: xmlParserCtxtPtr ctx; /* the existing parsing context */
! 13699: int n_ctx;
! 13700: xmlChar * URL; /* the URL for the entity to load */
! 13701: int n_URL;
! 13702: xmlChar * ID; /* the System ID for the entity to load */
! 13703: int n_ID;
! 13704: xmlNodePtr * lst; /* the return value for the set of parsed nodes */
! 13705: int n_lst;
! 13706:
! 13707: for (n_ctx = 0;n_ctx < gen_nb_xmlParserCtxtPtr;n_ctx++) {
! 13708: for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) {
! 13709: for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
! 13710: for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
! 13711: mem_base = xmlMemBlocks();
! 13712: ctx = gen_xmlParserCtxtPtr(n_ctx, 0);
! 13713: URL = gen_const_xmlChar_ptr(n_URL, 1);
! 13714: ID = gen_const_xmlChar_ptr(n_ID, 2);
! 13715: lst = gen_xmlNodePtr_ptr(n_lst, 3);
! 13716:
! 13717: ret_val = xmlParseCtxtExternalEntity(ctx, (const xmlChar *)URL, (const xmlChar *)ID, lst);
! 13718: desret_int(ret_val);
! 13719: call_tests++;
! 13720: des_xmlParserCtxtPtr(n_ctx, ctx, 0);
! 13721: des_const_xmlChar_ptr(n_URL, (const xmlChar *)URL, 1);
! 13722: des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 2);
! 13723: des_xmlNodePtr_ptr(n_lst, lst, 3);
! 13724: xmlResetLastError();
! 13725: if (mem_base != xmlMemBlocks()) {
! 13726: printf("Leak of %d blocks found in xmlParseCtxtExternalEntity",
! 13727: xmlMemBlocks() - mem_base);
! 13728: test_ret++;
! 13729: printf(" %d", n_ctx);
! 13730: printf(" %d", n_URL);
! 13731: printf(" %d", n_ID);
! 13732: printf(" %d", n_lst);
! 13733: printf("\n");
! 13734: }
! 13735: }
! 13736: }
! 13737: }
! 13738: }
! 13739: function_tests++;
! 13740:
! 13741: return(test_ret);
! 13742: }
! 13743:
! 13744:
! 13745: static int
! 13746: test_xmlParseDTD(void) {
! 13747: int test_ret = 0;
! 13748:
! 13749: #if defined(LIBXML_VALID_ENABLED)
! 13750: #ifdef LIBXML_VALID_ENABLED
! 13751: int mem_base;
! 13752: xmlDtdPtr ret_val;
! 13753: xmlChar * ExternalID; /* a NAME* containing the External ID of the DTD */
! 13754: int n_ExternalID;
! 13755: xmlChar * SystemID; /* a NAME* containing the URL to the DTD */
! 13756: int n_SystemID;
! 13757:
! 13758: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
! 13759: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
! 13760: mem_base = xmlMemBlocks();
! 13761: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 0);
! 13762: SystemID = gen_const_xmlChar_ptr(n_SystemID, 1);
! 13763:
! 13764: ret_val = xmlParseDTD((const xmlChar *)ExternalID, (const xmlChar *)SystemID);
! 13765: desret_xmlDtdPtr(ret_val);
! 13766: call_tests++;
! 13767: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 0);
! 13768: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 1);
! 13769: xmlResetLastError();
! 13770: if (mem_base != xmlMemBlocks()) {
! 13771: printf("Leak of %d blocks found in xmlParseDTD",
! 13772: xmlMemBlocks() - mem_base);
! 13773: test_ret++;
! 13774: printf(" %d", n_ExternalID);
! 13775: printf(" %d", n_SystemID);
! 13776: printf("\n");
! 13777: }
! 13778: }
! 13779: }
! 13780: function_tests++;
! 13781: #endif
! 13782: #endif
! 13783:
! 13784: return(test_ret);
! 13785: }
! 13786:
! 13787:
! 13788: static int
! 13789: test_xmlParseDoc(void) {
! 13790: int test_ret = 0;
! 13791:
! 13792: #if defined(LIBXML_SAX1_ENABLED)
! 13793: #ifdef LIBXML_SAX1_ENABLED
! 13794: int mem_base;
! 13795: xmlDocPtr ret_val;
! 13796: xmlChar * cur; /* a pointer to an array of xmlChar */
! 13797: int n_cur;
! 13798:
! 13799: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
! 13800: mem_base = xmlMemBlocks();
! 13801: cur = gen_const_xmlChar_ptr(n_cur, 0);
! 13802:
! 13803: ret_val = xmlParseDoc((const xmlChar *)cur);
! 13804: desret_xmlDocPtr(ret_val);
! 13805: call_tests++;
! 13806: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
! 13807: xmlResetLastError();
! 13808: if (mem_base != xmlMemBlocks()) {
! 13809: printf("Leak of %d blocks found in xmlParseDoc",
! 13810: xmlMemBlocks() - mem_base);
! 13811: test_ret++;
! 13812: printf(" %d", n_cur);
! 13813: printf("\n");
! 13814: }
! 13815: }
! 13816: function_tests++;
! 13817: #endif
! 13818: #endif
! 13819:
! 13820: return(test_ret);
! 13821: }
! 13822:
! 13823:
! 13824: static int
! 13825: test_xmlParseDocument(void) {
! 13826: int test_ret = 0;
! 13827:
! 13828: int mem_base;
! 13829: int ret_val;
! 13830: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 13831: int n_ctxt;
! 13832:
! 13833: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 13834: mem_base = xmlMemBlocks();
! 13835: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 13836:
! 13837: ret_val = xmlParseDocument(ctxt);
! 13838: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
! 13839: desret_int(ret_val);
! 13840: call_tests++;
! 13841: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 13842: xmlResetLastError();
! 13843: if (mem_base != xmlMemBlocks()) {
! 13844: printf("Leak of %d blocks found in xmlParseDocument",
! 13845: xmlMemBlocks() - mem_base);
! 13846: test_ret++;
! 13847: printf(" %d", n_ctxt);
! 13848: printf("\n");
! 13849: }
! 13850: }
! 13851: function_tests++;
! 13852:
! 13853: return(test_ret);
! 13854: }
! 13855:
! 13856:
! 13857: static int
! 13858: test_xmlParseEntity(void) {
! 13859: int test_ret = 0;
! 13860:
! 13861: #if defined(LIBXML_SAX1_ENABLED)
! 13862: #ifdef LIBXML_SAX1_ENABLED
! 13863: int mem_base;
! 13864: xmlDocPtr ret_val;
! 13865: const char * filename; /* the filename */
! 13866: int n_filename;
! 13867:
! 13868: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 13869: mem_base = xmlMemBlocks();
! 13870: filename = gen_filepath(n_filename, 0);
! 13871:
! 13872: ret_val = xmlParseEntity(filename);
! 13873: desret_xmlDocPtr(ret_val);
! 13874: call_tests++;
! 13875: des_filepath(n_filename, filename, 0);
! 13876: xmlResetLastError();
! 13877: if (mem_base != xmlMemBlocks()) {
! 13878: printf("Leak of %d blocks found in xmlParseEntity",
! 13879: xmlMemBlocks() - mem_base);
! 13880: test_ret++;
! 13881: printf(" %d", n_filename);
! 13882: printf("\n");
! 13883: }
! 13884: }
! 13885: function_tests++;
! 13886: #endif
! 13887: #endif
! 13888:
! 13889: return(test_ret);
! 13890: }
! 13891:
! 13892:
! 13893: static int
! 13894: test_xmlParseExtParsedEnt(void) {
! 13895: int test_ret = 0;
! 13896:
! 13897: int mem_base;
! 13898: int ret_val;
! 13899: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 13900: int n_ctxt;
! 13901:
! 13902: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 13903: mem_base = xmlMemBlocks();
! 13904: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 13905:
! 13906: ret_val = xmlParseExtParsedEnt(ctxt);
! 13907: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
! 13908: desret_int(ret_val);
! 13909: call_tests++;
! 13910: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 13911: xmlResetLastError();
! 13912: if (mem_base != xmlMemBlocks()) {
! 13913: printf("Leak of %d blocks found in xmlParseExtParsedEnt",
! 13914: xmlMemBlocks() - mem_base);
! 13915: test_ret++;
! 13916: printf(" %d", n_ctxt);
! 13917: printf("\n");
! 13918: }
! 13919: }
! 13920: function_tests++;
! 13921:
! 13922: return(test_ret);
! 13923: }
! 13924:
! 13925:
! 13926: static int
! 13927: test_xmlParseExternalEntity(void) {
! 13928: int test_ret = 0;
! 13929:
! 13930: #if defined(LIBXML_SAX1_ENABLED)
! 13931: #ifdef LIBXML_SAX1_ENABLED
! 13932: int mem_base;
! 13933: int ret_val;
! 13934: xmlDocPtr doc; /* the document the chunk pertains to */
! 13935: int n_doc;
! 13936: xmlSAXHandlerPtr sax; /* the SAX handler bloc (possibly NULL) */
! 13937: int n_sax;
! 13938: void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */
! 13939: int n_user_data;
! 13940: int depth; /* Used for loop detection, use 0 */
! 13941: int n_depth;
! 13942: xmlChar * URL; /* the URL for the entity to load */
! 13943: int n_URL;
! 13944: xmlChar * ID; /* the System ID for the entity to load */
! 13945: int n_ID;
! 13946: xmlNodePtr * lst; /* the return value for the set of parsed nodes */
! 13947: int n_lst;
! 13948:
! 13949: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 13950: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
! 13951: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
! 13952: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
! 13953: for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) {
! 13954: for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
! 13955: for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
! 13956: mem_base = xmlMemBlocks();
! 13957: doc = gen_xmlDocPtr(n_doc, 0);
! 13958: sax = gen_xmlSAXHandlerPtr(n_sax, 1);
! 13959: user_data = gen_userdata(n_user_data, 2);
! 13960: depth = gen_int(n_depth, 3);
! 13961: URL = gen_const_xmlChar_ptr(n_URL, 4);
! 13962: ID = gen_const_xmlChar_ptr(n_ID, 5);
! 13963: lst = gen_xmlNodePtr_ptr(n_lst, 6);
! 13964:
! 13965: ret_val = xmlParseExternalEntity(doc, sax, user_data, depth, (const xmlChar *)URL, (const xmlChar *)ID, lst);
! 13966: desret_int(ret_val);
! 13967: call_tests++;
! 13968: des_xmlDocPtr(n_doc, doc, 0);
! 13969: des_xmlSAXHandlerPtr(n_sax, sax, 1);
! 13970: des_userdata(n_user_data, user_data, 2);
! 13971: des_int(n_depth, depth, 3);
! 13972: des_const_xmlChar_ptr(n_URL, (const xmlChar *)URL, 4);
! 13973: des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 5);
! 13974: des_xmlNodePtr_ptr(n_lst, lst, 6);
! 13975: xmlResetLastError();
! 13976: if (mem_base != xmlMemBlocks()) {
! 13977: printf("Leak of %d blocks found in xmlParseExternalEntity",
! 13978: xmlMemBlocks() - mem_base);
! 13979: test_ret++;
! 13980: printf(" %d", n_doc);
! 13981: printf(" %d", n_sax);
! 13982: printf(" %d", n_user_data);
! 13983: printf(" %d", n_depth);
! 13984: printf(" %d", n_URL);
! 13985: printf(" %d", n_ID);
! 13986: printf(" %d", n_lst);
! 13987: printf("\n");
! 13988: }
! 13989: }
! 13990: }
! 13991: }
! 13992: }
! 13993: }
! 13994: }
! 13995: }
! 13996: function_tests++;
! 13997: #endif
! 13998: #endif
! 13999:
! 14000: return(test_ret);
! 14001: }
! 14002:
! 14003:
! 14004: static int
! 14005: test_xmlParseFile(void) {
! 14006: int test_ret = 0;
! 14007:
! 14008: #if defined(LIBXML_SAX1_ENABLED)
! 14009: #ifdef LIBXML_SAX1_ENABLED
! 14010: int mem_base;
! 14011: xmlDocPtr ret_val;
! 14012: const char * filename; /* the filename */
! 14013: int n_filename;
! 14014:
! 14015: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 14016: mem_base = xmlMemBlocks();
! 14017: filename = gen_filepath(n_filename, 0);
! 14018:
! 14019: ret_val = xmlParseFile(filename);
! 14020: desret_xmlDocPtr(ret_val);
! 14021: call_tests++;
! 14022: des_filepath(n_filename, filename, 0);
! 14023: xmlResetLastError();
! 14024: if (mem_base != xmlMemBlocks()) {
! 14025: printf("Leak of %d blocks found in xmlParseFile",
! 14026: xmlMemBlocks() - mem_base);
! 14027: test_ret++;
! 14028: printf(" %d", n_filename);
! 14029: printf("\n");
! 14030: }
! 14031: }
! 14032: function_tests++;
! 14033: #endif
! 14034: #endif
! 14035:
! 14036: return(test_ret);
! 14037: }
! 14038:
! 14039:
! 14040: static int
! 14041: test_xmlParseInNodeContext(void) {
! 14042: int test_ret = 0;
! 14043:
! 14044: int mem_base;
! 14045: xmlParserErrors ret_val;
! 14046: xmlNodePtr node; /* the context node */
! 14047: int n_node;
! 14048: char * data; /* the input string */
! 14049: int n_data;
! 14050: int datalen; /* the input string length in bytes */
! 14051: int n_datalen;
! 14052: int options; /* a combination of xmlParserOption */
! 14053: int n_options;
! 14054: xmlNodePtr * lst; /* the return value for the set of parsed nodes */
! 14055: int n_lst;
! 14056:
! 14057: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 14058: for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) {
! 14059: for (n_datalen = 0;n_datalen < gen_nb_int;n_datalen++) {
! 14060: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
! 14061: for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
! 14062: mem_base = xmlMemBlocks();
! 14063: node = gen_xmlNodePtr(n_node, 0);
! 14064: data = gen_const_char_ptr(n_data, 1);
! 14065: datalen = gen_int(n_datalen, 2);
! 14066: options = gen_parseroptions(n_options, 3);
! 14067: lst = gen_xmlNodePtr_ptr(n_lst, 4);
! 14068:
! 14069: ret_val = xmlParseInNodeContext(node, (const char *)data, datalen, options, lst);
! 14070: desret_xmlParserErrors(ret_val);
! 14071: call_tests++;
! 14072: des_xmlNodePtr(n_node, node, 0);
! 14073: des_const_char_ptr(n_data, (const char *)data, 1);
! 14074: des_int(n_datalen, datalen, 2);
! 14075: des_parseroptions(n_options, options, 3);
! 14076: des_xmlNodePtr_ptr(n_lst, lst, 4);
! 14077: xmlResetLastError();
! 14078: if (mem_base != xmlMemBlocks()) {
! 14079: printf("Leak of %d blocks found in xmlParseInNodeContext",
! 14080: xmlMemBlocks() - mem_base);
! 14081: test_ret++;
! 14082: printf(" %d", n_node);
! 14083: printf(" %d", n_data);
! 14084: printf(" %d", n_datalen);
! 14085: printf(" %d", n_options);
! 14086: printf(" %d", n_lst);
! 14087: printf("\n");
! 14088: }
! 14089: }
! 14090: }
! 14091: }
! 14092: }
! 14093: }
! 14094: function_tests++;
! 14095:
! 14096: return(test_ret);
! 14097: }
! 14098:
! 14099:
! 14100: static int
! 14101: test_xmlParseMemory(void) {
! 14102: int test_ret = 0;
! 14103:
! 14104: #if defined(LIBXML_SAX1_ENABLED)
! 14105: #ifdef LIBXML_SAX1_ENABLED
! 14106: int mem_base;
! 14107: xmlDocPtr ret_val;
! 14108: char * buffer; /* an pointer to a char array */
! 14109: int n_buffer;
! 14110: int size; /* the size of the array */
! 14111: int n_size;
! 14112:
! 14113: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
! 14114: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 14115: mem_base = xmlMemBlocks();
! 14116: buffer = gen_const_char_ptr(n_buffer, 0);
! 14117: size = gen_int(n_size, 1);
! 14118:
! 14119: ret_val = xmlParseMemory((const char *)buffer, size);
! 14120: desret_xmlDocPtr(ret_val);
! 14121: call_tests++;
! 14122: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
! 14123: des_int(n_size, size, 1);
! 14124: xmlResetLastError();
! 14125: if (mem_base != xmlMemBlocks()) {
! 14126: printf("Leak of %d blocks found in xmlParseMemory",
! 14127: xmlMemBlocks() - mem_base);
! 14128: test_ret++;
! 14129: printf(" %d", n_buffer);
! 14130: printf(" %d", n_size);
! 14131: printf("\n");
! 14132: }
! 14133: }
! 14134: }
! 14135: function_tests++;
! 14136: #endif
! 14137: #endif
! 14138:
! 14139: return(test_ret);
! 14140: }
! 14141:
! 14142:
! 14143: #define gen_nb_const_xmlParserNodeInfoPtr 1
! 14144: static xmlParserNodeInfoPtr gen_const_xmlParserNodeInfoPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 14145: return(NULL);
! 14146: }
! 14147: static void des_const_xmlParserNodeInfoPtr(int no ATTRIBUTE_UNUSED, const xmlParserNodeInfoPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 14148: }
! 14149:
! 14150: static int
! 14151: test_xmlParserAddNodeInfo(void) {
! 14152: int test_ret = 0;
! 14153:
! 14154: int mem_base;
! 14155: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 14156: int n_ctxt;
! 14157: xmlParserNodeInfoPtr info; /* a node info sequence pointer */
! 14158: int n_info;
! 14159:
! 14160: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 14161: for (n_info = 0;n_info < gen_nb_const_xmlParserNodeInfoPtr;n_info++) {
! 14162: mem_base = xmlMemBlocks();
! 14163: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 14164: info = gen_const_xmlParserNodeInfoPtr(n_info, 1);
! 14165:
! 14166: xmlParserAddNodeInfo(ctxt, (const xmlParserNodeInfoPtr)info);
! 14167: call_tests++;
! 14168: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 14169: des_const_xmlParserNodeInfoPtr(n_info, (const xmlParserNodeInfoPtr)info, 1);
! 14170: xmlResetLastError();
! 14171: if (mem_base != xmlMemBlocks()) {
! 14172: printf("Leak of %d blocks found in xmlParserAddNodeInfo",
! 14173: xmlMemBlocks() - mem_base);
! 14174: test_ret++;
! 14175: printf(" %d", n_ctxt);
! 14176: printf(" %d", n_info);
! 14177: printf("\n");
! 14178: }
! 14179: }
! 14180: }
! 14181: function_tests++;
! 14182:
! 14183: return(test_ret);
! 14184: }
! 14185:
! 14186:
! 14187: #define gen_nb_const_xmlParserCtxtPtr 1
! 14188: static xmlParserCtxtPtr gen_const_xmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 14189: return(NULL);
! 14190: }
! 14191: static void des_const_xmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, const xmlParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 14192: }
! 14193:
! 14194: #define gen_nb_const_xmlNodePtr 1
! 14195: static xmlNodePtr gen_const_xmlNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 14196: return(NULL);
! 14197: }
! 14198: static void des_const_xmlNodePtr(int no ATTRIBUTE_UNUSED, const xmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 14199: }
! 14200:
! 14201: static int
! 14202: test_xmlParserFindNodeInfo(void) {
! 14203: int test_ret = 0;
! 14204:
! 14205: int mem_base;
! 14206: const xmlParserNodeInfo * ret_val;
! 14207: xmlParserCtxtPtr ctx; /* an XML parser context */
! 14208: int n_ctx;
! 14209: xmlNodePtr node; /* an XML node within the tree */
! 14210: int n_node;
! 14211:
! 14212: for (n_ctx = 0;n_ctx < gen_nb_const_xmlParserCtxtPtr;n_ctx++) {
! 14213: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
! 14214: mem_base = xmlMemBlocks();
! 14215: ctx = gen_const_xmlParserCtxtPtr(n_ctx, 0);
! 14216: node = gen_const_xmlNodePtr(n_node, 1);
! 14217:
! 14218: ret_val = xmlParserFindNodeInfo((const xmlParserCtxtPtr)ctx, (const xmlNodePtr)node);
! 14219: desret_const_xmlParserNodeInfo_ptr(ret_val);
! 14220: call_tests++;
! 14221: des_const_xmlParserCtxtPtr(n_ctx, (const xmlParserCtxtPtr)ctx, 0);
! 14222: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 1);
! 14223: xmlResetLastError();
! 14224: if (mem_base != xmlMemBlocks()) {
! 14225: printf("Leak of %d blocks found in xmlParserFindNodeInfo",
! 14226: xmlMemBlocks() - mem_base);
! 14227: test_ret++;
! 14228: printf(" %d", n_ctx);
! 14229: printf(" %d", n_node);
! 14230: printf("\n");
! 14231: }
! 14232: }
! 14233: }
! 14234: function_tests++;
! 14235:
! 14236: return(test_ret);
! 14237: }
! 14238:
! 14239:
! 14240: #define gen_nb_const_xmlParserNodeInfoSeqPtr 1
! 14241: static xmlParserNodeInfoSeqPtr gen_const_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 14242: return(NULL);
! 14243: }
! 14244: static void des_const_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, const xmlParserNodeInfoSeqPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 14245: }
! 14246:
! 14247: static int
! 14248: test_xmlParserFindNodeInfoIndex(void) {
! 14249: int test_ret = 0;
! 14250:
! 14251: int mem_base;
! 14252: unsigned long ret_val;
! 14253: xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */
! 14254: int n_seq;
! 14255: xmlNodePtr node; /* an XML node pointer */
! 14256: int n_node;
! 14257:
! 14258: for (n_seq = 0;n_seq < gen_nb_const_xmlParserNodeInfoSeqPtr;n_seq++) {
! 14259: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
! 14260: mem_base = xmlMemBlocks();
! 14261: seq = gen_const_xmlParserNodeInfoSeqPtr(n_seq, 0);
! 14262: node = gen_const_xmlNodePtr(n_node, 1);
! 14263:
! 14264: ret_val = xmlParserFindNodeInfoIndex((const xmlParserNodeInfoSeqPtr)seq, (const xmlNodePtr)node);
! 14265: desret_unsigned_long(ret_val);
! 14266: call_tests++;
! 14267: des_const_xmlParserNodeInfoSeqPtr(n_seq, (const xmlParserNodeInfoSeqPtr)seq, 0);
! 14268: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 1);
! 14269: xmlResetLastError();
! 14270: if (mem_base != xmlMemBlocks()) {
! 14271: printf("Leak of %d blocks found in xmlParserFindNodeInfoIndex",
! 14272: xmlMemBlocks() - mem_base);
! 14273: test_ret++;
! 14274: printf(" %d", n_seq);
! 14275: printf(" %d", n_node);
! 14276: printf("\n");
! 14277: }
! 14278: }
! 14279: }
! 14280: function_tests++;
! 14281:
! 14282: return(test_ret);
! 14283: }
! 14284:
! 14285:
! 14286: #define gen_nb_xmlParserInputPtr 1
! 14287: static xmlParserInputPtr gen_xmlParserInputPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 14288: return(NULL);
! 14289: }
! 14290: static void des_xmlParserInputPtr(int no ATTRIBUTE_UNUSED, xmlParserInputPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 14291: }
! 14292:
! 14293: static int
! 14294: test_xmlParserInputGrow(void) {
! 14295: int test_ret = 0;
! 14296:
! 14297: int mem_base;
! 14298: int ret_val;
! 14299: xmlParserInputPtr in; /* an XML parser input */
! 14300: int n_in;
! 14301: int len; /* an indicative size for the lookahead */
! 14302: int n_len;
! 14303:
! 14304: for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) {
! 14305: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 14306: mem_base = xmlMemBlocks();
! 14307: in = gen_xmlParserInputPtr(n_in, 0);
! 14308: len = gen_int(n_len, 1);
! 14309:
! 14310: ret_val = xmlParserInputGrow(in, len);
! 14311: desret_int(ret_val);
! 14312: call_tests++;
! 14313: des_xmlParserInputPtr(n_in, in, 0);
! 14314: des_int(n_len, len, 1);
! 14315: xmlResetLastError();
! 14316: if (mem_base != xmlMemBlocks()) {
! 14317: printf("Leak of %d blocks found in xmlParserInputGrow",
! 14318: xmlMemBlocks() - mem_base);
! 14319: test_ret++;
! 14320: printf(" %d", n_in);
! 14321: printf(" %d", n_len);
! 14322: printf("\n");
! 14323: }
! 14324: }
! 14325: }
! 14326: function_tests++;
! 14327:
! 14328: return(test_ret);
! 14329: }
! 14330:
! 14331:
! 14332: static int
! 14333: test_xmlParserInputRead(void) {
! 14334: int test_ret = 0;
! 14335:
! 14336: int mem_base;
! 14337: int ret_val;
! 14338: xmlParserInputPtr in; /* an XML parser input */
! 14339: int n_in;
! 14340: int len; /* an indicative size for the lookahead */
! 14341: int n_len;
! 14342:
! 14343: for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) {
! 14344: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 14345: mem_base = xmlMemBlocks();
! 14346: in = gen_xmlParserInputPtr(n_in, 0);
! 14347: len = gen_int(n_len, 1);
! 14348:
! 14349: ret_val = xmlParserInputRead(in, len);
! 14350: desret_int(ret_val);
! 14351: call_tests++;
! 14352: des_xmlParserInputPtr(n_in, in, 0);
! 14353: des_int(n_len, len, 1);
! 14354: xmlResetLastError();
! 14355: if (mem_base != xmlMemBlocks()) {
! 14356: printf("Leak of %d blocks found in xmlParserInputRead",
! 14357: xmlMemBlocks() - mem_base);
! 14358: test_ret++;
! 14359: printf(" %d", n_in);
! 14360: printf(" %d", n_len);
! 14361: printf("\n");
! 14362: }
! 14363: }
! 14364: }
! 14365: function_tests++;
! 14366:
! 14367: return(test_ret);
! 14368: }
! 14369:
! 14370:
! 14371: static int
! 14372: test_xmlPedanticParserDefault(void) {
! 14373: int test_ret = 0;
! 14374:
! 14375: int mem_base;
! 14376: int ret_val;
! 14377: int val; /* int 0 or 1 */
! 14378: int n_val;
! 14379:
! 14380: for (n_val = 0;n_val < gen_nb_int;n_val++) {
! 14381: mem_base = xmlMemBlocks();
! 14382: val = gen_int(n_val, 0);
! 14383:
! 14384: ret_val = xmlPedanticParserDefault(val);
! 14385: desret_int(ret_val);
! 14386: call_tests++;
! 14387: des_int(n_val, val, 0);
! 14388: xmlResetLastError();
! 14389: if (mem_base != xmlMemBlocks()) {
! 14390: printf("Leak of %d blocks found in xmlPedanticParserDefault",
! 14391: xmlMemBlocks() - mem_base);
! 14392: test_ret++;
! 14393: printf(" %d", n_val);
! 14394: printf("\n");
! 14395: }
! 14396: }
! 14397: function_tests++;
! 14398:
! 14399: return(test_ret);
! 14400: }
! 14401:
! 14402:
! 14403: static int
! 14404: test_xmlReadDoc(void) {
! 14405: int test_ret = 0;
! 14406:
! 14407: int mem_base;
! 14408: xmlDocPtr ret_val;
! 14409: xmlChar * cur; /* a pointer to a zero terminated string */
! 14410: int n_cur;
! 14411: const char * URL; /* the base URL to use for the document */
! 14412: int n_URL;
! 14413: char * encoding; /* the document encoding, or NULL */
! 14414: int n_encoding;
! 14415: int options; /* a combination of xmlParserOption */
! 14416: int n_options;
! 14417:
! 14418: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
! 14419: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 14420: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 14421: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
! 14422: mem_base = xmlMemBlocks();
! 14423: cur = gen_const_xmlChar_ptr(n_cur, 0);
! 14424: URL = gen_filepath(n_URL, 1);
! 14425: encoding = gen_const_char_ptr(n_encoding, 2);
! 14426: options = gen_parseroptions(n_options, 3);
! 14427:
! 14428: ret_val = xmlReadDoc((const xmlChar *)cur, URL, (const char *)encoding, options);
! 14429: desret_xmlDocPtr(ret_val);
! 14430: call_tests++;
! 14431: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
! 14432: des_filepath(n_URL, URL, 1);
! 14433: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
! 14434: des_parseroptions(n_options, options, 3);
! 14435: xmlResetLastError();
! 14436: if (mem_base != xmlMemBlocks()) {
! 14437: printf("Leak of %d blocks found in xmlReadDoc",
! 14438: xmlMemBlocks() - mem_base);
! 14439: test_ret++;
! 14440: printf(" %d", n_cur);
! 14441: printf(" %d", n_URL);
! 14442: printf(" %d", n_encoding);
! 14443: printf(" %d", n_options);
! 14444: printf("\n");
! 14445: }
! 14446: }
! 14447: }
! 14448: }
! 14449: }
! 14450: function_tests++;
! 14451:
! 14452: return(test_ret);
! 14453: }
! 14454:
! 14455:
! 14456: static int
! 14457: test_xmlReadFile(void) {
! 14458: int test_ret = 0;
! 14459:
! 14460: int mem_base;
! 14461: xmlDocPtr ret_val;
! 14462: const char * filename; /* a file or URL */
! 14463: int n_filename;
! 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_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 14470: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 14471: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
! 14472: mem_base = xmlMemBlocks();
! 14473: filename = gen_filepath(n_filename, 0);
! 14474: encoding = gen_const_char_ptr(n_encoding, 1);
! 14475: options = gen_parseroptions(n_options, 2);
! 14476:
! 14477: ret_val = xmlReadFile(filename, (const char *)encoding, options);
! 14478: desret_xmlDocPtr(ret_val);
! 14479: call_tests++;
! 14480: des_filepath(n_filename, filename, 0);
! 14481: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
! 14482: des_parseroptions(n_options, options, 2);
! 14483: xmlResetLastError();
! 14484: if (mem_base != xmlMemBlocks()) {
! 14485: printf("Leak of %d blocks found in xmlReadFile",
! 14486: xmlMemBlocks() - mem_base);
! 14487: test_ret++;
! 14488: printf(" %d", n_filename);
! 14489: printf(" %d", n_encoding);
! 14490: printf(" %d", n_options);
! 14491: printf("\n");
! 14492: }
! 14493: }
! 14494: }
! 14495: }
! 14496: function_tests++;
! 14497:
! 14498: return(test_ret);
! 14499: }
! 14500:
! 14501:
! 14502: static int
! 14503: test_xmlReadMemory(void) {
! 14504: int test_ret = 0;
! 14505:
! 14506: int mem_base;
! 14507: xmlDocPtr ret_val;
! 14508: char * buffer; /* a pointer to a char array */
! 14509: int n_buffer;
! 14510: int size; /* the size of the array */
! 14511: int n_size;
! 14512: const char * URL; /* the base URL to use for the document */
! 14513: int n_URL;
! 14514: char * encoding; /* the document encoding, or NULL */
! 14515: int n_encoding;
! 14516: int options; /* a combination of xmlParserOption */
! 14517: int n_options;
! 14518:
! 14519: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
! 14520: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 14521: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 14522: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 14523: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
! 14524: mem_base = xmlMemBlocks();
! 14525: buffer = gen_const_char_ptr(n_buffer, 0);
! 14526: size = gen_int(n_size, 1);
! 14527: URL = gen_filepath(n_URL, 2);
! 14528: encoding = gen_const_char_ptr(n_encoding, 3);
! 14529: options = gen_parseroptions(n_options, 4);
! 14530:
! 14531: ret_val = xmlReadMemory((const char *)buffer, size, URL, (const char *)encoding, options);
! 14532: desret_xmlDocPtr(ret_val);
! 14533: call_tests++;
! 14534: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
! 14535: des_int(n_size, size, 1);
! 14536: des_filepath(n_URL, URL, 2);
! 14537: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
! 14538: des_parseroptions(n_options, options, 4);
! 14539: xmlResetLastError();
! 14540: if (mem_base != xmlMemBlocks()) {
! 14541: printf("Leak of %d blocks found in xmlReadMemory",
! 14542: xmlMemBlocks() - mem_base);
! 14543: test_ret++;
! 14544: printf(" %d", n_buffer);
! 14545: printf(" %d", n_size);
! 14546: printf(" %d", n_URL);
! 14547: printf(" %d", n_encoding);
! 14548: printf(" %d", n_options);
! 14549: printf("\n");
! 14550: }
! 14551: }
! 14552: }
! 14553: }
! 14554: }
! 14555: }
! 14556: function_tests++;
! 14557:
! 14558: return(test_ret);
! 14559: }
! 14560:
! 14561:
! 14562: static int
! 14563: test_xmlRecoverDoc(void) {
! 14564: int test_ret = 0;
! 14565:
! 14566: #if defined(LIBXML_SAX1_ENABLED)
! 14567: #ifdef LIBXML_SAX1_ENABLED
! 14568: int mem_base;
! 14569: xmlDocPtr ret_val;
! 14570: xmlChar * cur; /* a pointer to an array of xmlChar */
! 14571: int n_cur;
! 14572:
! 14573: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
! 14574: mem_base = xmlMemBlocks();
! 14575: cur = gen_const_xmlChar_ptr(n_cur, 0);
! 14576:
! 14577: ret_val = xmlRecoverDoc((const xmlChar *)cur);
! 14578: desret_xmlDocPtr(ret_val);
! 14579: call_tests++;
! 14580: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
! 14581: xmlResetLastError();
! 14582: if (mem_base != xmlMemBlocks()) {
! 14583: printf("Leak of %d blocks found in xmlRecoverDoc",
! 14584: xmlMemBlocks() - mem_base);
! 14585: test_ret++;
! 14586: printf(" %d", n_cur);
! 14587: printf("\n");
! 14588: }
! 14589: }
! 14590: function_tests++;
! 14591: #endif
! 14592: #endif
! 14593:
! 14594: return(test_ret);
! 14595: }
! 14596:
! 14597:
! 14598: static int
! 14599: test_xmlRecoverFile(void) {
! 14600: int test_ret = 0;
! 14601:
! 14602: #if defined(LIBXML_SAX1_ENABLED)
! 14603: #ifdef LIBXML_SAX1_ENABLED
! 14604: int mem_base;
! 14605: xmlDocPtr ret_val;
! 14606: const char * filename; /* the filename */
! 14607: int n_filename;
! 14608:
! 14609: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 14610: mem_base = xmlMemBlocks();
! 14611: filename = gen_filepath(n_filename, 0);
! 14612:
! 14613: ret_val = xmlRecoverFile(filename);
! 14614: desret_xmlDocPtr(ret_val);
! 14615: call_tests++;
! 14616: des_filepath(n_filename, filename, 0);
! 14617: xmlResetLastError();
! 14618: if (mem_base != xmlMemBlocks()) {
! 14619: printf("Leak of %d blocks found in xmlRecoverFile",
! 14620: xmlMemBlocks() - mem_base);
! 14621: test_ret++;
! 14622: printf(" %d", n_filename);
! 14623: printf("\n");
! 14624: }
! 14625: }
! 14626: function_tests++;
! 14627: #endif
! 14628: #endif
! 14629:
! 14630: return(test_ret);
! 14631: }
! 14632:
! 14633:
! 14634: static int
! 14635: test_xmlRecoverMemory(void) {
! 14636: int test_ret = 0;
! 14637:
! 14638: #if defined(LIBXML_SAX1_ENABLED)
! 14639: #ifdef LIBXML_SAX1_ENABLED
! 14640: int mem_base;
! 14641: xmlDocPtr ret_val;
! 14642: char * buffer; /* an pointer to a char array */
! 14643: int n_buffer;
! 14644: int size; /* the size of the array */
! 14645: int n_size;
! 14646:
! 14647: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
! 14648: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 14649: mem_base = xmlMemBlocks();
! 14650: buffer = gen_const_char_ptr(n_buffer, 0);
! 14651: size = gen_int(n_size, 1);
! 14652:
! 14653: ret_val = xmlRecoverMemory((const char *)buffer, size);
! 14654: desret_xmlDocPtr(ret_val);
! 14655: call_tests++;
! 14656: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
! 14657: des_int(n_size, size, 1);
! 14658: xmlResetLastError();
! 14659: if (mem_base != xmlMemBlocks()) {
! 14660: printf("Leak of %d blocks found in xmlRecoverMemory",
! 14661: xmlMemBlocks() - mem_base);
! 14662: test_ret++;
! 14663: printf(" %d", n_buffer);
! 14664: printf(" %d", n_size);
! 14665: printf("\n");
! 14666: }
! 14667: }
! 14668: }
! 14669: function_tests++;
! 14670: #endif
! 14671: #endif
! 14672:
! 14673: return(test_ret);
! 14674: }
! 14675:
! 14676:
! 14677: static int
! 14678: test_xmlSAXParseDTD(void) {
! 14679: int test_ret = 0;
! 14680:
! 14681: #if defined(LIBXML_VALID_ENABLED)
! 14682: #ifdef LIBXML_SAX1_ENABLED
! 14683: int mem_base;
! 14684: xmlDtdPtr ret_val;
! 14685: xmlSAXHandlerPtr sax; /* the SAX handler block */
! 14686: int n_sax;
! 14687: xmlChar * ExternalID; /* a NAME* containing the External ID of the DTD */
! 14688: int n_ExternalID;
! 14689: xmlChar * SystemID; /* a NAME* containing the URL to the DTD */
! 14690: int n_SystemID;
! 14691:
! 14692: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
! 14693: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
! 14694: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
! 14695: mem_base = xmlMemBlocks();
! 14696: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
! 14697: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 1);
! 14698: SystemID = gen_const_xmlChar_ptr(n_SystemID, 2);
! 14699:
! 14700: ret_val = xmlSAXParseDTD(sax, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
! 14701: desret_xmlDtdPtr(ret_val);
! 14702: call_tests++;
! 14703: des_xmlSAXHandlerPtr(n_sax, sax, 0);
! 14704: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 1);
! 14705: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 2);
! 14706: xmlResetLastError();
! 14707: if (mem_base != xmlMemBlocks()) {
! 14708: printf("Leak of %d blocks found in xmlSAXParseDTD",
! 14709: xmlMemBlocks() - mem_base);
! 14710: test_ret++;
! 14711: printf(" %d", n_sax);
! 14712: printf(" %d", n_ExternalID);
! 14713: printf(" %d", n_SystemID);
! 14714: printf("\n");
! 14715: }
! 14716: }
! 14717: }
! 14718: }
! 14719: function_tests++;
! 14720: #endif
! 14721: #endif
! 14722:
! 14723: return(test_ret);
! 14724: }
! 14725:
! 14726:
! 14727: static int
! 14728: test_xmlSAXParseDoc(void) {
! 14729: int test_ret = 0;
! 14730:
! 14731: #if defined(LIBXML_SAX1_ENABLED)
! 14732: #ifdef LIBXML_SAX1_ENABLED
! 14733: int mem_base;
! 14734: xmlDocPtr ret_val;
! 14735: xmlSAXHandlerPtr sax; /* the SAX handler block */
! 14736: int n_sax;
! 14737: xmlChar * cur; /* a pointer to an array of xmlChar */
! 14738: int n_cur;
! 14739: int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
! 14740: int n_recovery;
! 14741:
! 14742: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
! 14743: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
! 14744: for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
! 14745: mem_base = xmlMemBlocks();
! 14746: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
! 14747: cur = gen_const_xmlChar_ptr(n_cur, 1);
! 14748: recovery = gen_int(n_recovery, 2);
! 14749:
! 14750: ret_val = xmlSAXParseDoc(sax, (const xmlChar *)cur, recovery);
! 14751: desret_xmlDocPtr(ret_val);
! 14752: call_tests++;
! 14753: des_xmlSAXHandlerPtr(n_sax, sax, 0);
! 14754: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
! 14755: des_int(n_recovery, recovery, 2);
! 14756: xmlResetLastError();
! 14757: if (mem_base != xmlMemBlocks()) {
! 14758: printf("Leak of %d blocks found in xmlSAXParseDoc",
! 14759: xmlMemBlocks() - mem_base);
! 14760: test_ret++;
! 14761: printf(" %d", n_sax);
! 14762: printf(" %d", n_cur);
! 14763: printf(" %d", n_recovery);
! 14764: printf("\n");
! 14765: }
! 14766: }
! 14767: }
! 14768: }
! 14769: function_tests++;
! 14770: #endif
! 14771: #endif
! 14772:
! 14773: return(test_ret);
! 14774: }
! 14775:
! 14776:
! 14777: static int
! 14778: test_xmlSAXParseEntity(void) {
! 14779: int test_ret = 0;
! 14780:
! 14781: #if defined(LIBXML_SAX1_ENABLED)
! 14782: #ifdef LIBXML_SAX1_ENABLED
! 14783: int mem_base;
! 14784: xmlDocPtr ret_val;
! 14785: xmlSAXHandlerPtr sax; /* the SAX handler block */
! 14786: int n_sax;
! 14787: const char * filename; /* the filename */
! 14788: int n_filename;
! 14789:
! 14790: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
! 14791: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 14792: mem_base = xmlMemBlocks();
! 14793: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
! 14794: filename = gen_filepath(n_filename, 1);
! 14795:
! 14796: ret_val = xmlSAXParseEntity(sax, filename);
! 14797: desret_xmlDocPtr(ret_val);
! 14798: call_tests++;
! 14799: des_xmlSAXHandlerPtr(n_sax, sax, 0);
! 14800: des_filepath(n_filename, filename, 1);
! 14801: xmlResetLastError();
! 14802: if (mem_base != xmlMemBlocks()) {
! 14803: printf("Leak of %d blocks found in xmlSAXParseEntity",
! 14804: xmlMemBlocks() - mem_base);
! 14805: test_ret++;
! 14806: printf(" %d", n_sax);
! 14807: printf(" %d", n_filename);
! 14808: printf("\n");
! 14809: }
! 14810: }
! 14811: }
! 14812: function_tests++;
! 14813: #endif
! 14814: #endif
! 14815:
! 14816: return(test_ret);
! 14817: }
! 14818:
! 14819:
! 14820: static int
! 14821: test_xmlSAXParseFile(void) {
! 14822: int test_ret = 0;
! 14823:
! 14824: #if defined(LIBXML_SAX1_ENABLED)
! 14825: #ifdef LIBXML_SAX1_ENABLED
! 14826: int mem_base;
! 14827: xmlDocPtr ret_val;
! 14828: xmlSAXHandlerPtr sax; /* the SAX handler block */
! 14829: int n_sax;
! 14830: const char * filename; /* the filename */
! 14831: int n_filename;
! 14832: int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
! 14833: int n_recovery;
! 14834:
! 14835: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
! 14836: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 14837: for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
! 14838: mem_base = xmlMemBlocks();
! 14839: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
! 14840: filename = gen_filepath(n_filename, 1);
! 14841: recovery = gen_int(n_recovery, 2);
! 14842:
! 14843: ret_val = xmlSAXParseFile(sax, filename, recovery);
! 14844: desret_xmlDocPtr(ret_val);
! 14845: call_tests++;
! 14846: des_xmlSAXHandlerPtr(n_sax, sax, 0);
! 14847: des_filepath(n_filename, filename, 1);
! 14848: des_int(n_recovery, recovery, 2);
! 14849: xmlResetLastError();
! 14850: if (mem_base != xmlMemBlocks()) {
! 14851: printf("Leak of %d blocks found in xmlSAXParseFile",
! 14852: xmlMemBlocks() - mem_base);
! 14853: test_ret++;
! 14854: printf(" %d", n_sax);
! 14855: printf(" %d", n_filename);
! 14856: printf(" %d", n_recovery);
! 14857: printf("\n");
! 14858: }
! 14859: }
! 14860: }
! 14861: }
! 14862: function_tests++;
! 14863: #endif
! 14864: #endif
! 14865:
! 14866: return(test_ret);
! 14867: }
! 14868:
! 14869:
! 14870: static int
! 14871: test_xmlSAXParseFileWithData(void) {
! 14872: int test_ret = 0;
! 14873:
! 14874: #if defined(LIBXML_SAX1_ENABLED)
! 14875: #ifdef LIBXML_SAX1_ENABLED
! 14876: int mem_base;
! 14877: xmlDocPtr ret_val;
! 14878: xmlSAXHandlerPtr sax; /* the SAX handler block */
! 14879: int n_sax;
! 14880: const char * filename; /* the filename */
! 14881: int n_filename;
! 14882: int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
! 14883: int n_recovery;
! 14884: void * data; /* the userdata */
! 14885: int n_data;
! 14886:
! 14887: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
! 14888: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 14889: for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
! 14890: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
! 14891: mem_base = xmlMemBlocks();
! 14892: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
! 14893: filename = gen_filepath(n_filename, 1);
! 14894: recovery = gen_int(n_recovery, 2);
! 14895: data = gen_userdata(n_data, 3);
! 14896:
! 14897: ret_val = xmlSAXParseFileWithData(sax, filename, recovery, data);
! 14898: desret_xmlDocPtr(ret_val);
! 14899: call_tests++;
! 14900: des_xmlSAXHandlerPtr(n_sax, sax, 0);
! 14901: des_filepath(n_filename, filename, 1);
! 14902: des_int(n_recovery, recovery, 2);
! 14903: des_userdata(n_data, data, 3);
! 14904: xmlResetLastError();
! 14905: if (mem_base != xmlMemBlocks()) {
! 14906: printf("Leak of %d blocks found in xmlSAXParseFileWithData",
! 14907: xmlMemBlocks() - mem_base);
! 14908: test_ret++;
! 14909: printf(" %d", n_sax);
! 14910: printf(" %d", n_filename);
! 14911: printf(" %d", n_recovery);
! 14912: printf(" %d", n_data);
! 14913: printf("\n");
! 14914: }
! 14915: }
! 14916: }
! 14917: }
! 14918: }
! 14919: function_tests++;
! 14920: #endif
! 14921: #endif
! 14922:
! 14923: return(test_ret);
! 14924: }
! 14925:
! 14926:
! 14927: static int
! 14928: test_xmlSAXParseMemory(void) {
! 14929: int test_ret = 0;
! 14930:
! 14931: #if defined(LIBXML_SAX1_ENABLED)
! 14932: #ifdef LIBXML_SAX1_ENABLED
! 14933: int mem_base;
! 14934: xmlDocPtr ret_val;
! 14935: xmlSAXHandlerPtr sax; /* the SAX handler block */
! 14936: int n_sax;
! 14937: char * buffer; /* an pointer to a char array */
! 14938: int n_buffer;
! 14939: int size; /* the size of the array */
! 14940: int n_size;
! 14941: int recovery; /* work in recovery mode, i.e. tries to read not Well Formed documents */
! 14942: int n_recovery;
! 14943:
! 14944: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
! 14945: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
! 14946: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 14947: for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
! 14948: mem_base = xmlMemBlocks();
! 14949: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
! 14950: buffer = gen_const_char_ptr(n_buffer, 1);
! 14951: size = gen_int(n_size, 2);
! 14952: recovery = gen_int(n_recovery, 3);
! 14953:
! 14954: ret_val = xmlSAXParseMemory(sax, (const char *)buffer, size, recovery);
! 14955: desret_xmlDocPtr(ret_val);
! 14956: call_tests++;
! 14957: des_xmlSAXHandlerPtr(n_sax, sax, 0);
! 14958: des_const_char_ptr(n_buffer, (const char *)buffer, 1);
! 14959: des_int(n_size, size, 2);
! 14960: des_int(n_recovery, recovery, 3);
! 14961: xmlResetLastError();
! 14962: if (mem_base != xmlMemBlocks()) {
! 14963: printf("Leak of %d blocks found in xmlSAXParseMemory",
! 14964: xmlMemBlocks() - mem_base);
! 14965: test_ret++;
! 14966: printf(" %d", n_sax);
! 14967: printf(" %d", n_buffer);
! 14968: printf(" %d", n_size);
! 14969: printf(" %d", n_recovery);
! 14970: printf("\n");
! 14971: }
! 14972: }
! 14973: }
! 14974: }
! 14975: }
! 14976: function_tests++;
! 14977: #endif
! 14978: #endif
! 14979:
! 14980: return(test_ret);
! 14981: }
! 14982:
! 14983:
! 14984: static int
! 14985: test_xmlSAXParseMemoryWithData(void) {
! 14986: int test_ret = 0;
! 14987:
! 14988: #if defined(LIBXML_SAX1_ENABLED)
! 14989: #ifdef LIBXML_SAX1_ENABLED
! 14990: int mem_base;
! 14991: xmlDocPtr ret_val;
! 14992: xmlSAXHandlerPtr sax; /* the SAX handler block */
! 14993: int n_sax;
! 14994: char * buffer; /* an pointer to a char array */
! 14995: int n_buffer;
! 14996: int size; /* the size of the array */
! 14997: int n_size;
! 14998: int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
! 14999: int n_recovery;
! 15000: void * data; /* the userdata */
! 15001: int n_data;
! 15002:
! 15003: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
! 15004: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
! 15005: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 15006: for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
! 15007: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
! 15008: mem_base = xmlMemBlocks();
! 15009: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
! 15010: buffer = gen_const_char_ptr(n_buffer, 1);
! 15011: size = gen_int(n_size, 2);
! 15012: recovery = gen_int(n_recovery, 3);
! 15013: data = gen_userdata(n_data, 4);
! 15014:
! 15015: ret_val = xmlSAXParseMemoryWithData(sax, (const char *)buffer, size, recovery, data);
! 15016: desret_xmlDocPtr(ret_val);
! 15017: call_tests++;
! 15018: des_xmlSAXHandlerPtr(n_sax, sax, 0);
! 15019: des_const_char_ptr(n_buffer, (const char *)buffer, 1);
! 15020: des_int(n_size, size, 2);
! 15021: des_int(n_recovery, recovery, 3);
! 15022: des_userdata(n_data, data, 4);
! 15023: xmlResetLastError();
! 15024: if (mem_base != xmlMemBlocks()) {
! 15025: printf("Leak of %d blocks found in xmlSAXParseMemoryWithData",
! 15026: xmlMemBlocks() - mem_base);
! 15027: test_ret++;
! 15028: printf(" %d", n_sax);
! 15029: printf(" %d", n_buffer);
! 15030: printf(" %d", n_size);
! 15031: printf(" %d", n_recovery);
! 15032: printf(" %d", n_data);
! 15033: printf("\n");
! 15034: }
! 15035: }
! 15036: }
! 15037: }
! 15038: }
! 15039: }
! 15040: function_tests++;
! 15041: #endif
! 15042: #endif
! 15043:
! 15044: return(test_ret);
! 15045: }
! 15046:
! 15047:
! 15048: static int
! 15049: test_xmlSAXUserParseFile(void) {
! 15050: int test_ret = 0;
! 15051:
! 15052: #if defined(LIBXML_SAX1_ENABLED)
! 15053: #ifdef LIBXML_SAX1_ENABLED
! 15054: int mem_base;
! 15055: int ret_val;
! 15056: xmlSAXHandlerPtr sax; /* a SAX handler */
! 15057: int n_sax;
! 15058: void * user_data; /* The user data returned on SAX callbacks */
! 15059: int n_user_data;
! 15060: const char * filename; /* a file name */
! 15061: int n_filename;
! 15062:
! 15063: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
! 15064: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
! 15065: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 15066: mem_base = xmlMemBlocks();
! 15067: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
! 15068: user_data = gen_userdata(n_user_data, 1);
! 15069: filename = gen_filepath(n_filename, 2);
! 15070:
! 15071: #ifdef LIBXML_SAX1_ENABLED
! 15072: if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
! 15073: #endif
! 15074:
! 15075:
! 15076: ret_val = xmlSAXUserParseFile(sax, user_data, filename);
! 15077: desret_int(ret_val);
! 15078: call_tests++;
! 15079: des_xmlSAXHandlerPtr(n_sax, sax, 0);
! 15080: des_userdata(n_user_data, user_data, 1);
! 15081: des_filepath(n_filename, filename, 2);
! 15082: xmlResetLastError();
! 15083: if (mem_base != xmlMemBlocks()) {
! 15084: printf("Leak of %d blocks found in xmlSAXUserParseFile",
! 15085: xmlMemBlocks() - mem_base);
! 15086: test_ret++;
! 15087: printf(" %d", n_sax);
! 15088: printf(" %d", n_user_data);
! 15089: printf(" %d", n_filename);
! 15090: printf("\n");
! 15091: }
! 15092: }
! 15093: }
! 15094: }
! 15095: function_tests++;
! 15096: #endif
! 15097: #endif
! 15098:
! 15099: return(test_ret);
! 15100: }
! 15101:
! 15102:
! 15103: static int
! 15104: test_xmlSAXUserParseMemory(void) {
! 15105: int test_ret = 0;
! 15106:
! 15107: #if defined(LIBXML_SAX1_ENABLED)
! 15108: #ifdef LIBXML_SAX1_ENABLED
! 15109: int mem_base;
! 15110: int ret_val;
! 15111: xmlSAXHandlerPtr sax; /* a SAX handler */
! 15112: int n_sax;
! 15113: void * user_data; /* The user data returned on SAX callbacks */
! 15114: int n_user_data;
! 15115: char * buffer; /* an in-memory XML document input */
! 15116: int n_buffer;
! 15117: int size; /* the length of the XML document in bytes */
! 15118: int n_size;
! 15119:
! 15120: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
! 15121: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
! 15122: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
! 15123: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 15124: mem_base = xmlMemBlocks();
! 15125: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
! 15126: user_data = gen_userdata(n_user_data, 1);
! 15127: buffer = gen_const_char_ptr(n_buffer, 2);
! 15128: size = gen_int(n_size, 3);
! 15129:
! 15130: #ifdef LIBXML_SAX1_ENABLED
! 15131: if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
! 15132: #endif
! 15133:
! 15134:
! 15135: ret_val = xmlSAXUserParseMemory(sax, user_data, (const char *)buffer, size);
! 15136: desret_int(ret_val);
! 15137: call_tests++;
! 15138: des_xmlSAXHandlerPtr(n_sax, sax, 0);
! 15139: des_userdata(n_user_data, user_data, 1);
! 15140: des_const_char_ptr(n_buffer, (const char *)buffer, 2);
! 15141: des_int(n_size, size, 3);
! 15142: xmlResetLastError();
! 15143: if (mem_base != xmlMemBlocks()) {
! 15144: printf("Leak of %d blocks found in xmlSAXUserParseMemory",
! 15145: xmlMemBlocks() - mem_base);
! 15146: test_ret++;
! 15147: printf(" %d", n_sax);
! 15148: printf(" %d", n_user_data);
! 15149: printf(" %d", n_buffer);
! 15150: printf(" %d", n_size);
! 15151: printf("\n");
! 15152: }
! 15153: }
! 15154: }
! 15155: }
! 15156: }
! 15157: function_tests++;
! 15158: #endif
! 15159: #endif
! 15160:
! 15161: return(test_ret);
! 15162: }
! 15163:
! 15164:
! 15165: static int
! 15166: test_xmlSetExternalEntityLoader(void) {
! 15167: int test_ret = 0;
! 15168:
! 15169:
! 15170: /* missing type support */
! 15171: return(test_ret);
! 15172: }
! 15173:
! 15174:
! 15175: static int
! 15176: test_xmlSetFeature(void) {
! 15177: int test_ret = 0;
! 15178:
! 15179: #if defined(LIBXML_LEGACY_ENABLED)
! 15180: #ifdef LIBXML_LEGACY_ENABLED
! 15181: int mem_base;
! 15182: int ret_val;
! 15183: xmlParserCtxtPtr ctxt; /* an XML/HTML parser context */
! 15184: int n_ctxt;
! 15185: char * name; /* the feature name */
! 15186: int n_name;
! 15187: void * value; /* pointer to the location of the new value */
! 15188: int n_value;
! 15189:
! 15190: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 15191: for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
! 15192: for (n_value = 0;n_value < gen_nb_void_ptr;n_value++) {
! 15193: mem_base = xmlMemBlocks();
! 15194: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 15195: name = gen_const_char_ptr(n_name, 1);
! 15196: value = gen_void_ptr(n_value, 2);
! 15197:
! 15198: ret_val = xmlSetFeature(ctxt, (const char *)name, value);
! 15199: desret_int(ret_val);
! 15200: call_tests++;
! 15201: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 15202: des_const_char_ptr(n_name, (const char *)name, 1);
! 15203: des_void_ptr(n_value, value, 2);
! 15204: xmlResetLastError();
! 15205: if (mem_base != xmlMemBlocks()) {
! 15206: printf("Leak of %d blocks found in xmlSetFeature",
! 15207: xmlMemBlocks() - mem_base);
! 15208: test_ret++;
! 15209: printf(" %d", n_ctxt);
! 15210: printf(" %d", n_name);
! 15211: printf(" %d", n_value);
! 15212: printf("\n");
! 15213: }
! 15214: }
! 15215: }
! 15216: }
! 15217: function_tests++;
! 15218: #endif
! 15219: #endif
! 15220:
! 15221: return(test_ret);
! 15222: }
! 15223:
! 15224:
! 15225: static int
! 15226: test_xmlSetupParserForBuffer(void) {
! 15227: int test_ret = 0;
! 15228:
! 15229: #if defined(LIBXML_SAX1_ENABLED)
! 15230: #ifdef LIBXML_SAX1_ENABLED
! 15231: int mem_base;
! 15232: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 15233: int n_ctxt;
! 15234: xmlChar * buffer; /* a xmlChar * buffer */
! 15235: int n_buffer;
! 15236: const char * filename; /* a file name */
! 15237: int n_filename;
! 15238:
! 15239: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 15240: for (n_buffer = 0;n_buffer < gen_nb_const_xmlChar_ptr;n_buffer++) {
! 15241: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 15242: mem_base = xmlMemBlocks();
! 15243: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 15244: buffer = gen_const_xmlChar_ptr(n_buffer, 1);
! 15245: filename = gen_filepath(n_filename, 2);
! 15246:
! 15247: xmlSetupParserForBuffer(ctxt, (const xmlChar *)buffer, filename);
! 15248: call_tests++;
! 15249: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 15250: des_const_xmlChar_ptr(n_buffer, (const xmlChar *)buffer, 1);
! 15251: des_filepath(n_filename, filename, 2);
! 15252: xmlResetLastError();
! 15253: if (mem_base != xmlMemBlocks()) {
! 15254: printf("Leak of %d blocks found in xmlSetupParserForBuffer",
! 15255: xmlMemBlocks() - mem_base);
! 15256: test_ret++;
! 15257: printf(" %d", n_ctxt);
! 15258: printf(" %d", n_buffer);
! 15259: printf(" %d", n_filename);
! 15260: printf("\n");
! 15261: }
! 15262: }
! 15263: }
! 15264: }
! 15265: function_tests++;
! 15266: #endif
! 15267: #endif
! 15268:
! 15269: return(test_ret);
! 15270: }
! 15271:
! 15272:
! 15273: static int
! 15274: test_xmlStopParser(void) {
! 15275: int test_ret = 0;
! 15276:
! 15277: #ifdef LIBXML_PUSH_ENABLED
! 15278: int mem_base;
! 15279: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 15280: int n_ctxt;
! 15281:
! 15282: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 15283: mem_base = xmlMemBlocks();
! 15284: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 15285:
! 15286: xmlStopParser(ctxt);
! 15287: call_tests++;
! 15288: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 15289: xmlResetLastError();
! 15290: if (mem_base != xmlMemBlocks()) {
! 15291: printf("Leak of %d blocks found in xmlStopParser",
! 15292: xmlMemBlocks() - mem_base);
! 15293: test_ret++;
! 15294: printf(" %d", n_ctxt);
! 15295: printf("\n");
! 15296: }
! 15297: }
! 15298: function_tests++;
! 15299: #endif
! 15300:
! 15301: return(test_ret);
! 15302: }
! 15303:
! 15304:
! 15305: static int
! 15306: test_xmlSubstituteEntitiesDefault(void) {
! 15307: int test_ret = 0;
! 15308:
! 15309: int mem_base;
! 15310: int ret_val;
! 15311: int val; /* int 0 or 1 */
! 15312: int n_val;
! 15313:
! 15314: for (n_val = 0;n_val < gen_nb_int;n_val++) {
! 15315: mem_base = xmlMemBlocks();
! 15316: val = gen_int(n_val, 0);
! 15317:
! 15318: ret_val = xmlSubstituteEntitiesDefault(val);
! 15319: desret_int(ret_val);
! 15320: call_tests++;
! 15321: des_int(n_val, val, 0);
! 15322: xmlResetLastError();
! 15323: if (mem_base != xmlMemBlocks()) {
! 15324: printf("Leak of %d blocks found in xmlSubstituteEntitiesDefault",
! 15325: xmlMemBlocks() - mem_base);
! 15326: test_ret++;
! 15327: printf(" %d", n_val);
! 15328: printf("\n");
! 15329: }
! 15330: }
! 15331: function_tests++;
! 15332:
! 15333: return(test_ret);
! 15334: }
! 15335:
! 15336: static int
! 15337: test_parser(void) {
! 15338: int test_ret = 0;
! 15339:
! 15340: if (quiet == 0) printf("Testing parser : 61 of 70 functions ...\n");
! 15341: test_ret += test_xmlByteConsumed();
! 15342: test_ret += test_xmlClearNodeInfoSeq();
! 15343: test_ret += test_xmlClearParserCtxt();
! 15344: test_ret += test_xmlCreateDocParserCtxt();
! 15345: test_ret += test_xmlCreatePushParserCtxt();
! 15346: test_ret += test_xmlCtxtReadDoc();
! 15347: test_ret += test_xmlCtxtReadFile();
! 15348: test_ret += test_xmlCtxtReadMemory();
! 15349: test_ret += test_xmlCtxtReset();
! 15350: test_ret += test_xmlCtxtResetPush();
! 15351: test_ret += test_xmlCtxtUseOptions();
! 15352: test_ret += test_xmlGetExternalEntityLoader();
! 15353: test_ret += test_xmlGetFeature();
! 15354: test_ret += test_xmlGetFeaturesList();
! 15355: test_ret += test_xmlHasFeature();
! 15356: test_ret += test_xmlIOParseDTD();
! 15357: test_ret += test_xmlInitNodeInfoSeq();
! 15358: test_ret += test_xmlInitParser();
! 15359: test_ret += test_xmlInitParserCtxt();
! 15360: test_ret += test_xmlKeepBlanksDefault();
! 15361: test_ret += test_xmlLineNumbersDefault();
! 15362: test_ret += test_xmlLoadExternalEntity();
! 15363: test_ret += test_xmlNewIOInputStream();
! 15364: test_ret += test_xmlNewParserCtxt();
! 15365: test_ret += test_xmlParseBalancedChunkMemory();
! 15366: test_ret += test_xmlParseBalancedChunkMemoryRecover();
! 15367: test_ret += test_xmlParseChunk();
! 15368: test_ret += test_xmlParseCtxtExternalEntity();
! 15369: test_ret += test_xmlParseDTD();
! 15370: test_ret += test_xmlParseDoc();
! 15371: test_ret += test_xmlParseDocument();
! 15372: test_ret += test_xmlParseEntity();
! 15373: test_ret += test_xmlParseExtParsedEnt();
! 15374: test_ret += test_xmlParseExternalEntity();
! 15375: test_ret += test_xmlParseFile();
! 15376: test_ret += test_xmlParseInNodeContext();
! 15377: test_ret += test_xmlParseMemory();
! 15378: test_ret += test_xmlParserAddNodeInfo();
! 15379: test_ret += test_xmlParserFindNodeInfo();
! 15380: test_ret += test_xmlParserFindNodeInfoIndex();
! 15381: test_ret += test_xmlParserInputGrow();
! 15382: test_ret += test_xmlParserInputRead();
! 15383: test_ret += test_xmlPedanticParserDefault();
! 15384: test_ret += test_xmlReadDoc();
! 15385: test_ret += test_xmlReadFile();
! 15386: test_ret += test_xmlReadMemory();
! 15387: test_ret += test_xmlRecoverDoc();
! 15388: test_ret += test_xmlRecoverFile();
! 15389: test_ret += test_xmlRecoverMemory();
! 15390: test_ret += test_xmlSAXParseDTD();
! 15391: test_ret += test_xmlSAXParseDoc();
! 15392: test_ret += test_xmlSAXParseEntity();
! 15393: test_ret += test_xmlSAXParseFile();
! 15394: test_ret += test_xmlSAXParseFileWithData();
! 15395: test_ret += test_xmlSAXParseMemory();
! 15396: test_ret += test_xmlSAXParseMemoryWithData();
! 15397: test_ret += test_xmlSAXUserParseFile();
! 15398: test_ret += test_xmlSAXUserParseMemory();
! 15399: test_ret += test_xmlSetExternalEntityLoader();
! 15400: test_ret += test_xmlSetFeature();
! 15401: test_ret += test_xmlSetupParserForBuffer();
! 15402: test_ret += test_xmlStopParser();
! 15403: test_ret += test_xmlSubstituteEntitiesDefault();
! 15404:
! 15405: if (test_ret != 0)
! 15406: printf("Module parser: %d errors\n", test_ret);
! 15407: return(test_ret);
! 15408: }
! 15409:
! 15410: static int
! 15411: test_htmlCreateFileParserCtxt(void) {
! 15412: int test_ret = 0;
! 15413:
! 15414: #if defined(LIBXML_HTML_ENABLED)
! 15415: int mem_base;
! 15416: htmlParserCtxtPtr ret_val;
! 15417: const char * filename; /* the filename */
! 15418: int n_filename;
! 15419: char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
! 15420: int n_encoding;
! 15421:
! 15422: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
! 15423: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 15424: mem_base = xmlMemBlocks();
! 15425: filename = gen_fileoutput(n_filename, 0);
! 15426: encoding = gen_const_char_ptr(n_encoding, 1);
! 15427:
! 15428: ret_val = htmlCreateFileParserCtxt(filename, (const char *)encoding);
! 15429: desret_htmlParserCtxtPtr(ret_val);
! 15430: call_tests++;
! 15431: des_fileoutput(n_filename, filename, 0);
! 15432: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
! 15433: xmlResetLastError();
! 15434: if (mem_base != xmlMemBlocks()) {
! 15435: printf("Leak of %d blocks found in htmlCreateFileParserCtxt",
! 15436: xmlMemBlocks() - mem_base);
! 15437: test_ret++;
! 15438: printf(" %d", n_filename);
! 15439: printf(" %d", n_encoding);
! 15440: printf("\n");
! 15441: }
! 15442: }
! 15443: }
! 15444: function_tests++;
! 15445: #endif
! 15446:
! 15447: return(test_ret);
! 15448: }
! 15449:
! 15450:
! 15451: static int
! 15452: test_htmlInitAutoClose(void) {
! 15453: int test_ret = 0;
! 15454:
! 15455: #if defined(LIBXML_HTML_ENABLED)
! 15456: int mem_base;
! 15457:
! 15458: mem_base = xmlMemBlocks();
! 15459:
! 15460: htmlInitAutoClose();
! 15461: call_tests++;
! 15462: xmlResetLastError();
! 15463: if (mem_base != xmlMemBlocks()) {
! 15464: printf("Leak of %d blocks found in htmlInitAutoClose",
! 15465: xmlMemBlocks() - mem_base);
! 15466: test_ret++;
! 15467: printf("\n");
! 15468: }
! 15469: function_tests++;
! 15470: #endif
! 15471:
! 15472: return(test_ret);
! 15473: }
! 15474:
! 15475:
! 15476: static int
! 15477: test_inputPop(void) {
! 15478: int test_ret = 0;
! 15479:
! 15480: int mem_base;
! 15481: xmlParserInputPtr ret_val;
! 15482: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 15483: int n_ctxt;
! 15484:
! 15485: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 15486: mem_base = xmlMemBlocks();
! 15487: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 15488:
! 15489: ret_val = inputPop(ctxt);
! 15490: desret_xmlParserInputPtr(ret_val);
! 15491: call_tests++;
! 15492: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 15493: xmlResetLastError();
! 15494: if (mem_base != xmlMemBlocks()) {
! 15495: printf("Leak of %d blocks found in inputPop",
! 15496: xmlMemBlocks() - mem_base);
! 15497: test_ret++;
! 15498: printf(" %d", n_ctxt);
! 15499: printf("\n");
! 15500: }
! 15501: }
! 15502: function_tests++;
! 15503:
! 15504: return(test_ret);
! 15505: }
! 15506:
! 15507:
! 15508: static int
! 15509: test_inputPush(void) {
! 15510: int test_ret = 0;
! 15511:
! 15512: int mem_base;
! 15513: int ret_val;
! 15514: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 15515: int n_ctxt;
! 15516: xmlParserInputPtr value; /* the parser input */
! 15517: int n_value;
! 15518:
! 15519: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 15520: for (n_value = 0;n_value < gen_nb_xmlParserInputPtr;n_value++) {
! 15521: mem_base = xmlMemBlocks();
! 15522: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 15523: value = gen_xmlParserInputPtr(n_value, 1);
! 15524:
! 15525: ret_val = inputPush(ctxt, value);
! 15526: desret_int(ret_val);
! 15527: call_tests++;
! 15528: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 15529: des_xmlParserInputPtr(n_value, value, 1);
! 15530: xmlResetLastError();
! 15531: if (mem_base != xmlMemBlocks()) {
! 15532: printf("Leak of %d blocks found in inputPush",
! 15533: xmlMemBlocks() - mem_base);
! 15534: test_ret++;
! 15535: printf(" %d", n_ctxt);
! 15536: printf(" %d", n_value);
! 15537: printf("\n");
! 15538: }
! 15539: }
! 15540: }
! 15541: function_tests++;
! 15542:
! 15543: return(test_ret);
! 15544: }
! 15545:
! 15546:
! 15547: static int
! 15548: test_namePop(void) {
! 15549: int test_ret = 0;
! 15550:
! 15551: int mem_base;
! 15552: const xmlChar * ret_val;
! 15553: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 15554: int n_ctxt;
! 15555:
! 15556: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 15557: mem_base = xmlMemBlocks();
! 15558: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 15559:
! 15560: ret_val = namePop(ctxt);
! 15561: desret_const_xmlChar_ptr(ret_val);
! 15562: call_tests++;
! 15563: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 15564: xmlResetLastError();
! 15565: if (mem_base != xmlMemBlocks()) {
! 15566: printf("Leak of %d blocks found in namePop",
! 15567: xmlMemBlocks() - mem_base);
! 15568: test_ret++;
! 15569: printf(" %d", n_ctxt);
! 15570: printf("\n");
! 15571: }
! 15572: }
! 15573: function_tests++;
! 15574:
! 15575: return(test_ret);
! 15576: }
! 15577:
! 15578:
! 15579: static int
! 15580: test_namePush(void) {
! 15581: int test_ret = 0;
! 15582:
! 15583: int mem_base;
! 15584: int ret_val;
! 15585: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 15586: int n_ctxt;
! 15587: xmlChar * value; /* the element name */
! 15588: int n_value;
! 15589:
! 15590: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 15591: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 15592: mem_base = xmlMemBlocks();
! 15593: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 15594: value = gen_const_xmlChar_ptr(n_value, 1);
! 15595:
! 15596: ret_val = namePush(ctxt, (const xmlChar *)value);
! 15597: desret_int(ret_val);
! 15598: call_tests++;
! 15599: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 15600: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
! 15601: xmlResetLastError();
! 15602: if (mem_base != xmlMemBlocks()) {
! 15603: printf("Leak of %d blocks found in namePush",
! 15604: xmlMemBlocks() - mem_base);
! 15605: test_ret++;
! 15606: printf(" %d", n_ctxt);
! 15607: printf(" %d", n_value);
! 15608: printf("\n");
! 15609: }
! 15610: }
! 15611: }
! 15612: function_tests++;
! 15613:
! 15614: return(test_ret);
! 15615: }
! 15616:
! 15617:
! 15618: static int
! 15619: test_nodePop(void) {
! 15620: int test_ret = 0;
! 15621:
! 15622: int mem_base;
! 15623: xmlNodePtr ret_val;
! 15624: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 15625: int n_ctxt;
! 15626:
! 15627: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 15628: mem_base = xmlMemBlocks();
! 15629: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 15630:
! 15631: ret_val = nodePop(ctxt);
! 15632: desret_xmlNodePtr(ret_val);
! 15633: call_tests++;
! 15634: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 15635: xmlResetLastError();
! 15636: if (mem_base != xmlMemBlocks()) {
! 15637: printf("Leak of %d blocks found in nodePop",
! 15638: xmlMemBlocks() - mem_base);
! 15639: test_ret++;
! 15640: printf(" %d", n_ctxt);
! 15641: printf("\n");
! 15642: }
! 15643: }
! 15644: function_tests++;
! 15645:
! 15646: return(test_ret);
! 15647: }
! 15648:
! 15649:
! 15650: static int
! 15651: test_nodePush(void) {
! 15652: int test_ret = 0;
! 15653:
! 15654: int mem_base;
! 15655: int ret_val;
! 15656: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 15657: int n_ctxt;
! 15658: xmlNodePtr value; /* the element node */
! 15659: int n_value;
! 15660:
! 15661: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 15662: for (n_value = 0;n_value < gen_nb_xmlNodePtr;n_value++) {
! 15663: mem_base = xmlMemBlocks();
! 15664: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 15665: value = gen_xmlNodePtr(n_value, 1);
! 15666:
! 15667: ret_val = nodePush(ctxt, value);
! 15668: desret_int(ret_val);
! 15669: call_tests++;
! 15670: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 15671: des_xmlNodePtr(n_value, value, 1);
! 15672: xmlResetLastError();
! 15673: if (mem_base != xmlMemBlocks()) {
! 15674: printf("Leak of %d blocks found in nodePush",
! 15675: xmlMemBlocks() - mem_base);
! 15676: test_ret++;
! 15677: printf(" %d", n_ctxt);
! 15678: printf(" %d", n_value);
! 15679: printf("\n");
! 15680: }
! 15681: }
! 15682: }
! 15683: function_tests++;
! 15684:
! 15685: return(test_ret);
! 15686: }
! 15687:
! 15688:
! 15689: static int
! 15690: test_xmlCheckLanguageID(void) {
! 15691: int test_ret = 0;
! 15692:
! 15693: int mem_base;
! 15694: int ret_val;
! 15695: xmlChar * lang; /* pointer to the string value */
! 15696: int n_lang;
! 15697:
! 15698: for (n_lang = 0;n_lang < gen_nb_const_xmlChar_ptr;n_lang++) {
! 15699: mem_base = xmlMemBlocks();
! 15700: lang = gen_const_xmlChar_ptr(n_lang, 0);
! 15701:
! 15702: ret_val = xmlCheckLanguageID((const xmlChar *)lang);
! 15703: desret_int(ret_val);
! 15704: call_tests++;
! 15705: des_const_xmlChar_ptr(n_lang, (const xmlChar *)lang, 0);
! 15706: xmlResetLastError();
! 15707: if (mem_base != xmlMemBlocks()) {
! 15708: printf("Leak of %d blocks found in xmlCheckLanguageID",
! 15709: xmlMemBlocks() - mem_base);
! 15710: test_ret++;
! 15711: printf(" %d", n_lang);
! 15712: printf("\n");
! 15713: }
! 15714: }
! 15715: function_tests++;
! 15716:
! 15717: return(test_ret);
! 15718: }
! 15719:
! 15720:
! 15721: static int
! 15722: test_xmlCopyChar(void) {
! 15723: int test_ret = 0;
! 15724:
! 15725: int mem_base;
! 15726: int ret_val;
! 15727: int len; /* Ignored, compatibility */
! 15728: int n_len;
! 15729: xmlChar * out; /* pointer to an array of xmlChar */
! 15730: int n_out;
! 15731: int val; /* the char value */
! 15732: int n_val;
! 15733:
! 15734: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 15735: for (n_out = 0;n_out < gen_nb_xmlChar_ptr;n_out++) {
! 15736: for (n_val = 0;n_val < gen_nb_int;n_val++) {
! 15737: mem_base = xmlMemBlocks();
! 15738: len = gen_int(n_len, 0);
! 15739: out = gen_xmlChar_ptr(n_out, 1);
! 15740: val = gen_int(n_val, 2);
! 15741:
! 15742: ret_val = xmlCopyChar(len, out, val);
! 15743: desret_int(ret_val);
! 15744: call_tests++;
! 15745: des_int(n_len, len, 0);
! 15746: des_xmlChar_ptr(n_out, out, 1);
! 15747: des_int(n_val, val, 2);
! 15748: xmlResetLastError();
! 15749: if (mem_base != xmlMemBlocks()) {
! 15750: printf("Leak of %d blocks found in xmlCopyChar",
! 15751: xmlMemBlocks() - mem_base);
! 15752: test_ret++;
! 15753: printf(" %d", n_len);
! 15754: printf(" %d", n_out);
! 15755: printf(" %d", n_val);
! 15756: printf("\n");
! 15757: }
! 15758: }
! 15759: }
! 15760: }
! 15761: function_tests++;
! 15762:
! 15763: return(test_ret);
! 15764: }
! 15765:
! 15766:
! 15767: static int
! 15768: test_xmlCopyCharMultiByte(void) {
! 15769: int test_ret = 0;
! 15770:
! 15771: int mem_base;
! 15772: int ret_val;
! 15773: xmlChar * out; /* pointer to an array of xmlChar */
! 15774: int n_out;
! 15775: int val; /* the char value */
! 15776: int n_val;
! 15777:
! 15778: for (n_out = 0;n_out < gen_nb_xmlChar_ptr;n_out++) {
! 15779: for (n_val = 0;n_val < gen_nb_int;n_val++) {
! 15780: mem_base = xmlMemBlocks();
! 15781: out = gen_xmlChar_ptr(n_out, 0);
! 15782: val = gen_int(n_val, 1);
! 15783:
! 15784: ret_val = xmlCopyCharMultiByte(out, val);
! 15785: desret_int(ret_val);
! 15786: call_tests++;
! 15787: des_xmlChar_ptr(n_out, out, 0);
! 15788: des_int(n_val, val, 1);
! 15789: xmlResetLastError();
! 15790: if (mem_base != xmlMemBlocks()) {
! 15791: printf("Leak of %d blocks found in xmlCopyCharMultiByte",
! 15792: xmlMemBlocks() - mem_base);
! 15793: test_ret++;
! 15794: printf(" %d", n_out);
! 15795: printf(" %d", n_val);
! 15796: printf("\n");
! 15797: }
! 15798: }
! 15799: }
! 15800: function_tests++;
! 15801:
! 15802: return(test_ret);
! 15803: }
! 15804:
! 15805:
! 15806: static int
! 15807: test_xmlCreateEntityParserCtxt(void) {
! 15808: int test_ret = 0;
! 15809:
! 15810: int mem_base;
! 15811: xmlParserCtxtPtr ret_val;
! 15812: xmlChar * URL; /* the entity URL */
! 15813: int n_URL;
! 15814: xmlChar * ID; /* the entity PUBLIC ID */
! 15815: int n_ID;
! 15816: xmlChar * base; /* a possible base for the target URI */
! 15817: int n_base;
! 15818:
! 15819: for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) {
! 15820: for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
! 15821: for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) {
! 15822: mem_base = xmlMemBlocks();
! 15823: URL = gen_const_xmlChar_ptr(n_URL, 0);
! 15824: ID = gen_const_xmlChar_ptr(n_ID, 1);
! 15825: base = gen_const_xmlChar_ptr(n_base, 2);
! 15826:
! 15827: ret_val = xmlCreateEntityParserCtxt((const xmlChar *)URL, (const xmlChar *)ID, (const xmlChar *)base);
! 15828: desret_xmlParserCtxtPtr(ret_val);
! 15829: call_tests++;
! 15830: des_const_xmlChar_ptr(n_URL, (const xmlChar *)URL, 0);
! 15831: des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 1);
! 15832: des_const_xmlChar_ptr(n_base, (const xmlChar *)base, 2);
! 15833: xmlResetLastError();
! 15834: if (mem_base != xmlMemBlocks()) {
! 15835: printf("Leak of %d blocks found in xmlCreateEntityParserCtxt",
! 15836: xmlMemBlocks() - mem_base);
! 15837: test_ret++;
! 15838: printf(" %d", n_URL);
! 15839: printf(" %d", n_ID);
! 15840: printf(" %d", n_base);
! 15841: printf("\n");
! 15842: }
! 15843: }
! 15844: }
! 15845: }
! 15846: function_tests++;
! 15847:
! 15848: return(test_ret);
! 15849: }
! 15850:
! 15851:
! 15852: static int
! 15853: test_xmlCreateFileParserCtxt(void) {
! 15854: int test_ret = 0;
! 15855:
! 15856: int mem_base;
! 15857: xmlParserCtxtPtr ret_val;
! 15858: const char * filename; /* the filename */
! 15859: int n_filename;
! 15860:
! 15861: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
! 15862: mem_base = xmlMemBlocks();
! 15863: filename = gen_fileoutput(n_filename, 0);
! 15864:
! 15865: ret_val = xmlCreateFileParserCtxt(filename);
! 15866: desret_xmlParserCtxtPtr(ret_val);
! 15867: call_tests++;
! 15868: des_fileoutput(n_filename, filename, 0);
! 15869: xmlResetLastError();
! 15870: if (mem_base != xmlMemBlocks()) {
! 15871: printf("Leak of %d blocks found in xmlCreateFileParserCtxt",
! 15872: xmlMemBlocks() - mem_base);
! 15873: test_ret++;
! 15874: printf(" %d", n_filename);
! 15875: printf("\n");
! 15876: }
! 15877: }
! 15878: function_tests++;
! 15879:
! 15880: return(test_ret);
! 15881: }
! 15882:
! 15883:
! 15884: static int
! 15885: test_xmlCreateMemoryParserCtxt(void) {
! 15886: int test_ret = 0;
! 15887:
! 15888: int mem_base;
! 15889: xmlParserCtxtPtr ret_val;
! 15890: char * buffer; /* a pointer to a char array */
! 15891: int n_buffer;
! 15892: int size; /* the size of the array */
! 15893: int n_size;
! 15894:
! 15895: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
! 15896: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 15897: mem_base = xmlMemBlocks();
! 15898: buffer = gen_const_char_ptr(n_buffer, 0);
! 15899: size = gen_int(n_size, 1);
! 15900:
! 15901: ret_val = xmlCreateMemoryParserCtxt((const char *)buffer, size);
! 15902: desret_xmlParserCtxtPtr(ret_val);
! 15903: call_tests++;
! 15904: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
! 15905: des_int(n_size, size, 1);
! 15906: xmlResetLastError();
! 15907: if (mem_base != xmlMemBlocks()) {
! 15908: printf("Leak of %d blocks found in xmlCreateMemoryParserCtxt",
! 15909: xmlMemBlocks() - mem_base);
! 15910: test_ret++;
! 15911: printf(" %d", n_buffer);
! 15912: printf(" %d", n_size);
! 15913: printf("\n");
! 15914: }
! 15915: }
! 15916: }
! 15917: function_tests++;
! 15918:
! 15919: return(test_ret);
! 15920: }
! 15921:
! 15922:
! 15923: static int
! 15924: test_xmlCreateURLParserCtxt(void) {
! 15925: int test_ret = 0;
! 15926:
! 15927: int mem_base;
! 15928: xmlParserCtxtPtr ret_val;
! 15929: const char * filename; /* the filename or URL */
! 15930: int n_filename;
! 15931: int options; /* a combination of xmlParserOption */
! 15932: int n_options;
! 15933:
! 15934: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
! 15935: for (n_options = 0;n_options < gen_nb_int;n_options++) {
! 15936: mem_base = xmlMemBlocks();
! 15937: filename = gen_fileoutput(n_filename, 0);
! 15938: options = gen_int(n_options, 1);
! 15939:
! 15940: ret_val = xmlCreateURLParserCtxt(filename, options);
! 15941: desret_xmlParserCtxtPtr(ret_val);
! 15942: call_tests++;
! 15943: des_fileoutput(n_filename, filename, 0);
! 15944: des_int(n_options, options, 1);
! 15945: xmlResetLastError();
! 15946: if (mem_base != xmlMemBlocks()) {
! 15947: printf("Leak of %d blocks found in xmlCreateURLParserCtxt",
! 15948: xmlMemBlocks() - mem_base);
! 15949: test_ret++;
! 15950: printf(" %d", n_filename);
! 15951: printf(" %d", n_options);
! 15952: printf("\n");
! 15953: }
! 15954: }
! 15955: }
! 15956: function_tests++;
! 15957:
! 15958: return(test_ret);
! 15959: }
! 15960:
! 15961:
! 15962: static int
! 15963: test_xmlCurrentChar(void) {
! 15964: int test_ret = 0;
! 15965:
! 15966: int mem_base;
! 15967: int ret_val;
! 15968: xmlParserCtxtPtr ctxt; /* the XML parser context */
! 15969: int n_ctxt;
! 15970: int * len; /* pointer to the length of the char read */
! 15971: int n_len;
! 15972:
! 15973: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 15974: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
! 15975: mem_base = xmlMemBlocks();
! 15976: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 15977: len = gen_int_ptr(n_len, 1);
! 15978:
! 15979: ret_val = xmlCurrentChar(ctxt, len);
! 15980: desret_int(ret_val);
! 15981: call_tests++;
! 15982: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 15983: des_int_ptr(n_len, len, 1);
! 15984: xmlResetLastError();
! 15985: if (mem_base != xmlMemBlocks()) {
! 15986: printf("Leak of %d blocks found in xmlCurrentChar",
! 15987: xmlMemBlocks() - mem_base);
! 15988: test_ret++;
! 15989: printf(" %d", n_ctxt);
! 15990: printf(" %d", n_len);
! 15991: printf("\n");
! 15992: }
! 15993: }
! 15994: }
! 15995: function_tests++;
! 15996:
! 15997: return(test_ret);
! 15998: }
! 15999:
! 16000:
! 16001: static int
! 16002: test_xmlErrMemory(void) {
! 16003: int test_ret = 0;
! 16004:
! 16005: int mem_base;
! 16006: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 16007: int n_ctxt;
! 16008: char * extra; /* extra informations */
! 16009: int n_extra;
! 16010:
! 16011: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 16012: for (n_extra = 0;n_extra < gen_nb_const_char_ptr;n_extra++) {
! 16013: mem_base = xmlMemBlocks();
! 16014: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 16015: extra = gen_const_char_ptr(n_extra, 1);
! 16016:
! 16017: xmlErrMemory(ctxt, (const char *)extra);
! 16018: call_tests++;
! 16019: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 16020: des_const_char_ptr(n_extra, (const char *)extra, 1);
! 16021: xmlResetLastError();
! 16022: if (mem_base != xmlMemBlocks()) {
! 16023: printf("Leak of %d blocks found in xmlErrMemory",
! 16024: xmlMemBlocks() - mem_base);
! 16025: test_ret++;
! 16026: printf(" %d", n_ctxt);
! 16027: printf(" %d", n_extra);
! 16028: printf("\n");
! 16029: }
! 16030: }
! 16031: }
! 16032: function_tests++;
! 16033:
! 16034: return(test_ret);
! 16035: }
! 16036:
! 16037:
! 16038: static int
! 16039: test_xmlIsLetter(void) {
! 16040: int test_ret = 0;
! 16041:
! 16042: int mem_base;
! 16043: int ret_val;
! 16044: int c; /* an unicode character (int) */
! 16045: int n_c;
! 16046:
! 16047: for (n_c = 0;n_c < gen_nb_int;n_c++) {
! 16048: mem_base = xmlMemBlocks();
! 16049: c = gen_int(n_c, 0);
! 16050:
! 16051: ret_val = xmlIsLetter(c);
! 16052: desret_int(ret_val);
! 16053: call_tests++;
! 16054: des_int(n_c, c, 0);
! 16055: xmlResetLastError();
! 16056: if (mem_base != xmlMemBlocks()) {
! 16057: printf("Leak of %d blocks found in xmlIsLetter",
! 16058: xmlMemBlocks() - mem_base);
! 16059: test_ret++;
! 16060: printf(" %d", n_c);
! 16061: printf("\n");
! 16062: }
! 16063: }
! 16064: function_tests++;
! 16065:
! 16066: return(test_ret);
! 16067: }
! 16068:
! 16069:
! 16070: static int
! 16071: test_xmlNewEntityInputStream(void) {
! 16072: int test_ret = 0;
! 16073:
! 16074: int mem_base;
! 16075: xmlParserInputPtr ret_val;
! 16076: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 16077: int n_ctxt;
! 16078: xmlEntityPtr entity; /* an Entity pointer */
! 16079: int n_entity;
! 16080:
! 16081: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 16082: for (n_entity = 0;n_entity < gen_nb_xmlEntityPtr;n_entity++) {
! 16083: mem_base = xmlMemBlocks();
! 16084: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 16085: entity = gen_xmlEntityPtr(n_entity, 1);
! 16086:
! 16087: ret_val = xmlNewEntityInputStream(ctxt, entity);
! 16088: desret_xmlParserInputPtr(ret_val);
! 16089: call_tests++;
! 16090: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 16091: des_xmlEntityPtr(n_entity, entity, 1);
! 16092: xmlResetLastError();
! 16093: if (mem_base != xmlMemBlocks()) {
! 16094: printf("Leak of %d blocks found in xmlNewEntityInputStream",
! 16095: xmlMemBlocks() - mem_base);
! 16096: test_ret++;
! 16097: printf(" %d", n_ctxt);
! 16098: printf(" %d", n_entity);
! 16099: printf("\n");
! 16100: }
! 16101: }
! 16102: }
! 16103: function_tests++;
! 16104:
! 16105: return(test_ret);
! 16106: }
! 16107:
! 16108:
! 16109: static int
! 16110: test_xmlNewInputFromFile(void) {
! 16111: int test_ret = 0;
! 16112:
! 16113: int mem_base;
! 16114: xmlParserInputPtr ret_val;
! 16115: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 16116: int n_ctxt;
! 16117: const char * filename; /* the filename to use as entity */
! 16118: int n_filename;
! 16119:
! 16120: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 16121: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 16122: mem_base = xmlMemBlocks();
! 16123: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 16124: filename = gen_filepath(n_filename, 1);
! 16125:
! 16126: ret_val = xmlNewInputFromFile(ctxt, filename);
! 16127: desret_xmlParserInputPtr(ret_val);
! 16128: call_tests++;
! 16129: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 16130: des_filepath(n_filename, filename, 1);
! 16131: xmlResetLastError();
! 16132: if (mem_base != xmlMemBlocks()) {
! 16133: printf("Leak of %d blocks found in xmlNewInputFromFile",
! 16134: xmlMemBlocks() - mem_base);
! 16135: test_ret++;
! 16136: printf(" %d", n_ctxt);
! 16137: printf(" %d", n_filename);
! 16138: printf("\n");
! 16139: }
! 16140: }
! 16141: }
! 16142: function_tests++;
! 16143:
! 16144: return(test_ret);
! 16145: }
! 16146:
! 16147:
! 16148: static int
! 16149: test_xmlNewInputStream(void) {
! 16150: int test_ret = 0;
! 16151:
! 16152: int mem_base;
! 16153: xmlParserInputPtr ret_val;
! 16154: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 16155: int n_ctxt;
! 16156:
! 16157: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 16158: mem_base = xmlMemBlocks();
! 16159: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 16160:
! 16161: ret_val = xmlNewInputStream(ctxt);
! 16162: desret_xmlParserInputPtr(ret_val);
! 16163: call_tests++;
! 16164: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 16165: xmlResetLastError();
! 16166: if (mem_base != xmlMemBlocks()) {
! 16167: printf("Leak of %d blocks found in xmlNewInputStream",
! 16168: xmlMemBlocks() - mem_base);
! 16169: test_ret++;
! 16170: printf(" %d", n_ctxt);
! 16171: printf("\n");
! 16172: }
! 16173: }
! 16174: function_tests++;
! 16175:
! 16176: return(test_ret);
! 16177: }
! 16178:
! 16179:
! 16180: static int
! 16181: test_xmlNewStringInputStream(void) {
! 16182: int test_ret = 0;
! 16183:
! 16184: int mem_base;
! 16185: xmlParserInputPtr ret_val;
! 16186: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 16187: int n_ctxt;
! 16188: xmlChar * buffer; /* an memory buffer */
! 16189: int n_buffer;
! 16190:
! 16191: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 16192: for (n_buffer = 0;n_buffer < gen_nb_const_xmlChar_ptr;n_buffer++) {
! 16193: mem_base = xmlMemBlocks();
! 16194: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 16195: buffer = gen_const_xmlChar_ptr(n_buffer, 1);
! 16196:
! 16197: ret_val = xmlNewStringInputStream(ctxt, (const xmlChar *)buffer);
! 16198: desret_xmlParserInputPtr(ret_val);
! 16199: call_tests++;
! 16200: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 16201: des_const_xmlChar_ptr(n_buffer, (const xmlChar *)buffer, 1);
! 16202: xmlResetLastError();
! 16203: if (mem_base != xmlMemBlocks()) {
! 16204: printf("Leak of %d blocks found in xmlNewStringInputStream",
! 16205: xmlMemBlocks() - mem_base);
! 16206: test_ret++;
! 16207: printf(" %d", n_ctxt);
! 16208: printf(" %d", n_buffer);
! 16209: printf("\n");
! 16210: }
! 16211: }
! 16212: }
! 16213: function_tests++;
! 16214:
! 16215: return(test_ret);
! 16216: }
! 16217:
! 16218:
! 16219: static int
! 16220: test_xmlNextChar(void) {
! 16221: int test_ret = 0;
! 16222:
! 16223: int mem_base;
! 16224: xmlParserCtxtPtr ctxt; /* the XML parser context */
! 16225: int n_ctxt;
! 16226:
! 16227: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 16228: mem_base = xmlMemBlocks();
! 16229: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 16230:
! 16231: xmlNextChar(ctxt);
! 16232: call_tests++;
! 16233: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 16234: xmlResetLastError();
! 16235: if (mem_base != xmlMemBlocks()) {
! 16236: printf("Leak of %d blocks found in xmlNextChar",
! 16237: xmlMemBlocks() - mem_base);
! 16238: test_ret++;
! 16239: printf(" %d", n_ctxt);
! 16240: printf("\n");
! 16241: }
! 16242: }
! 16243: function_tests++;
! 16244:
! 16245: return(test_ret);
! 16246: }
! 16247:
! 16248:
! 16249: static int
! 16250: test_xmlParserInputShrink(void) {
! 16251: int test_ret = 0;
! 16252:
! 16253: int mem_base;
! 16254: xmlParserInputPtr in; /* an XML parser input */
! 16255: int n_in;
! 16256:
! 16257: for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) {
! 16258: mem_base = xmlMemBlocks();
! 16259: in = gen_xmlParserInputPtr(n_in, 0);
! 16260:
! 16261: xmlParserInputShrink(in);
! 16262: call_tests++;
! 16263: des_xmlParserInputPtr(n_in, in, 0);
! 16264: xmlResetLastError();
! 16265: if (mem_base != xmlMemBlocks()) {
! 16266: printf("Leak of %d blocks found in xmlParserInputShrink",
! 16267: xmlMemBlocks() - mem_base);
! 16268: test_ret++;
! 16269: printf(" %d", n_in);
! 16270: printf("\n");
! 16271: }
! 16272: }
! 16273: function_tests++;
! 16274:
! 16275: return(test_ret);
! 16276: }
! 16277:
! 16278:
! 16279: static int
! 16280: test_xmlPopInput(void) {
! 16281: int test_ret = 0;
! 16282:
! 16283: int mem_base;
! 16284: xmlChar ret_val;
! 16285: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 16286: int n_ctxt;
! 16287:
! 16288: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 16289: mem_base = xmlMemBlocks();
! 16290: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 16291:
! 16292: ret_val = xmlPopInput(ctxt);
! 16293: desret_xmlChar(ret_val);
! 16294: call_tests++;
! 16295: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 16296: xmlResetLastError();
! 16297: if (mem_base != xmlMemBlocks()) {
! 16298: printf("Leak of %d blocks found in xmlPopInput",
! 16299: xmlMemBlocks() - mem_base);
! 16300: test_ret++;
! 16301: printf(" %d", n_ctxt);
! 16302: printf("\n");
! 16303: }
! 16304: }
! 16305: function_tests++;
! 16306:
! 16307: return(test_ret);
! 16308: }
! 16309:
! 16310:
! 16311: static int
! 16312: test_xmlPushInput(void) {
! 16313: int test_ret = 0;
! 16314:
! 16315: int mem_base;
! 16316: int ret_val;
! 16317: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 16318: int n_ctxt;
! 16319: xmlParserInputPtr input; /* an XML parser input fragment (entity, XML fragment ...). */
! 16320: int n_input;
! 16321:
! 16322: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 16323: for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
! 16324: mem_base = xmlMemBlocks();
! 16325: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 16326: input = gen_xmlParserInputPtr(n_input, 1);
! 16327:
! 16328: ret_val = xmlPushInput(ctxt, input);
! 16329: desret_int(ret_val);
! 16330: call_tests++;
! 16331: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 16332: des_xmlParserInputPtr(n_input, input, 1);
! 16333: xmlResetLastError();
! 16334: if (mem_base != xmlMemBlocks()) {
! 16335: printf("Leak of %d blocks found in xmlPushInput",
! 16336: xmlMemBlocks() - mem_base);
! 16337: test_ret++;
! 16338: printf(" %d", n_ctxt);
! 16339: printf(" %d", n_input);
! 16340: printf("\n");
! 16341: }
! 16342: }
! 16343: }
! 16344: function_tests++;
! 16345:
! 16346: return(test_ret);
! 16347: }
! 16348:
! 16349:
! 16350: static int
! 16351: test_xmlSetEntityReferenceFunc(void) {
! 16352: int test_ret = 0;
! 16353:
! 16354:
! 16355: /* missing type support */
! 16356: return(test_ret);
! 16357: }
! 16358:
! 16359:
! 16360: static int
! 16361: test_xmlSplitQName(void) {
! 16362: int test_ret = 0;
! 16363:
! 16364: int mem_base;
! 16365: xmlChar * ret_val;
! 16366: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 16367: int n_ctxt;
! 16368: xmlChar * name; /* an XML parser context */
! 16369: int n_name;
! 16370: xmlChar ** prefix; /* a xmlChar ** */
! 16371: int n_prefix;
! 16372:
! 16373: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 16374: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 16375: for (n_prefix = 0;n_prefix < gen_nb_xmlChar_ptr_ptr;n_prefix++) {
! 16376: mem_base = xmlMemBlocks();
! 16377: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 16378: name = gen_const_xmlChar_ptr(n_name, 1);
! 16379: prefix = gen_xmlChar_ptr_ptr(n_prefix, 2);
! 16380:
! 16381: ret_val = xmlSplitQName(ctxt, (const xmlChar *)name, prefix);
! 16382: desret_xmlChar_ptr(ret_val);
! 16383: call_tests++;
! 16384: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 16385: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 16386: des_xmlChar_ptr_ptr(n_prefix, prefix, 2);
! 16387: xmlResetLastError();
! 16388: if (mem_base != xmlMemBlocks()) {
! 16389: printf("Leak of %d blocks found in xmlSplitQName",
! 16390: xmlMemBlocks() - mem_base);
! 16391: test_ret++;
! 16392: printf(" %d", n_ctxt);
! 16393: printf(" %d", n_name);
! 16394: printf(" %d", n_prefix);
! 16395: printf("\n");
! 16396: }
! 16397: }
! 16398: }
! 16399: }
! 16400: function_tests++;
! 16401:
! 16402: return(test_ret);
! 16403: }
! 16404:
! 16405:
! 16406: static int
! 16407: test_xmlStringCurrentChar(void) {
! 16408: int test_ret = 0;
! 16409:
! 16410: int mem_base;
! 16411: int ret_val;
! 16412: xmlParserCtxtPtr ctxt; /* the XML parser context */
! 16413: int n_ctxt;
! 16414: xmlChar * cur; /* pointer to the beginning of the char */
! 16415: int n_cur;
! 16416: int * len; /* pointer to the length of the char read */
! 16417: int n_len;
! 16418:
! 16419: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 16420: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
! 16421: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
! 16422: mem_base = xmlMemBlocks();
! 16423: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 16424: cur = gen_const_xmlChar_ptr(n_cur, 1);
! 16425: len = gen_int_ptr(n_len, 2);
! 16426:
! 16427: ret_val = xmlStringCurrentChar(ctxt, (const xmlChar *)cur, len);
! 16428: desret_int(ret_val);
! 16429: call_tests++;
! 16430: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 16431: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
! 16432: des_int_ptr(n_len, len, 2);
! 16433: xmlResetLastError();
! 16434: if (mem_base != xmlMemBlocks()) {
! 16435: printf("Leak of %d blocks found in xmlStringCurrentChar",
! 16436: xmlMemBlocks() - mem_base);
! 16437: test_ret++;
! 16438: printf(" %d", n_ctxt);
! 16439: printf(" %d", n_cur);
! 16440: printf(" %d", n_len);
! 16441: printf("\n");
! 16442: }
! 16443: }
! 16444: }
! 16445: }
! 16446: function_tests++;
! 16447:
! 16448: return(test_ret);
! 16449: }
! 16450:
! 16451:
! 16452: static int
! 16453: test_xmlStringDecodeEntities(void) {
! 16454: int test_ret = 0;
! 16455:
! 16456: int mem_base;
! 16457: xmlChar * ret_val;
! 16458: xmlParserCtxtPtr ctxt; /* the parser context */
! 16459: int n_ctxt;
! 16460: xmlChar * str; /* the input string */
! 16461: int n_str;
! 16462: int what; /* combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF */
! 16463: int n_what;
! 16464: xmlChar end; /* an end marker xmlChar, 0 if none */
! 16465: int n_end;
! 16466: xmlChar end2; /* an end marker xmlChar, 0 if none */
! 16467: int n_end2;
! 16468: xmlChar end3; /* an end marker xmlChar, 0 if none */
! 16469: int n_end3;
! 16470:
! 16471: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 16472: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 16473: for (n_what = 0;n_what < gen_nb_int;n_what++) {
! 16474: for (n_end = 0;n_end < gen_nb_xmlChar;n_end++) {
! 16475: for (n_end2 = 0;n_end2 < gen_nb_xmlChar;n_end2++) {
! 16476: for (n_end3 = 0;n_end3 < gen_nb_xmlChar;n_end3++) {
! 16477: mem_base = xmlMemBlocks();
! 16478: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 16479: str = gen_const_xmlChar_ptr(n_str, 1);
! 16480: what = gen_int(n_what, 2);
! 16481: end = gen_xmlChar(n_end, 3);
! 16482: end2 = gen_xmlChar(n_end2, 4);
! 16483: end3 = gen_xmlChar(n_end3, 5);
! 16484:
! 16485: ret_val = xmlStringDecodeEntities(ctxt, (const xmlChar *)str, what, end, end2, end3);
! 16486: desret_xmlChar_ptr(ret_val);
! 16487: call_tests++;
! 16488: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 16489: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
! 16490: des_int(n_what, what, 2);
! 16491: des_xmlChar(n_end, end, 3);
! 16492: des_xmlChar(n_end2, end2, 4);
! 16493: des_xmlChar(n_end3, end3, 5);
! 16494: xmlResetLastError();
! 16495: if (mem_base != xmlMemBlocks()) {
! 16496: printf("Leak of %d blocks found in xmlStringDecodeEntities",
! 16497: xmlMemBlocks() - mem_base);
! 16498: test_ret++;
! 16499: printf(" %d", n_ctxt);
! 16500: printf(" %d", n_str);
! 16501: printf(" %d", n_what);
! 16502: printf(" %d", n_end);
! 16503: printf(" %d", n_end2);
! 16504: printf(" %d", n_end3);
! 16505: printf("\n");
! 16506: }
! 16507: }
! 16508: }
! 16509: }
! 16510: }
! 16511: }
! 16512: }
! 16513: function_tests++;
! 16514:
! 16515: return(test_ret);
! 16516: }
! 16517:
! 16518:
! 16519: static int
! 16520: test_xmlStringLenDecodeEntities(void) {
! 16521: int test_ret = 0;
! 16522:
! 16523: int mem_base;
! 16524: xmlChar * ret_val;
! 16525: xmlParserCtxtPtr ctxt; /* the parser context */
! 16526: int n_ctxt;
! 16527: xmlChar * str; /* the input string */
! 16528: int n_str;
! 16529: int len; /* the string length */
! 16530: int n_len;
! 16531: int what; /* combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF */
! 16532: int n_what;
! 16533: xmlChar end; /* an end marker xmlChar, 0 if none */
! 16534: int n_end;
! 16535: xmlChar end2; /* an end marker xmlChar, 0 if none */
! 16536: int n_end2;
! 16537: xmlChar end3; /* an end marker xmlChar, 0 if none */
! 16538: int n_end3;
! 16539:
! 16540: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 16541: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 16542: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 16543: for (n_what = 0;n_what < gen_nb_int;n_what++) {
! 16544: for (n_end = 0;n_end < gen_nb_xmlChar;n_end++) {
! 16545: for (n_end2 = 0;n_end2 < gen_nb_xmlChar;n_end2++) {
! 16546: for (n_end3 = 0;n_end3 < gen_nb_xmlChar;n_end3++) {
! 16547: mem_base = xmlMemBlocks();
! 16548: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 16549: str = gen_const_xmlChar_ptr(n_str, 1);
! 16550: len = gen_int(n_len, 2);
! 16551: what = gen_int(n_what, 3);
! 16552: end = gen_xmlChar(n_end, 4);
! 16553: end2 = gen_xmlChar(n_end2, 5);
! 16554: end3 = gen_xmlChar(n_end3, 6);
! 16555:
! 16556: ret_val = xmlStringLenDecodeEntities(ctxt, (const xmlChar *)str, len, what, end, end2, end3);
! 16557: desret_xmlChar_ptr(ret_val);
! 16558: call_tests++;
! 16559: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 16560: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
! 16561: des_int(n_len, len, 2);
! 16562: des_int(n_what, what, 3);
! 16563: des_xmlChar(n_end, end, 4);
! 16564: des_xmlChar(n_end2, end2, 5);
! 16565: des_xmlChar(n_end3, end3, 6);
! 16566: xmlResetLastError();
! 16567: if (mem_base != xmlMemBlocks()) {
! 16568: printf("Leak of %d blocks found in xmlStringLenDecodeEntities",
! 16569: xmlMemBlocks() - mem_base);
! 16570: test_ret++;
! 16571: printf(" %d", n_ctxt);
! 16572: printf(" %d", n_str);
! 16573: printf(" %d", n_len);
! 16574: printf(" %d", n_what);
! 16575: printf(" %d", n_end);
! 16576: printf(" %d", n_end2);
! 16577: printf(" %d", n_end3);
! 16578: printf("\n");
! 16579: }
! 16580: }
! 16581: }
! 16582: }
! 16583: }
! 16584: }
! 16585: }
! 16586: }
! 16587: function_tests++;
! 16588:
! 16589: return(test_ret);
! 16590: }
! 16591:
! 16592:
! 16593: static int
! 16594: test_xmlSwitchEncoding(void) {
! 16595: int test_ret = 0;
! 16596:
! 16597: int mem_base;
! 16598: int ret_val;
! 16599: xmlParserCtxtPtr ctxt; /* the parser context */
! 16600: int n_ctxt;
! 16601: xmlCharEncoding enc; /* the encoding value (number) */
! 16602: int n_enc;
! 16603:
! 16604: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 16605: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
! 16606: mem_base = xmlMemBlocks();
! 16607: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 16608: enc = gen_xmlCharEncoding(n_enc, 1);
! 16609:
! 16610: ret_val = xmlSwitchEncoding(ctxt, enc);
! 16611: desret_int(ret_val);
! 16612: call_tests++;
! 16613: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 16614: des_xmlCharEncoding(n_enc, enc, 1);
! 16615: xmlResetLastError();
! 16616: if (mem_base != xmlMemBlocks()) {
! 16617: printf("Leak of %d blocks found in xmlSwitchEncoding",
! 16618: xmlMemBlocks() - mem_base);
! 16619: test_ret++;
! 16620: printf(" %d", n_ctxt);
! 16621: printf(" %d", n_enc);
! 16622: printf("\n");
! 16623: }
! 16624: }
! 16625: }
! 16626: function_tests++;
! 16627:
! 16628: return(test_ret);
! 16629: }
! 16630:
! 16631:
! 16632: static int
! 16633: test_xmlSwitchInputEncoding(void) {
! 16634: int test_ret = 0;
! 16635:
! 16636: int mem_base;
! 16637: int ret_val;
! 16638: xmlParserCtxtPtr ctxt; /* the parser context */
! 16639: int n_ctxt;
! 16640: xmlParserInputPtr input; /* the input stream */
! 16641: int n_input;
! 16642: xmlCharEncodingHandlerPtr handler; /* the encoding handler */
! 16643: int n_handler;
! 16644:
! 16645: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 16646: for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
! 16647: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) {
! 16648: mem_base = xmlMemBlocks();
! 16649: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 16650: input = gen_xmlParserInputPtr(n_input, 1);
! 16651: handler = gen_xmlCharEncodingHandlerPtr(n_handler, 2);
! 16652:
! 16653: ret_val = xmlSwitchInputEncoding(ctxt, input, handler);
! 16654: desret_int(ret_val);
! 16655: call_tests++;
! 16656: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 16657: des_xmlParserInputPtr(n_input, input, 1);
! 16658: des_xmlCharEncodingHandlerPtr(n_handler, handler, 2);
! 16659: xmlResetLastError();
! 16660: if (mem_base != xmlMemBlocks()) {
! 16661: printf("Leak of %d blocks found in xmlSwitchInputEncoding",
! 16662: xmlMemBlocks() - mem_base);
! 16663: test_ret++;
! 16664: printf(" %d", n_ctxt);
! 16665: printf(" %d", n_input);
! 16666: printf(" %d", n_handler);
! 16667: printf("\n");
! 16668: }
! 16669: }
! 16670: }
! 16671: }
! 16672: function_tests++;
! 16673:
! 16674: return(test_ret);
! 16675: }
! 16676:
! 16677:
! 16678: static int
! 16679: test_xmlSwitchToEncoding(void) {
! 16680: int test_ret = 0;
! 16681:
! 16682: int mem_base;
! 16683: int ret_val;
! 16684: xmlParserCtxtPtr ctxt; /* the parser context */
! 16685: int n_ctxt;
! 16686: xmlCharEncodingHandlerPtr handler; /* the encoding handler */
! 16687: int n_handler;
! 16688:
! 16689: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 16690: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) {
! 16691: mem_base = xmlMemBlocks();
! 16692: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 16693: handler = gen_xmlCharEncodingHandlerPtr(n_handler, 1);
! 16694:
! 16695: ret_val = xmlSwitchToEncoding(ctxt, handler);
! 16696: desret_int(ret_val);
! 16697: call_tests++;
! 16698: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 16699: des_xmlCharEncodingHandlerPtr(n_handler, handler, 1);
! 16700: xmlResetLastError();
! 16701: if (mem_base != xmlMemBlocks()) {
! 16702: printf("Leak of %d blocks found in xmlSwitchToEncoding",
! 16703: xmlMemBlocks() - mem_base);
! 16704: test_ret++;
! 16705: printf(" %d", n_ctxt);
! 16706: printf(" %d", n_handler);
! 16707: printf("\n");
! 16708: }
! 16709: }
! 16710: }
! 16711: function_tests++;
! 16712:
! 16713: return(test_ret);
! 16714: }
! 16715:
! 16716: static int
! 16717: test_parserInternals(void) {
! 16718: int test_ret = 0;
! 16719:
! 16720: if (quiet == 0) printf("Testing parserInternals : 33 of 90 functions ...\n");
! 16721: test_ret += test_htmlCreateFileParserCtxt();
! 16722: test_ret += test_htmlInitAutoClose();
! 16723: test_ret += test_inputPop();
! 16724: test_ret += test_inputPush();
! 16725: test_ret += test_namePop();
! 16726: test_ret += test_namePush();
! 16727: test_ret += test_nodePop();
! 16728: test_ret += test_nodePush();
! 16729: test_ret += test_xmlCheckLanguageID();
! 16730: test_ret += test_xmlCopyChar();
! 16731: test_ret += test_xmlCopyCharMultiByte();
! 16732: test_ret += test_xmlCreateEntityParserCtxt();
! 16733: test_ret += test_xmlCreateFileParserCtxt();
! 16734: test_ret += test_xmlCreateMemoryParserCtxt();
! 16735: test_ret += test_xmlCreateURLParserCtxt();
! 16736: test_ret += test_xmlCurrentChar();
! 16737: test_ret += test_xmlErrMemory();
! 16738: test_ret += test_xmlIsLetter();
! 16739: test_ret += test_xmlNewEntityInputStream();
! 16740: test_ret += test_xmlNewInputFromFile();
! 16741: test_ret += test_xmlNewInputStream();
! 16742: test_ret += test_xmlNewStringInputStream();
! 16743: test_ret += test_xmlNextChar();
! 16744: test_ret += test_xmlParserInputShrink();
! 16745: test_ret += test_xmlPopInput();
! 16746: test_ret += test_xmlPushInput();
! 16747: test_ret += test_xmlSetEntityReferenceFunc();
! 16748: test_ret += test_xmlSplitQName();
! 16749: test_ret += test_xmlStringCurrentChar();
! 16750: test_ret += test_xmlStringDecodeEntities();
! 16751: test_ret += test_xmlStringLenDecodeEntities();
! 16752: test_ret += test_xmlSwitchEncoding();
! 16753: test_ret += test_xmlSwitchInputEncoding();
! 16754: test_ret += test_xmlSwitchToEncoding();
! 16755:
! 16756: if (test_ret != 0)
! 16757: printf("Module parserInternals: %d errors\n", test_ret);
! 16758: return(test_ret);
! 16759: }
! 16760:
! 16761: static int
! 16762: test_xmlPatternFromRoot(void) {
! 16763: int test_ret = 0;
! 16764:
! 16765: #if defined(LIBXML_PATTERN_ENABLED)
! 16766: int mem_base;
! 16767: int ret_val;
! 16768: xmlPatternPtr comp; /* the precompiled pattern */
! 16769: int n_comp;
! 16770:
! 16771: for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
! 16772: mem_base = xmlMemBlocks();
! 16773: comp = gen_xmlPatternPtr(n_comp, 0);
! 16774:
! 16775: ret_val = xmlPatternFromRoot(comp);
! 16776: desret_int(ret_val);
! 16777: call_tests++;
! 16778: des_xmlPatternPtr(n_comp, comp, 0);
! 16779: xmlResetLastError();
! 16780: if (mem_base != xmlMemBlocks()) {
! 16781: printf("Leak of %d blocks found in xmlPatternFromRoot",
! 16782: xmlMemBlocks() - mem_base);
! 16783: test_ret++;
! 16784: printf(" %d", n_comp);
! 16785: printf("\n");
! 16786: }
! 16787: }
! 16788: function_tests++;
! 16789: #endif
! 16790:
! 16791: return(test_ret);
! 16792: }
! 16793:
! 16794:
! 16795: static int
! 16796: test_xmlPatternGetStreamCtxt(void) {
! 16797: int test_ret = 0;
! 16798:
! 16799:
! 16800: /* missing type support */
! 16801: return(test_ret);
! 16802: }
! 16803:
! 16804:
! 16805: static int
! 16806: test_xmlPatternMatch(void) {
! 16807: int test_ret = 0;
! 16808:
! 16809: #if defined(LIBXML_PATTERN_ENABLED)
! 16810: int mem_base;
! 16811: int ret_val;
! 16812: xmlPatternPtr comp; /* the precompiled pattern */
! 16813: int n_comp;
! 16814: xmlNodePtr node; /* a node */
! 16815: int n_node;
! 16816:
! 16817: for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
! 16818: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 16819: mem_base = xmlMemBlocks();
! 16820: comp = gen_xmlPatternPtr(n_comp, 0);
! 16821: node = gen_xmlNodePtr(n_node, 1);
! 16822:
! 16823: ret_val = xmlPatternMatch(comp, node);
! 16824: desret_int(ret_val);
! 16825: call_tests++;
! 16826: des_xmlPatternPtr(n_comp, comp, 0);
! 16827: des_xmlNodePtr(n_node, node, 1);
! 16828: xmlResetLastError();
! 16829: if (mem_base != xmlMemBlocks()) {
! 16830: printf("Leak of %d blocks found in xmlPatternMatch",
! 16831: xmlMemBlocks() - mem_base);
! 16832: test_ret++;
! 16833: printf(" %d", n_comp);
! 16834: printf(" %d", n_node);
! 16835: printf("\n");
! 16836: }
! 16837: }
! 16838: }
! 16839: function_tests++;
! 16840: #endif
! 16841:
! 16842: return(test_ret);
! 16843: }
! 16844:
! 16845:
! 16846: static int
! 16847: test_xmlPatternMaxDepth(void) {
! 16848: int test_ret = 0;
! 16849:
! 16850: #if defined(LIBXML_PATTERN_ENABLED)
! 16851: int mem_base;
! 16852: int ret_val;
! 16853: xmlPatternPtr comp; /* the precompiled pattern */
! 16854: int n_comp;
! 16855:
! 16856: for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
! 16857: mem_base = xmlMemBlocks();
! 16858: comp = gen_xmlPatternPtr(n_comp, 0);
! 16859:
! 16860: ret_val = xmlPatternMaxDepth(comp);
! 16861: desret_int(ret_val);
! 16862: call_tests++;
! 16863: des_xmlPatternPtr(n_comp, comp, 0);
! 16864: xmlResetLastError();
! 16865: if (mem_base != xmlMemBlocks()) {
! 16866: printf("Leak of %d blocks found in xmlPatternMaxDepth",
! 16867: xmlMemBlocks() - mem_base);
! 16868: test_ret++;
! 16869: printf(" %d", n_comp);
! 16870: printf("\n");
! 16871: }
! 16872: }
! 16873: function_tests++;
! 16874: #endif
! 16875:
! 16876: return(test_ret);
! 16877: }
! 16878:
! 16879:
! 16880: static int
! 16881: test_xmlPatternMinDepth(void) {
! 16882: int test_ret = 0;
! 16883:
! 16884: #if defined(LIBXML_PATTERN_ENABLED)
! 16885: int mem_base;
! 16886: int ret_val;
! 16887: xmlPatternPtr comp; /* the precompiled pattern */
! 16888: int n_comp;
! 16889:
! 16890: for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
! 16891: mem_base = xmlMemBlocks();
! 16892: comp = gen_xmlPatternPtr(n_comp, 0);
! 16893:
! 16894: ret_val = xmlPatternMinDepth(comp);
! 16895: desret_int(ret_val);
! 16896: call_tests++;
! 16897: des_xmlPatternPtr(n_comp, comp, 0);
! 16898: xmlResetLastError();
! 16899: if (mem_base != xmlMemBlocks()) {
! 16900: printf("Leak of %d blocks found in xmlPatternMinDepth",
! 16901: xmlMemBlocks() - mem_base);
! 16902: test_ret++;
! 16903: printf(" %d", n_comp);
! 16904: printf("\n");
! 16905: }
! 16906: }
! 16907: function_tests++;
! 16908: #endif
! 16909:
! 16910: return(test_ret);
! 16911: }
! 16912:
! 16913:
! 16914: static int
! 16915: test_xmlPatternStreamable(void) {
! 16916: int test_ret = 0;
! 16917:
! 16918: #if defined(LIBXML_PATTERN_ENABLED)
! 16919: int mem_base;
! 16920: int ret_val;
! 16921: xmlPatternPtr comp; /* the precompiled pattern */
! 16922: int n_comp;
! 16923:
! 16924: for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
! 16925: mem_base = xmlMemBlocks();
! 16926: comp = gen_xmlPatternPtr(n_comp, 0);
! 16927:
! 16928: ret_val = xmlPatternStreamable(comp);
! 16929: desret_int(ret_val);
! 16930: call_tests++;
! 16931: des_xmlPatternPtr(n_comp, comp, 0);
! 16932: xmlResetLastError();
! 16933: if (mem_base != xmlMemBlocks()) {
! 16934: printf("Leak of %d blocks found in xmlPatternStreamable",
! 16935: xmlMemBlocks() - mem_base);
! 16936: test_ret++;
! 16937: printf(" %d", n_comp);
! 16938: printf("\n");
! 16939: }
! 16940: }
! 16941: function_tests++;
! 16942: #endif
! 16943:
! 16944: return(test_ret);
! 16945: }
! 16946:
! 16947:
! 16948: static int
! 16949: test_xmlPatterncompile(void) {
! 16950: int test_ret = 0;
! 16951:
! 16952:
! 16953: /* missing type support */
! 16954: return(test_ret);
! 16955: }
! 16956:
! 16957: #ifdef LIBXML_PATTERN_ENABLED
! 16958:
! 16959: #define gen_nb_xmlStreamCtxtPtr 1
! 16960: static xmlStreamCtxtPtr gen_xmlStreamCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 16961: return(NULL);
! 16962: }
! 16963: static void des_xmlStreamCtxtPtr(int no ATTRIBUTE_UNUSED, xmlStreamCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 16964: }
! 16965: #endif
! 16966:
! 16967:
! 16968: static int
! 16969: test_xmlStreamPop(void) {
! 16970: int test_ret = 0;
! 16971:
! 16972: #if defined(LIBXML_PATTERN_ENABLED)
! 16973: int mem_base;
! 16974: int ret_val;
! 16975: xmlStreamCtxtPtr stream; /* the stream context */
! 16976: int n_stream;
! 16977:
! 16978: for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
! 16979: mem_base = xmlMemBlocks();
! 16980: stream = gen_xmlStreamCtxtPtr(n_stream, 0);
! 16981:
! 16982: ret_val = xmlStreamPop(stream);
! 16983: desret_int(ret_val);
! 16984: call_tests++;
! 16985: des_xmlStreamCtxtPtr(n_stream, stream, 0);
! 16986: xmlResetLastError();
! 16987: if (mem_base != xmlMemBlocks()) {
! 16988: printf("Leak of %d blocks found in xmlStreamPop",
! 16989: xmlMemBlocks() - mem_base);
! 16990: test_ret++;
! 16991: printf(" %d", n_stream);
! 16992: printf("\n");
! 16993: }
! 16994: }
! 16995: function_tests++;
! 16996: #endif
! 16997:
! 16998: return(test_ret);
! 16999: }
! 17000:
! 17001:
! 17002: static int
! 17003: test_xmlStreamPush(void) {
! 17004: int test_ret = 0;
! 17005:
! 17006: #if defined(LIBXML_PATTERN_ENABLED)
! 17007: int mem_base;
! 17008: int ret_val;
! 17009: xmlStreamCtxtPtr stream; /* the stream context */
! 17010: int n_stream;
! 17011: xmlChar * name; /* the current name */
! 17012: int n_name;
! 17013: xmlChar * ns; /* the namespace name */
! 17014: int n_ns;
! 17015:
! 17016: for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
! 17017: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 17018: for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
! 17019: mem_base = xmlMemBlocks();
! 17020: stream = gen_xmlStreamCtxtPtr(n_stream, 0);
! 17021: name = gen_const_xmlChar_ptr(n_name, 1);
! 17022: ns = gen_const_xmlChar_ptr(n_ns, 2);
! 17023:
! 17024: ret_val = xmlStreamPush(stream, (const xmlChar *)name, (const xmlChar *)ns);
! 17025: desret_int(ret_val);
! 17026: call_tests++;
! 17027: des_xmlStreamCtxtPtr(n_stream, stream, 0);
! 17028: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 17029: des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 2);
! 17030: xmlResetLastError();
! 17031: if (mem_base != xmlMemBlocks()) {
! 17032: printf("Leak of %d blocks found in xmlStreamPush",
! 17033: xmlMemBlocks() - mem_base);
! 17034: test_ret++;
! 17035: printf(" %d", n_stream);
! 17036: printf(" %d", n_name);
! 17037: printf(" %d", n_ns);
! 17038: printf("\n");
! 17039: }
! 17040: }
! 17041: }
! 17042: }
! 17043: function_tests++;
! 17044: #endif
! 17045:
! 17046: return(test_ret);
! 17047: }
! 17048:
! 17049:
! 17050: static int
! 17051: test_xmlStreamPushAttr(void) {
! 17052: int test_ret = 0;
! 17053:
! 17054: #if defined(LIBXML_PATTERN_ENABLED)
! 17055: int mem_base;
! 17056: int ret_val;
! 17057: xmlStreamCtxtPtr stream; /* the stream context */
! 17058: int n_stream;
! 17059: xmlChar * name; /* the current name */
! 17060: int n_name;
! 17061: xmlChar * ns; /* the namespace name */
! 17062: int n_ns;
! 17063:
! 17064: for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
! 17065: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 17066: for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
! 17067: mem_base = xmlMemBlocks();
! 17068: stream = gen_xmlStreamCtxtPtr(n_stream, 0);
! 17069: name = gen_const_xmlChar_ptr(n_name, 1);
! 17070: ns = gen_const_xmlChar_ptr(n_ns, 2);
! 17071:
! 17072: ret_val = xmlStreamPushAttr(stream, (const xmlChar *)name, (const xmlChar *)ns);
! 17073: desret_int(ret_val);
! 17074: call_tests++;
! 17075: des_xmlStreamCtxtPtr(n_stream, stream, 0);
! 17076: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 17077: des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 2);
! 17078: xmlResetLastError();
! 17079: if (mem_base != xmlMemBlocks()) {
! 17080: printf("Leak of %d blocks found in xmlStreamPushAttr",
! 17081: xmlMemBlocks() - mem_base);
! 17082: test_ret++;
! 17083: printf(" %d", n_stream);
! 17084: printf(" %d", n_name);
! 17085: printf(" %d", n_ns);
! 17086: printf("\n");
! 17087: }
! 17088: }
! 17089: }
! 17090: }
! 17091: function_tests++;
! 17092: #endif
! 17093:
! 17094: return(test_ret);
! 17095: }
! 17096:
! 17097:
! 17098: static int
! 17099: test_xmlStreamPushNode(void) {
! 17100: int test_ret = 0;
! 17101:
! 17102: #if defined(LIBXML_PATTERN_ENABLED)
! 17103: int mem_base;
! 17104: int ret_val;
! 17105: xmlStreamCtxtPtr stream; /* the stream context */
! 17106: int n_stream;
! 17107: xmlChar * name; /* the current name */
! 17108: int n_name;
! 17109: xmlChar * ns; /* the namespace name */
! 17110: int n_ns;
! 17111: int nodeType; /* the type of the node being pushed */
! 17112: int n_nodeType;
! 17113:
! 17114: for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
! 17115: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 17116: for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
! 17117: for (n_nodeType = 0;n_nodeType < gen_nb_int;n_nodeType++) {
! 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: nodeType = gen_int(n_nodeType, 3);
! 17123:
! 17124: ret_val = xmlStreamPushNode(stream, (const xmlChar *)name, (const xmlChar *)ns, nodeType);
! 17125: desret_int(ret_val);
! 17126: call_tests++;
! 17127: des_xmlStreamCtxtPtr(n_stream, stream, 0);
! 17128: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 17129: des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 2);
! 17130: des_int(n_nodeType, nodeType, 3);
! 17131: xmlResetLastError();
! 17132: if (mem_base != xmlMemBlocks()) {
! 17133: printf("Leak of %d blocks found in xmlStreamPushNode",
! 17134: xmlMemBlocks() - mem_base);
! 17135: test_ret++;
! 17136: printf(" %d", n_stream);
! 17137: printf(" %d", n_name);
! 17138: printf(" %d", n_ns);
! 17139: printf(" %d", n_nodeType);
! 17140: printf("\n");
! 17141: }
! 17142: }
! 17143: }
! 17144: }
! 17145: }
! 17146: function_tests++;
! 17147: #endif
! 17148:
! 17149: return(test_ret);
! 17150: }
! 17151:
! 17152:
! 17153: static int
! 17154: test_xmlStreamWantsAnyNode(void) {
! 17155: int test_ret = 0;
! 17156:
! 17157: #if defined(LIBXML_PATTERN_ENABLED)
! 17158: int mem_base;
! 17159: int ret_val;
! 17160: xmlStreamCtxtPtr streamCtxt; /* the stream context */
! 17161: int n_streamCtxt;
! 17162:
! 17163: for (n_streamCtxt = 0;n_streamCtxt < gen_nb_xmlStreamCtxtPtr;n_streamCtxt++) {
! 17164: mem_base = xmlMemBlocks();
! 17165: streamCtxt = gen_xmlStreamCtxtPtr(n_streamCtxt, 0);
! 17166:
! 17167: ret_val = xmlStreamWantsAnyNode(streamCtxt);
! 17168: desret_int(ret_val);
! 17169: call_tests++;
! 17170: des_xmlStreamCtxtPtr(n_streamCtxt, streamCtxt, 0);
! 17171: xmlResetLastError();
! 17172: if (mem_base != xmlMemBlocks()) {
! 17173: printf("Leak of %d blocks found in xmlStreamWantsAnyNode",
! 17174: xmlMemBlocks() - mem_base);
! 17175: test_ret++;
! 17176: printf(" %d", n_streamCtxt);
! 17177: printf("\n");
! 17178: }
! 17179: }
! 17180: function_tests++;
! 17181: #endif
! 17182:
! 17183: return(test_ret);
! 17184: }
! 17185:
! 17186: static int
! 17187: test_pattern(void) {
! 17188: int test_ret = 0;
! 17189:
! 17190: if (quiet == 0) printf("Testing pattern : 10 of 15 functions ...\n");
! 17191: test_ret += test_xmlPatternFromRoot();
! 17192: test_ret += test_xmlPatternGetStreamCtxt();
! 17193: test_ret += test_xmlPatternMatch();
! 17194: test_ret += test_xmlPatternMaxDepth();
! 17195: test_ret += test_xmlPatternMinDepth();
! 17196: test_ret += test_xmlPatternStreamable();
! 17197: test_ret += test_xmlPatterncompile();
! 17198: test_ret += test_xmlStreamPop();
! 17199: test_ret += test_xmlStreamPush();
! 17200: test_ret += test_xmlStreamPushAttr();
! 17201: test_ret += test_xmlStreamPushNode();
! 17202: test_ret += test_xmlStreamWantsAnyNode();
! 17203:
! 17204: if (test_ret != 0)
! 17205: printf("Module pattern: %d errors\n", test_ret);
! 17206: return(test_ret);
! 17207: }
! 17208: #ifdef LIBXML_SCHEMAS_ENABLED
! 17209:
! 17210: #define gen_nb_xmlRelaxNGPtr 1
! 17211: static xmlRelaxNGPtr gen_xmlRelaxNGPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 17212: return(NULL);
! 17213: }
! 17214: static void des_xmlRelaxNGPtr(int no ATTRIBUTE_UNUSED, xmlRelaxNGPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 17215: }
! 17216: #endif
! 17217:
! 17218:
! 17219: static int
! 17220: test_xmlRelaxNGDump(void) {
! 17221: int test_ret = 0;
! 17222:
! 17223: #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 17224: int mem_base;
! 17225: FILE * output; /* the file output */
! 17226: int n_output;
! 17227: xmlRelaxNGPtr schema; /* a schema structure */
! 17228: int n_schema;
! 17229:
! 17230: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
! 17231: for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) {
! 17232: mem_base = xmlMemBlocks();
! 17233: output = gen_FILE_ptr(n_output, 0);
! 17234: schema = gen_xmlRelaxNGPtr(n_schema, 1);
! 17235:
! 17236: xmlRelaxNGDump(output, schema);
! 17237: call_tests++;
! 17238: des_FILE_ptr(n_output, output, 0);
! 17239: des_xmlRelaxNGPtr(n_schema, schema, 1);
! 17240: xmlResetLastError();
! 17241: if (mem_base != xmlMemBlocks()) {
! 17242: printf("Leak of %d blocks found in xmlRelaxNGDump",
! 17243: xmlMemBlocks() - mem_base);
! 17244: test_ret++;
! 17245: printf(" %d", n_output);
! 17246: printf(" %d", n_schema);
! 17247: printf("\n");
! 17248: }
! 17249: }
! 17250: }
! 17251: function_tests++;
! 17252: #endif
! 17253:
! 17254: return(test_ret);
! 17255: }
! 17256:
! 17257:
! 17258: static int
! 17259: test_xmlRelaxNGDumpTree(void) {
! 17260: int test_ret = 0;
! 17261:
! 17262: #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 17263: int mem_base;
! 17264: FILE * output; /* the file output */
! 17265: int n_output;
! 17266: xmlRelaxNGPtr schema; /* a schema structure */
! 17267: int n_schema;
! 17268:
! 17269: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
! 17270: for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) {
! 17271: mem_base = xmlMemBlocks();
! 17272: output = gen_FILE_ptr(n_output, 0);
! 17273: schema = gen_xmlRelaxNGPtr(n_schema, 1);
! 17274:
! 17275: xmlRelaxNGDumpTree(output, schema);
! 17276: call_tests++;
! 17277: des_FILE_ptr(n_output, output, 0);
! 17278: des_xmlRelaxNGPtr(n_schema, schema, 1);
! 17279: xmlResetLastError();
! 17280: if (mem_base != xmlMemBlocks()) {
! 17281: printf("Leak of %d blocks found in xmlRelaxNGDumpTree",
! 17282: xmlMemBlocks() - mem_base);
! 17283: test_ret++;
! 17284: printf(" %d", n_output);
! 17285: printf(" %d", n_schema);
! 17286: printf("\n");
! 17287: }
! 17288: }
! 17289: }
! 17290: function_tests++;
! 17291: #endif
! 17292:
! 17293: return(test_ret);
! 17294: }
! 17295:
! 17296: #ifdef LIBXML_SCHEMAS_ENABLED
! 17297:
! 17298: #define gen_nb_xmlRelaxNGParserCtxtPtr 1
! 17299: static xmlRelaxNGParserCtxtPtr gen_xmlRelaxNGParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 17300: return(NULL);
! 17301: }
! 17302: static void des_xmlRelaxNGParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlRelaxNGParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 17303: }
! 17304: #endif
! 17305:
! 17306: #ifdef LIBXML_SCHEMAS_ENABLED
! 17307:
! 17308: #define gen_nb_xmlRelaxNGValidityErrorFunc_ptr 1
! 17309: static xmlRelaxNGValidityErrorFunc * gen_xmlRelaxNGValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 17310: return(NULL);
! 17311: }
! 17312: static void des_xmlRelaxNGValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlRelaxNGValidityErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 17313: }
! 17314: #endif
! 17315:
! 17316: #ifdef LIBXML_SCHEMAS_ENABLED
! 17317:
! 17318: #define gen_nb_xmlRelaxNGValidityWarningFunc_ptr 1
! 17319: static xmlRelaxNGValidityWarningFunc * gen_xmlRelaxNGValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 17320: return(NULL);
! 17321: }
! 17322: static void des_xmlRelaxNGValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, xmlRelaxNGValidityWarningFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 17323: }
! 17324: #endif
! 17325:
! 17326:
! 17327: static int
! 17328: test_xmlRelaxNGGetParserErrors(void) {
! 17329: int test_ret = 0;
! 17330:
! 17331: #if defined(LIBXML_SCHEMAS_ENABLED)
! 17332: int mem_base;
! 17333: int ret_val;
! 17334: xmlRelaxNGParserCtxtPtr ctxt; /* a Relax-NG validation context */
! 17335: int n_ctxt;
! 17336: xmlRelaxNGValidityErrorFunc * err; /* the error callback result */
! 17337: int n_err;
! 17338: xmlRelaxNGValidityWarningFunc * warn; /* the warning callback result */
! 17339: int n_warn;
! 17340: void ** ctx; /* contextual data for the callbacks result */
! 17341: int n_ctx;
! 17342:
! 17343: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGParserCtxtPtr;n_ctxt++) {
! 17344: for (n_err = 0;n_err < gen_nb_xmlRelaxNGValidityErrorFunc_ptr;n_err++) {
! 17345: for (n_warn = 0;n_warn < gen_nb_xmlRelaxNGValidityWarningFunc_ptr;n_warn++) {
! 17346: for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
! 17347: mem_base = xmlMemBlocks();
! 17348: ctxt = gen_xmlRelaxNGParserCtxtPtr(n_ctxt, 0);
! 17349: err = gen_xmlRelaxNGValidityErrorFunc_ptr(n_err, 1);
! 17350: warn = gen_xmlRelaxNGValidityWarningFunc_ptr(n_warn, 2);
! 17351: ctx = gen_void_ptr_ptr(n_ctx, 3);
! 17352:
! 17353: ret_val = xmlRelaxNGGetParserErrors(ctxt, err, warn, ctx);
! 17354: desret_int(ret_val);
! 17355: call_tests++;
! 17356: des_xmlRelaxNGParserCtxtPtr(n_ctxt, ctxt, 0);
! 17357: des_xmlRelaxNGValidityErrorFunc_ptr(n_err, err, 1);
! 17358: des_xmlRelaxNGValidityWarningFunc_ptr(n_warn, warn, 2);
! 17359: des_void_ptr_ptr(n_ctx, ctx, 3);
! 17360: xmlResetLastError();
! 17361: if (mem_base != xmlMemBlocks()) {
! 17362: printf("Leak of %d blocks found in xmlRelaxNGGetParserErrors",
! 17363: xmlMemBlocks() - mem_base);
! 17364: test_ret++;
! 17365: printf(" %d", n_ctxt);
! 17366: printf(" %d", n_err);
! 17367: printf(" %d", n_warn);
! 17368: printf(" %d", n_ctx);
! 17369: printf("\n");
! 17370: }
! 17371: }
! 17372: }
! 17373: }
! 17374: }
! 17375: function_tests++;
! 17376: #endif
! 17377:
! 17378: return(test_ret);
! 17379: }
! 17380:
! 17381: #ifdef LIBXML_SCHEMAS_ENABLED
! 17382:
! 17383: #define gen_nb_xmlRelaxNGValidCtxtPtr 1
! 17384: static xmlRelaxNGValidCtxtPtr gen_xmlRelaxNGValidCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 17385: return(NULL);
! 17386: }
! 17387: static void des_xmlRelaxNGValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlRelaxNGValidCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 17388: }
! 17389: #endif
! 17390:
! 17391:
! 17392: static int
! 17393: test_xmlRelaxNGGetValidErrors(void) {
! 17394: int test_ret = 0;
! 17395:
! 17396: #if defined(LIBXML_SCHEMAS_ENABLED)
! 17397: int mem_base;
! 17398: int ret_val;
! 17399: xmlRelaxNGValidCtxtPtr ctxt; /* a Relax-NG validation context */
! 17400: int n_ctxt;
! 17401: xmlRelaxNGValidityErrorFunc * err; /* the error function result */
! 17402: int n_err;
! 17403: xmlRelaxNGValidityWarningFunc * warn; /* the warning function result */
! 17404: int n_warn;
! 17405: void ** ctx; /* the functions context result */
! 17406: int n_ctx;
! 17407:
! 17408: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
! 17409: for (n_err = 0;n_err < gen_nb_xmlRelaxNGValidityErrorFunc_ptr;n_err++) {
! 17410: for (n_warn = 0;n_warn < gen_nb_xmlRelaxNGValidityWarningFunc_ptr;n_warn++) {
! 17411: for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
! 17412: mem_base = xmlMemBlocks();
! 17413: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
! 17414: err = gen_xmlRelaxNGValidityErrorFunc_ptr(n_err, 1);
! 17415: warn = gen_xmlRelaxNGValidityWarningFunc_ptr(n_warn, 2);
! 17416: ctx = gen_void_ptr_ptr(n_ctx, 3);
! 17417:
! 17418: ret_val = xmlRelaxNGGetValidErrors(ctxt, err, warn, ctx);
! 17419: desret_int(ret_val);
! 17420: call_tests++;
! 17421: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
! 17422: des_xmlRelaxNGValidityErrorFunc_ptr(n_err, err, 1);
! 17423: des_xmlRelaxNGValidityWarningFunc_ptr(n_warn, warn, 2);
! 17424: des_void_ptr_ptr(n_ctx, ctx, 3);
! 17425: xmlResetLastError();
! 17426: if (mem_base != xmlMemBlocks()) {
! 17427: printf("Leak of %d blocks found in xmlRelaxNGGetValidErrors",
! 17428: xmlMemBlocks() - mem_base);
! 17429: test_ret++;
! 17430: printf(" %d", n_ctxt);
! 17431: printf(" %d", n_err);
! 17432: printf(" %d", n_warn);
! 17433: printf(" %d", n_ctx);
! 17434: printf("\n");
! 17435: }
! 17436: }
! 17437: }
! 17438: }
! 17439: }
! 17440: function_tests++;
! 17441: #endif
! 17442:
! 17443: return(test_ret);
! 17444: }
! 17445:
! 17446:
! 17447: static int
! 17448: test_xmlRelaxNGInitTypes(void) {
! 17449: int test_ret = 0;
! 17450:
! 17451: #if defined(LIBXML_SCHEMAS_ENABLED)
! 17452: int mem_base;
! 17453: int ret_val;
! 17454:
! 17455: mem_base = xmlMemBlocks();
! 17456:
! 17457: ret_val = xmlRelaxNGInitTypes();
! 17458: desret_int(ret_val);
! 17459: call_tests++;
! 17460: xmlResetLastError();
! 17461: if (mem_base != xmlMemBlocks()) {
! 17462: printf("Leak of %d blocks found in xmlRelaxNGInitTypes",
! 17463: xmlMemBlocks() - mem_base);
! 17464: test_ret++;
! 17465: printf("\n");
! 17466: }
! 17467: function_tests++;
! 17468: #endif
! 17469:
! 17470: return(test_ret);
! 17471: }
! 17472:
! 17473:
! 17474: static int
! 17475: test_xmlRelaxNGNewDocParserCtxt(void) {
! 17476: int test_ret = 0;
! 17477:
! 17478: #if defined(LIBXML_SCHEMAS_ENABLED)
! 17479: int mem_base;
! 17480: xmlRelaxNGParserCtxtPtr ret_val;
! 17481: xmlDocPtr doc; /* a preparsed document tree */
! 17482: int n_doc;
! 17483:
! 17484: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 17485: mem_base = xmlMemBlocks();
! 17486: doc = gen_xmlDocPtr(n_doc, 0);
! 17487:
! 17488: ret_val = xmlRelaxNGNewDocParserCtxt(doc);
! 17489: desret_xmlRelaxNGParserCtxtPtr(ret_val);
! 17490: call_tests++;
! 17491: des_xmlDocPtr(n_doc, doc, 0);
! 17492: xmlResetLastError();
! 17493: if (mem_base != xmlMemBlocks()) {
! 17494: printf("Leak of %d blocks found in xmlRelaxNGNewDocParserCtxt",
! 17495: xmlMemBlocks() - mem_base);
! 17496: test_ret++;
! 17497: printf(" %d", n_doc);
! 17498: printf("\n");
! 17499: }
! 17500: }
! 17501: function_tests++;
! 17502: #endif
! 17503:
! 17504: return(test_ret);
! 17505: }
! 17506:
! 17507:
! 17508: static int
! 17509: test_xmlRelaxNGNewMemParserCtxt(void) {
! 17510: int test_ret = 0;
! 17511:
! 17512: #if defined(LIBXML_SCHEMAS_ENABLED)
! 17513: int mem_base;
! 17514: xmlRelaxNGParserCtxtPtr ret_val;
! 17515: char * buffer; /* a pointer to a char array containing the schemas */
! 17516: int n_buffer;
! 17517: int size; /* the size of the array */
! 17518: int n_size;
! 17519:
! 17520: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
! 17521: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 17522: mem_base = xmlMemBlocks();
! 17523: buffer = gen_const_char_ptr(n_buffer, 0);
! 17524: size = gen_int(n_size, 1);
! 17525:
! 17526: ret_val = xmlRelaxNGNewMemParserCtxt((const char *)buffer, size);
! 17527: desret_xmlRelaxNGParserCtxtPtr(ret_val);
! 17528: call_tests++;
! 17529: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
! 17530: des_int(n_size, size, 1);
! 17531: xmlResetLastError();
! 17532: if (mem_base != xmlMemBlocks()) {
! 17533: printf("Leak of %d blocks found in xmlRelaxNGNewMemParserCtxt",
! 17534: xmlMemBlocks() - mem_base);
! 17535: test_ret++;
! 17536: printf(" %d", n_buffer);
! 17537: printf(" %d", n_size);
! 17538: printf("\n");
! 17539: }
! 17540: }
! 17541: }
! 17542: function_tests++;
! 17543: #endif
! 17544:
! 17545: return(test_ret);
! 17546: }
! 17547:
! 17548:
! 17549: static int
! 17550: test_xmlRelaxNGNewParserCtxt(void) {
! 17551: int test_ret = 0;
! 17552:
! 17553: #if defined(LIBXML_SCHEMAS_ENABLED)
! 17554: int mem_base;
! 17555: xmlRelaxNGParserCtxtPtr ret_val;
! 17556: char * URL; /* the location of the schema */
! 17557: int n_URL;
! 17558:
! 17559: for (n_URL = 0;n_URL < gen_nb_const_char_ptr;n_URL++) {
! 17560: mem_base = xmlMemBlocks();
! 17561: URL = gen_const_char_ptr(n_URL, 0);
! 17562:
! 17563: ret_val = xmlRelaxNGNewParserCtxt((const char *)URL);
! 17564: desret_xmlRelaxNGParserCtxtPtr(ret_val);
! 17565: call_tests++;
! 17566: des_const_char_ptr(n_URL, (const char *)URL, 0);
! 17567: xmlResetLastError();
! 17568: if (mem_base != xmlMemBlocks()) {
! 17569: printf("Leak of %d blocks found in xmlRelaxNGNewParserCtxt",
! 17570: xmlMemBlocks() - mem_base);
! 17571: test_ret++;
! 17572: printf(" %d", n_URL);
! 17573: printf("\n");
! 17574: }
! 17575: }
! 17576: function_tests++;
! 17577: #endif
! 17578:
! 17579: return(test_ret);
! 17580: }
! 17581:
! 17582:
! 17583: static int
! 17584: test_xmlRelaxNGNewValidCtxt(void) {
! 17585: int test_ret = 0;
! 17586:
! 17587:
! 17588: /* missing type support */
! 17589: return(test_ret);
! 17590: }
! 17591:
! 17592:
! 17593: static int
! 17594: test_xmlRelaxNGParse(void) {
! 17595: int test_ret = 0;
! 17596:
! 17597:
! 17598: /* missing type support */
! 17599: return(test_ret);
! 17600: }
! 17601:
! 17602:
! 17603: static int
! 17604: test_xmlRelaxNGSetParserErrors(void) {
! 17605: int test_ret = 0;
! 17606:
! 17607:
! 17608: /* missing type support */
! 17609: return(test_ret);
! 17610: }
! 17611:
! 17612:
! 17613: static int
! 17614: test_xmlRelaxNGSetParserStructuredErrors(void) {
! 17615: int test_ret = 0;
! 17616:
! 17617:
! 17618: /* missing type support */
! 17619: return(test_ret);
! 17620: }
! 17621:
! 17622:
! 17623: static int
! 17624: test_xmlRelaxNGSetValidErrors(void) {
! 17625: int test_ret = 0;
! 17626:
! 17627:
! 17628: /* missing type support */
! 17629: return(test_ret);
! 17630: }
! 17631:
! 17632:
! 17633: static int
! 17634: test_xmlRelaxNGSetValidStructuredErrors(void) {
! 17635: int test_ret = 0;
! 17636:
! 17637:
! 17638: /* missing type support */
! 17639: return(test_ret);
! 17640: }
! 17641:
! 17642:
! 17643: static int
! 17644: test_xmlRelaxNGValidateDoc(void) {
! 17645: int test_ret = 0;
! 17646:
! 17647: #if defined(LIBXML_SCHEMAS_ENABLED)
! 17648: int mem_base;
! 17649: int ret_val;
! 17650: xmlRelaxNGValidCtxtPtr ctxt; /* a Relax-NG validation context */
! 17651: int n_ctxt;
! 17652: xmlDocPtr doc; /* a parsed document tree */
! 17653: int n_doc;
! 17654:
! 17655: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
! 17656: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 17657: mem_base = xmlMemBlocks();
! 17658: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
! 17659: doc = gen_xmlDocPtr(n_doc, 1);
! 17660:
! 17661: ret_val = xmlRelaxNGValidateDoc(ctxt, doc);
! 17662: desret_int(ret_val);
! 17663: call_tests++;
! 17664: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
! 17665: des_xmlDocPtr(n_doc, doc, 1);
! 17666: xmlResetLastError();
! 17667: if (mem_base != xmlMemBlocks()) {
! 17668: printf("Leak of %d blocks found in xmlRelaxNGValidateDoc",
! 17669: xmlMemBlocks() - mem_base);
! 17670: test_ret++;
! 17671: printf(" %d", n_ctxt);
! 17672: printf(" %d", n_doc);
! 17673: printf("\n");
! 17674: }
! 17675: }
! 17676: }
! 17677: function_tests++;
! 17678: #endif
! 17679:
! 17680: return(test_ret);
! 17681: }
! 17682:
! 17683:
! 17684: static int
! 17685: test_xmlRelaxNGValidateFullElement(void) {
! 17686: int test_ret = 0;
! 17687:
! 17688: #if defined(LIBXML_SCHEMAS_ENABLED)
! 17689: int mem_base;
! 17690: int ret_val;
! 17691: xmlRelaxNGValidCtxtPtr ctxt; /* the validation context */
! 17692: int n_ctxt;
! 17693: xmlDocPtr doc; /* a document instance */
! 17694: int n_doc;
! 17695: xmlNodePtr elem; /* an element instance */
! 17696: int n_elem;
! 17697:
! 17698: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
! 17699: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 17700: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
! 17701: mem_base = xmlMemBlocks();
! 17702: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
! 17703: doc = gen_xmlDocPtr(n_doc, 1);
! 17704: elem = gen_xmlNodePtr(n_elem, 2);
! 17705:
! 17706: ret_val = xmlRelaxNGValidateFullElement(ctxt, doc, elem);
! 17707: desret_int(ret_val);
! 17708: call_tests++;
! 17709: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
! 17710: des_xmlDocPtr(n_doc, doc, 1);
! 17711: des_xmlNodePtr(n_elem, elem, 2);
! 17712: xmlResetLastError();
! 17713: if (mem_base != xmlMemBlocks()) {
! 17714: printf("Leak of %d blocks found in xmlRelaxNGValidateFullElement",
! 17715: xmlMemBlocks() - mem_base);
! 17716: test_ret++;
! 17717: printf(" %d", n_ctxt);
! 17718: printf(" %d", n_doc);
! 17719: printf(" %d", n_elem);
! 17720: printf("\n");
! 17721: }
! 17722: }
! 17723: }
! 17724: }
! 17725: function_tests++;
! 17726: #endif
! 17727:
! 17728: return(test_ret);
! 17729: }
! 17730:
! 17731:
! 17732: static int
! 17733: test_xmlRelaxNGValidatePopElement(void) {
! 17734: int test_ret = 0;
! 17735:
! 17736: #if defined(LIBXML_SCHEMAS_ENABLED)
! 17737: int mem_base;
! 17738: int ret_val;
! 17739: xmlRelaxNGValidCtxtPtr ctxt; /* the RelaxNG validation context */
! 17740: int n_ctxt;
! 17741: xmlDocPtr doc; /* a document instance */
! 17742: int n_doc;
! 17743: xmlNodePtr elem; /* an element instance */
! 17744: int n_elem;
! 17745:
! 17746: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
! 17747: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 17748: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
! 17749: mem_base = xmlMemBlocks();
! 17750: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
! 17751: doc = gen_xmlDocPtr(n_doc, 1);
! 17752: elem = gen_xmlNodePtr(n_elem, 2);
! 17753:
! 17754: ret_val = xmlRelaxNGValidatePopElement(ctxt, doc, elem);
! 17755: desret_int(ret_val);
! 17756: call_tests++;
! 17757: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
! 17758: des_xmlDocPtr(n_doc, doc, 1);
! 17759: des_xmlNodePtr(n_elem, elem, 2);
! 17760: xmlResetLastError();
! 17761: if (mem_base != xmlMemBlocks()) {
! 17762: printf("Leak of %d blocks found in xmlRelaxNGValidatePopElement",
! 17763: xmlMemBlocks() - mem_base);
! 17764: test_ret++;
! 17765: printf(" %d", n_ctxt);
! 17766: printf(" %d", n_doc);
! 17767: printf(" %d", n_elem);
! 17768: printf("\n");
! 17769: }
! 17770: }
! 17771: }
! 17772: }
! 17773: function_tests++;
! 17774: #endif
! 17775:
! 17776: return(test_ret);
! 17777: }
! 17778:
! 17779:
! 17780: static int
! 17781: test_xmlRelaxNGValidatePushCData(void) {
! 17782: int test_ret = 0;
! 17783:
! 17784: #if defined(LIBXML_SCHEMAS_ENABLED)
! 17785: int mem_base;
! 17786: int ret_val;
! 17787: xmlRelaxNGValidCtxtPtr ctxt; /* the RelaxNG validation context */
! 17788: int n_ctxt;
! 17789: xmlChar * data; /* some character data read */
! 17790: int n_data;
! 17791: int len; /* the lenght of the data */
! 17792: int n_len;
! 17793:
! 17794: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
! 17795: for (n_data = 0;n_data < gen_nb_const_xmlChar_ptr;n_data++) {
! 17796: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 17797: mem_base = xmlMemBlocks();
! 17798: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
! 17799: data = gen_const_xmlChar_ptr(n_data, 1);
! 17800: len = gen_int(n_len, 2);
! 17801:
! 17802: ret_val = xmlRelaxNGValidatePushCData(ctxt, (const xmlChar *)data, len);
! 17803: desret_int(ret_val);
! 17804: call_tests++;
! 17805: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
! 17806: des_const_xmlChar_ptr(n_data, (const xmlChar *)data, 1);
! 17807: des_int(n_len, len, 2);
! 17808: xmlResetLastError();
! 17809: if (mem_base != xmlMemBlocks()) {
! 17810: printf("Leak of %d blocks found in xmlRelaxNGValidatePushCData",
! 17811: xmlMemBlocks() - mem_base);
! 17812: test_ret++;
! 17813: printf(" %d", n_ctxt);
! 17814: printf(" %d", n_data);
! 17815: printf(" %d", n_len);
! 17816: printf("\n");
! 17817: }
! 17818: }
! 17819: }
! 17820: }
! 17821: function_tests++;
! 17822: #endif
! 17823:
! 17824: return(test_ret);
! 17825: }
! 17826:
! 17827:
! 17828: static int
! 17829: test_xmlRelaxNGValidatePushElement(void) {
! 17830: int test_ret = 0;
! 17831:
! 17832: #if defined(LIBXML_SCHEMAS_ENABLED)
! 17833: int mem_base;
! 17834: int ret_val;
! 17835: xmlRelaxNGValidCtxtPtr ctxt; /* the validation context */
! 17836: int n_ctxt;
! 17837: xmlDocPtr doc; /* a document instance */
! 17838: int n_doc;
! 17839: xmlNodePtr elem; /* an element instance */
! 17840: int n_elem;
! 17841:
! 17842: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
! 17843: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 17844: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
! 17845: mem_base = xmlMemBlocks();
! 17846: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
! 17847: doc = gen_xmlDocPtr(n_doc, 1);
! 17848: elem = gen_xmlNodePtr(n_elem, 2);
! 17849:
! 17850: ret_val = xmlRelaxNGValidatePushElement(ctxt, doc, elem);
! 17851: desret_int(ret_val);
! 17852: call_tests++;
! 17853: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
! 17854: des_xmlDocPtr(n_doc, doc, 1);
! 17855: des_xmlNodePtr(n_elem, elem, 2);
! 17856: xmlResetLastError();
! 17857: if (mem_base != xmlMemBlocks()) {
! 17858: printf("Leak of %d blocks found in xmlRelaxNGValidatePushElement",
! 17859: xmlMemBlocks() - mem_base);
! 17860: test_ret++;
! 17861: printf(" %d", n_ctxt);
! 17862: printf(" %d", n_doc);
! 17863: printf(" %d", n_elem);
! 17864: printf("\n");
! 17865: }
! 17866: }
! 17867: }
! 17868: }
! 17869: function_tests++;
! 17870: #endif
! 17871:
! 17872: return(test_ret);
! 17873: }
! 17874:
! 17875:
! 17876: static int
! 17877: test_xmlRelaxParserSetFlag(void) {
! 17878: int test_ret = 0;
! 17879:
! 17880: #if defined(LIBXML_SCHEMAS_ENABLED)
! 17881: int mem_base;
! 17882: int ret_val;
! 17883: xmlRelaxNGParserCtxtPtr ctxt; /* a RelaxNG parser context */
! 17884: int n_ctxt;
! 17885: int flags; /* a set of flags values */
! 17886: int n_flags;
! 17887:
! 17888: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGParserCtxtPtr;n_ctxt++) {
! 17889: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
! 17890: mem_base = xmlMemBlocks();
! 17891: ctxt = gen_xmlRelaxNGParserCtxtPtr(n_ctxt, 0);
! 17892: flags = gen_int(n_flags, 1);
! 17893:
! 17894: ret_val = xmlRelaxParserSetFlag(ctxt, flags);
! 17895: desret_int(ret_val);
! 17896: call_tests++;
! 17897: des_xmlRelaxNGParserCtxtPtr(n_ctxt, ctxt, 0);
! 17898: des_int(n_flags, flags, 1);
! 17899: xmlResetLastError();
! 17900: if (mem_base != xmlMemBlocks()) {
! 17901: printf("Leak of %d blocks found in xmlRelaxParserSetFlag",
! 17902: xmlMemBlocks() - mem_base);
! 17903: test_ret++;
! 17904: printf(" %d", n_ctxt);
! 17905: printf(" %d", n_flags);
! 17906: printf("\n");
! 17907: }
! 17908: }
! 17909: }
! 17910: function_tests++;
! 17911: #endif
! 17912:
! 17913: return(test_ret);
! 17914: }
! 17915:
! 17916: static int
! 17917: test_relaxng(void) {
! 17918: int test_ret = 0;
! 17919:
! 17920: if (quiet == 0) printf("Testing relaxng : 14 of 24 functions ...\n");
! 17921: test_ret += test_xmlRelaxNGDump();
! 17922: test_ret += test_xmlRelaxNGDumpTree();
! 17923: test_ret += test_xmlRelaxNGGetParserErrors();
! 17924: test_ret += test_xmlRelaxNGGetValidErrors();
! 17925: test_ret += test_xmlRelaxNGInitTypes();
! 17926: test_ret += test_xmlRelaxNGNewDocParserCtxt();
! 17927: test_ret += test_xmlRelaxNGNewMemParserCtxt();
! 17928: test_ret += test_xmlRelaxNGNewParserCtxt();
! 17929: test_ret += test_xmlRelaxNGNewValidCtxt();
! 17930: test_ret += test_xmlRelaxNGParse();
! 17931: test_ret += test_xmlRelaxNGSetParserErrors();
! 17932: test_ret += test_xmlRelaxNGSetParserStructuredErrors();
! 17933: test_ret += test_xmlRelaxNGSetValidErrors();
! 17934: test_ret += test_xmlRelaxNGSetValidStructuredErrors();
! 17935: test_ret += test_xmlRelaxNGValidateDoc();
! 17936: test_ret += test_xmlRelaxNGValidateFullElement();
! 17937: test_ret += test_xmlRelaxNGValidatePopElement();
! 17938: test_ret += test_xmlRelaxNGValidatePushCData();
! 17939: test_ret += test_xmlRelaxNGValidatePushElement();
! 17940: test_ret += test_xmlRelaxParserSetFlag();
! 17941:
! 17942: if (test_ret != 0)
! 17943: printf("Module relaxng: %d errors\n", test_ret);
! 17944: return(test_ret);
! 17945: }
! 17946: static int
! 17947: test_schemasInternals(void) {
! 17948: int test_ret = 0;
! 17949:
! 17950: if (quiet == 0) printf("Testing schemasInternals : 0 of 2 functions ...\n");
! 17951:
! 17952: if (test_ret != 0)
! 17953: printf("Module schemasInternals: %d errors\n", test_ret);
! 17954: return(test_ret);
! 17955: }
! 17956:
! 17957: static int
! 17958: test_xmlSchematronNewDocParserCtxt(void) {
! 17959: int test_ret = 0;
! 17960:
! 17961:
! 17962: /* missing type support */
! 17963: return(test_ret);
! 17964: }
! 17965:
! 17966:
! 17967: static int
! 17968: test_xmlSchematronNewMemParserCtxt(void) {
! 17969: int test_ret = 0;
! 17970:
! 17971:
! 17972: /* missing type support */
! 17973: return(test_ret);
! 17974: }
! 17975:
! 17976:
! 17977: static int
! 17978: test_xmlSchematronNewParserCtxt(void) {
! 17979: int test_ret = 0;
! 17980:
! 17981:
! 17982: /* missing type support */
! 17983: return(test_ret);
! 17984: }
! 17985:
! 17986: #ifdef LIBXML_SCHEMATRON_ENABLED
! 17987:
! 17988: #define gen_nb_xmlSchematronPtr 1
! 17989: static xmlSchematronPtr gen_xmlSchematronPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 17990: return(NULL);
! 17991: }
! 17992: static void des_xmlSchematronPtr(int no ATTRIBUTE_UNUSED, xmlSchematronPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 17993: }
! 17994: #endif
! 17995:
! 17996:
! 17997: static int
! 17998: test_xmlSchematronNewValidCtxt(void) {
! 17999: int test_ret = 0;
! 18000:
! 18001:
! 18002: /* missing type support */
! 18003: return(test_ret);
! 18004: }
! 18005:
! 18006: #ifdef LIBXML_SCHEMATRON_ENABLED
! 18007:
! 18008: #define gen_nb_xmlSchematronParserCtxtPtr 1
! 18009: static xmlSchematronParserCtxtPtr gen_xmlSchematronParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 18010: return(NULL);
! 18011: }
! 18012: static void des_xmlSchematronParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchematronParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 18013: }
! 18014: #endif
! 18015:
! 18016:
! 18017: static int
! 18018: test_xmlSchematronParse(void) {
! 18019: int test_ret = 0;
! 18020:
! 18021:
! 18022: /* missing type support */
! 18023: return(test_ret);
! 18024: }
! 18025:
! 18026: #ifdef LIBXML_SCHEMATRON_ENABLED
! 18027:
! 18028: #define gen_nb_xmlSchematronValidCtxtPtr 1
! 18029: static xmlSchematronValidCtxtPtr gen_xmlSchematronValidCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 18030: return(NULL);
! 18031: }
! 18032: static void des_xmlSchematronValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchematronValidCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 18033: }
! 18034: #endif
! 18035:
! 18036:
! 18037: static int
! 18038: test_xmlSchematronSetValidStructuredErrors(void) {
! 18039: int test_ret = 0;
! 18040:
! 18041:
! 18042: /* missing type support */
! 18043: return(test_ret);
! 18044: }
! 18045:
! 18046:
! 18047: static int
! 18048: test_xmlSchematronValidateDoc(void) {
! 18049: int test_ret = 0;
! 18050:
! 18051: #if defined(LIBXML_SCHEMATRON_ENABLED)
! 18052: int mem_base;
! 18053: int ret_val;
! 18054: xmlSchematronValidCtxtPtr ctxt; /* the schema validation context */
! 18055: int n_ctxt;
! 18056: xmlDocPtr instance; /* the document instace tree */
! 18057: int n_instance;
! 18058:
! 18059: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchematronValidCtxtPtr;n_ctxt++) {
! 18060: for (n_instance = 0;n_instance < gen_nb_xmlDocPtr;n_instance++) {
! 18061: mem_base = xmlMemBlocks();
! 18062: ctxt = gen_xmlSchematronValidCtxtPtr(n_ctxt, 0);
! 18063: instance = gen_xmlDocPtr(n_instance, 1);
! 18064:
! 18065: ret_val = xmlSchematronValidateDoc(ctxt, instance);
! 18066: desret_int(ret_val);
! 18067: call_tests++;
! 18068: des_xmlSchematronValidCtxtPtr(n_ctxt, ctxt, 0);
! 18069: des_xmlDocPtr(n_instance, instance, 1);
! 18070: xmlResetLastError();
! 18071: if (mem_base != xmlMemBlocks()) {
! 18072: printf("Leak of %d blocks found in xmlSchematronValidateDoc",
! 18073: xmlMemBlocks() - mem_base);
! 18074: test_ret++;
! 18075: printf(" %d", n_ctxt);
! 18076: printf(" %d", n_instance);
! 18077: printf("\n");
! 18078: }
! 18079: }
! 18080: }
! 18081: function_tests++;
! 18082: #endif
! 18083:
! 18084: return(test_ret);
! 18085: }
! 18086:
! 18087: static int
! 18088: test_schematron(void) {
! 18089: int test_ret = 0;
! 18090:
! 18091: if (quiet == 0) printf("Testing schematron : 1 of 10 functions ...\n");
! 18092: test_ret += test_xmlSchematronNewDocParserCtxt();
! 18093: test_ret += test_xmlSchematronNewMemParserCtxt();
! 18094: test_ret += test_xmlSchematronNewParserCtxt();
! 18095: test_ret += test_xmlSchematronNewValidCtxt();
! 18096: test_ret += test_xmlSchematronParse();
! 18097: test_ret += test_xmlSchematronSetValidStructuredErrors();
! 18098: test_ret += test_xmlSchematronValidateDoc();
! 18099:
! 18100: if (test_ret != 0)
! 18101: printf("Module schematron: %d errors\n", test_ret);
! 18102: return(test_ret);
! 18103: }
! 18104:
! 18105: static int
! 18106: test_xmlAddChild(void) {
! 18107: int test_ret = 0;
! 18108:
! 18109: int mem_base;
! 18110: xmlNodePtr ret_val;
! 18111: xmlNodePtr parent; /* the parent node */
! 18112: int n_parent;
! 18113: xmlNodePtr cur; /* the child node */
! 18114: int n_cur;
! 18115:
! 18116: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
! 18117: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) {
! 18118: mem_base = xmlMemBlocks();
! 18119: parent = gen_xmlNodePtr(n_parent, 0);
! 18120: cur = gen_xmlNodePtr_in(n_cur, 1);
! 18121:
! 18122: ret_val = xmlAddChild(parent, cur);
! 18123: if (ret_val == NULL) { xmlFreeNode(cur) ; cur = NULL ; }
! 18124: desret_xmlNodePtr(ret_val);
! 18125: call_tests++;
! 18126: des_xmlNodePtr(n_parent, parent, 0);
! 18127: des_xmlNodePtr_in(n_cur, cur, 1);
! 18128: xmlResetLastError();
! 18129: if (mem_base != xmlMemBlocks()) {
! 18130: printf("Leak of %d blocks found in xmlAddChild",
! 18131: xmlMemBlocks() - mem_base);
! 18132: test_ret++;
! 18133: printf(" %d", n_parent);
! 18134: printf(" %d", n_cur);
! 18135: printf("\n");
! 18136: }
! 18137: }
! 18138: }
! 18139: function_tests++;
! 18140:
! 18141: return(test_ret);
! 18142: }
! 18143:
! 18144:
! 18145: static int
! 18146: test_xmlAddChildList(void) {
! 18147: int test_ret = 0;
! 18148:
! 18149: int mem_base;
! 18150: xmlNodePtr ret_val;
! 18151: xmlNodePtr parent; /* the parent node */
! 18152: int n_parent;
! 18153: xmlNodePtr cur; /* the first node in the list */
! 18154: int n_cur;
! 18155:
! 18156: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
! 18157: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) {
! 18158: mem_base = xmlMemBlocks();
! 18159: parent = gen_xmlNodePtr(n_parent, 0);
! 18160: cur = gen_xmlNodePtr_in(n_cur, 1);
! 18161:
! 18162: ret_val = xmlAddChildList(parent, cur);
! 18163: if (ret_val == NULL) { xmlFreeNodeList(cur) ; cur = NULL ; }
! 18164: desret_xmlNodePtr(ret_val);
! 18165: call_tests++;
! 18166: des_xmlNodePtr(n_parent, parent, 0);
! 18167: des_xmlNodePtr_in(n_cur, cur, 1);
! 18168: xmlResetLastError();
! 18169: if (mem_base != xmlMemBlocks()) {
! 18170: printf("Leak of %d blocks found in xmlAddChildList",
! 18171: xmlMemBlocks() - mem_base);
! 18172: test_ret++;
! 18173: printf(" %d", n_parent);
! 18174: printf(" %d", n_cur);
! 18175: printf("\n");
! 18176: }
! 18177: }
! 18178: }
! 18179: function_tests++;
! 18180:
! 18181: return(test_ret);
! 18182: }
! 18183:
! 18184:
! 18185: static int
! 18186: test_xmlAddNextSibling(void) {
! 18187: int test_ret = 0;
! 18188:
! 18189: int mem_base;
! 18190: xmlNodePtr ret_val;
! 18191: xmlNodePtr cur; /* the child node */
! 18192: int n_cur;
! 18193: xmlNodePtr elem; /* the new node */
! 18194: int n_elem;
! 18195:
! 18196: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 18197: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) {
! 18198: mem_base = xmlMemBlocks();
! 18199: cur = gen_xmlNodePtr(n_cur, 0);
! 18200: elem = gen_xmlNodePtr_in(n_elem, 1);
! 18201:
! 18202: ret_val = xmlAddNextSibling(cur, elem);
! 18203: if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
! 18204: desret_xmlNodePtr(ret_val);
! 18205: call_tests++;
! 18206: des_xmlNodePtr(n_cur, cur, 0);
! 18207: des_xmlNodePtr_in(n_elem, elem, 1);
! 18208: xmlResetLastError();
! 18209: if (mem_base != xmlMemBlocks()) {
! 18210: printf("Leak of %d blocks found in xmlAddNextSibling",
! 18211: xmlMemBlocks() - mem_base);
! 18212: test_ret++;
! 18213: printf(" %d", n_cur);
! 18214: printf(" %d", n_elem);
! 18215: printf("\n");
! 18216: }
! 18217: }
! 18218: }
! 18219: function_tests++;
! 18220:
! 18221: return(test_ret);
! 18222: }
! 18223:
! 18224:
! 18225: static int
! 18226: test_xmlAddPrevSibling(void) {
! 18227: int test_ret = 0;
! 18228:
! 18229: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 18230: int mem_base;
! 18231: xmlNodePtr ret_val;
! 18232: xmlNodePtr cur; /* the child node */
! 18233: int n_cur;
! 18234: xmlNodePtr elem; /* the new node */
! 18235: int n_elem;
! 18236:
! 18237: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 18238: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) {
! 18239: mem_base = xmlMemBlocks();
! 18240: cur = gen_xmlNodePtr(n_cur, 0);
! 18241: elem = gen_xmlNodePtr_in(n_elem, 1);
! 18242:
! 18243: ret_val = xmlAddPrevSibling(cur, elem);
! 18244: if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
! 18245: desret_xmlNodePtr(ret_val);
! 18246: call_tests++;
! 18247: des_xmlNodePtr(n_cur, cur, 0);
! 18248: des_xmlNodePtr_in(n_elem, elem, 1);
! 18249: xmlResetLastError();
! 18250: if (mem_base != xmlMemBlocks()) {
! 18251: printf("Leak of %d blocks found in xmlAddPrevSibling",
! 18252: xmlMemBlocks() - mem_base);
! 18253: test_ret++;
! 18254: printf(" %d", n_cur);
! 18255: printf(" %d", n_elem);
! 18256: printf("\n");
! 18257: }
! 18258: }
! 18259: }
! 18260: function_tests++;
! 18261: #endif
! 18262:
! 18263: return(test_ret);
! 18264: }
! 18265:
! 18266:
! 18267: static int
! 18268: test_xmlAddSibling(void) {
! 18269: int test_ret = 0;
! 18270:
! 18271: int mem_base;
! 18272: xmlNodePtr ret_val;
! 18273: xmlNodePtr cur; /* the child node */
! 18274: int n_cur;
! 18275: xmlNodePtr elem; /* the new node */
! 18276: int n_elem;
! 18277:
! 18278: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 18279: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) {
! 18280: mem_base = xmlMemBlocks();
! 18281: cur = gen_xmlNodePtr(n_cur, 0);
! 18282: elem = gen_xmlNodePtr_in(n_elem, 1);
! 18283:
! 18284: ret_val = xmlAddSibling(cur, elem);
! 18285: if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
! 18286: desret_xmlNodePtr(ret_val);
! 18287: call_tests++;
! 18288: des_xmlNodePtr(n_cur, cur, 0);
! 18289: des_xmlNodePtr_in(n_elem, elem, 1);
! 18290: xmlResetLastError();
! 18291: if (mem_base != xmlMemBlocks()) {
! 18292: printf("Leak of %d blocks found in xmlAddSibling",
! 18293: xmlMemBlocks() - mem_base);
! 18294: test_ret++;
! 18295: printf(" %d", n_cur);
! 18296: printf(" %d", n_elem);
! 18297: printf("\n");
! 18298: }
! 18299: }
! 18300: }
! 18301: function_tests++;
! 18302:
! 18303: return(test_ret);
! 18304: }
! 18305:
! 18306:
! 18307: static int
! 18308: test_xmlAttrSerializeTxtContent(void) {
! 18309: int test_ret = 0;
! 18310:
! 18311: #if defined(LIBXML_OUTPUT_ENABLED)
! 18312: #ifdef LIBXML_OUTPUT_ENABLED
! 18313: int mem_base;
! 18314: xmlBufferPtr buf; /* the XML buffer output */
! 18315: int n_buf;
! 18316: xmlDocPtr doc; /* the document */
! 18317: int n_doc;
! 18318: xmlAttrPtr attr; /* the attribute node */
! 18319: int n_attr;
! 18320: xmlChar * string; /* the text content */
! 18321: int n_string;
! 18322:
! 18323: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 18324: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 18325: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
! 18326: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
! 18327: mem_base = xmlMemBlocks();
! 18328: buf = gen_xmlBufferPtr(n_buf, 0);
! 18329: doc = gen_xmlDocPtr(n_doc, 1);
! 18330: attr = gen_xmlAttrPtr(n_attr, 2);
! 18331: string = gen_const_xmlChar_ptr(n_string, 3);
! 18332:
! 18333: xmlAttrSerializeTxtContent(buf, doc, attr, (const xmlChar *)string);
! 18334: call_tests++;
! 18335: des_xmlBufferPtr(n_buf, buf, 0);
! 18336: des_xmlDocPtr(n_doc, doc, 1);
! 18337: des_xmlAttrPtr(n_attr, attr, 2);
! 18338: des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 3);
! 18339: xmlResetLastError();
! 18340: if (mem_base != xmlMemBlocks()) {
! 18341: printf("Leak of %d blocks found in xmlAttrSerializeTxtContent",
! 18342: xmlMemBlocks() - mem_base);
! 18343: test_ret++;
! 18344: printf(" %d", n_buf);
! 18345: printf(" %d", n_doc);
! 18346: printf(" %d", n_attr);
! 18347: printf(" %d", n_string);
! 18348: printf("\n");
! 18349: }
! 18350: }
! 18351: }
! 18352: }
! 18353: }
! 18354: function_tests++;
! 18355: #endif
! 18356: #endif
! 18357:
! 18358: return(test_ret);
! 18359: }
! 18360:
! 18361:
! 18362: static int
! 18363: test_xmlBufferAdd(void) {
! 18364: int test_ret = 0;
! 18365:
! 18366: int mem_base;
! 18367: int ret_val;
! 18368: xmlBufferPtr buf; /* the buffer to dump */
! 18369: int n_buf;
! 18370: xmlChar * str; /* the #xmlChar string */
! 18371: int n_str;
! 18372: int len; /* the number of #xmlChar to add */
! 18373: int n_len;
! 18374:
! 18375: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 18376: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 18377: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 18378: mem_base = xmlMemBlocks();
! 18379: buf = gen_xmlBufferPtr(n_buf, 0);
! 18380: str = gen_const_xmlChar_ptr(n_str, 1);
! 18381: len = gen_int(n_len, 2);
! 18382:
! 18383: ret_val = xmlBufferAdd(buf, (const xmlChar *)str, len);
! 18384: desret_int(ret_val);
! 18385: call_tests++;
! 18386: des_xmlBufferPtr(n_buf, buf, 0);
! 18387: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
! 18388: des_int(n_len, len, 2);
! 18389: xmlResetLastError();
! 18390: if (mem_base != xmlMemBlocks()) {
! 18391: printf("Leak of %d blocks found in xmlBufferAdd",
! 18392: xmlMemBlocks() - mem_base);
! 18393: test_ret++;
! 18394: printf(" %d", n_buf);
! 18395: printf(" %d", n_str);
! 18396: printf(" %d", n_len);
! 18397: printf("\n");
! 18398: }
! 18399: }
! 18400: }
! 18401: }
! 18402: function_tests++;
! 18403:
! 18404: return(test_ret);
! 18405: }
! 18406:
! 18407:
! 18408: static int
! 18409: test_xmlBufferAddHead(void) {
! 18410: int test_ret = 0;
! 18411:
! 18412: int mem_base;
! 18413: int ret_val;
! 18414: xmlBufferPtr buf; /* the buffer */
! 18415: int n_buf;
! 18416: xmlChar * str; /* the #xmlChar string */
! 18417: int n_str;
! 18418: int len; /* the number of #xmlChar to add */
! 18419: int n_len;
! 18420:
! 18421: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 18422: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 18423: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 18424: mem_base = xmlMemBlocks();
! 18425: buf = gen_xmlBufferPtr(n_buf, 0);
! 18426: str = gen_const_xmlChar_ptr(n_str, 1);
! 18427: len = gen_int(n_len, 2);
! 18428:
! 18429: ret_val = xmlBufferAddHead(buf, (const xmlChar *)str, len);
! 18430: desret_int(ret_val);
! 18431: call_tests++;
! 18432: des_xmlBufferPtr(n_buf, buf, 0);
! 18433: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
! 18434: des_int(n_len, len, 2);
! 18435: xmlResetLastError();
! 18436: if (mem_base != xmlMemBlocks()) {
! 18437: printf("Leak of %d blocks found in xmlBufferAddHead",
! 18438: xmlMemBlocks() - mem_base);
! 18439: test_ret++;
! 18440: printf(" %d", n_buf);
! 18441: printf(" %d", n_str);
! 18442: printf(" %d", n_len);
! 18443: printf("\n");
! 18444: }
! 18445: }
! 18446: }
! 18447: }
! 18448: function_tests++;
! 18449:
! 18450: return(test_ret);
! 18451: }
! 18452:
! 18453:
! 18454: static int
! 18455: test_xmlBufferCCat(void) {
! 18456: int test_ret = 0;
! 18457:
! 18458: int mem_base;
! 18459: int ret_val;
! 18460: xmlBufferPtr buf; /* the buffer to dump */
! 18461: int n_buf;
! 18462: char * str; /* the C char string */
! 18463: int n_str;
! 18464:
! 18465: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 18466: for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) {
! 18467: mem_base = xmlMemBlocks();
! 18468: buf = gen_xmlBufferPtr(n_buf, 0);
! 18469: str = gen_const_char_ptr(n_str, 1);
! 18470:
! 18471: ret_val = xmlBufferCCat(buf, (const char *)str);
! 18472: desret_int(ret_val);
! 18473: call_tests++;
! 18474: des_xmlBufferPtr(n_buf, buf, 0);
! 18475: des_const_char_ptr(n_str, (const char *)str, 1);
! 18476: xmlResetLastError();
! 18477: if (mem_base != xmlMemBlocks()) {
! 18478: printf("Leak of %d blocks found in xmlBufferCCat",
! 18479: xmlMemBlocks() - mem_base);
! 18480: test_ret++;
! 18481: printf(" %d", n_buf);
! 18482: printf(" %d", n_str);
! 18483: printf("\n");
! 18484: }
! 18485: }
! 18486: }
! 18487: function_tests++;
! 18488:
! 18489: return(test_ret);
! 18490: }
! 18491:
! 18492:
! 18493: static int
! 18494: test_xmlBufferCat(void) {
! 18495: int test_ret = 0;
! 18496:
! 18497: int mem_base;
! 18498: int ret_val;
! 18499: xmlBufferPtr buf; /* the buffer to add to */
! 18500: int n_buf;
! 18501: xmlChar * str; /* the #xmlChar string */
! 18502: int n_str;
! 18503:
! 18504: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 18505: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 18506: mem_base = xmlMemBlocks();
! 18507: buf = gen_xmlBufferPtr(n_buf, 0);
! 18508: str = gen_const_xmlChar_ptr(n_str, 1);
! 18509:
! 18510: ret_val = xmlBufferCat(buf, (const xmlChar *)str);
! 18511: desret_int(ret_val);
! 18512: call_tests++;
! 18513: des_xmlBufferPtr(n_buf, buf, 0);
! 18514: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
! 18515: xmlResetLastError();
! 18516: if (mem_base != xmlMemBlocks()) {
! 18517: printf("Leak of %d blocks found in xmlBufferCat",
! 18518: xmlMemBlocks() - mem_base);
! 18519: test_ret++;
! 18520: printf(" %d", n_buf);
! 18521: printf(" %d", n_str);
! 18522: printf("\n");
! 18523: }
! 18524: }
! 18525: }
! 18526: function_tests++;
! 18527:
! 18528: return(test_ret);
! 18529: }
! 18530:
! 18531:
! 18532: #define gen_nb_const_xmlBufferPtr 1
! 18533: static xmlBufferPtr gen_const_xmlBufferPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 18534: return(NULL);
! 18535: }
! 18536: static void des_const_xmlBufferPtr(int no ATTRIBUTE_UNUSED, const xmlBufferPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 18537: }
! 18538:
! 18539: static int
! 18540: test_xmlBufferContent(void) {
! 18541: int test_ret = 0;
! 18542:
! 18543: int mem_base;
! 18544: const xmlChar * ret_val;
! 18545: xmlBufferPtr buf; /* the buffer */
! 18546: int n_buf;
! 18547:
! 18548: for (n_buf = 0;n_buf < gen_nb_const_xmlBufferPtr;n_buf++) {
! 18549: mem_base = xmlMemBlocks();
! 18550: buf = gen_const_xmlBufferPtr(n_buf, 0);
! 18551:
! 18552: ret_val = xmlBufferContent((const xmlBufferPtr)buf);
! 18553: desret_const_xmlChar_ptr(ret_val);
! 18554: call_tests++;
! 18555: des_const_xmlBufferPtr(n_buf, (const xmlBufferPtr)buf, 0);
! 18556: xmlResetLastError();
! 18557: if (mem_base != xmlMemBlocks()) {
! 18558: printf("Leak of %d blocks found in xmlBufferContent",
! 18559: xmlMemBlocks() - mem_base);
! 18560: test_ret++;
! 18561: printf(" %d", n_buf);
! 18562: printf("\n");
! 18563: }
! 18564: }
! 18565: function_tests++;
! 18566:
! 18567: return(test_ret);
! 18568: }
! 18569:
! 18570:
! 18571: static int
! 18572: test_xmlBufferCreate(void) {
! 18573: int test_ret = 0;
! 18574:
! 18575: int mem_base;
! 18576: xmlBufferPtr ret_val;
! 18577:
! 18578: mem_base = xmlMemBlocks();
! 18579:
! 18580: ret_val = xmlBufferCreate();
! 18581: desret_xmlBufferPtr(ret_val);
! 18582: call_tests++;
! 18583: xmlResetLastError();
! 18584: if (mem_base != xmlMemBlocks()) {
! 18585: printf("Leak of %d blocks found in xmlBufferCreate",
! 18586: xmlMemBlocks() - mem_base);
! 18587: test_ret++;
! 18588: printf("\n");
! 18589: }
! 18590: function_tests++;
! 18591:
! 18592: return(test_ret);
! 18593: }
! 18594:
! 18595:
! 18596: static int
! 18597: test_xmlBufferCreateSize(void) {
! 18598: int test_ret = 0;
! 18599:
! 18600:
! 18601: /* missing type support */
! 18602: return(test_ret);
! 18603: }
! 18604:
! 18605:
! 18606: static int
! 18607: test_xmlBufferCreateStatic(void) {
! 18608: int test_ret = 0;
! 18609:
! 18610:
! 18611: /* missing type support */
! 18612: return(test_ret);
! 18613: }
! 18614:
! 18615:
! 18616: static int
! 18617: test_xmlBufferEmpty(void) {
! 18618: int test_ret = 0;
! 18619:
! 18620: int mem_base;
! 18621: xmlBufferPtr buf; /* the buffer */
! 18622: int n_buf;
! 18623:
! 18624: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 18625: mem_base = xmlMemBlocks();
! 18626: buf = gen_xmlBufferPtr(n_buf, 0);
! 18627:
! 18628: xmlBufferEmpty(buf);
! 18629: call_tests++;
! 18630: des_xmlBufferPtr(n_buf, buf, 0);
! 18631: xmlResetLastError();
! 18632: if (mem_base != xmlMemBlocks()) {
! 18633: printf("Leak of %d blocks found in xmlBufferEmpty",
! 18634: xmlMemBlocks() - mem_base);
! 18635: test_ret++;
! 18636: printf(" %d", n_buf);
! 18637: printf("\n");
! 18638: }
! 18639: }
! 18640: function_tests++;
! 18641:
! 18642: return(test_ret);
! 18643: }
! 18644:
! 18645:
! 18646: static int
! 18647: test_xmlBufferGrow(void) {
! 18648: int test_ret = 0;
! 18649:
! 18650: int mem_base;
! 18651: int ret_val;
! 18652: xmlBufferPtr buf; /* the buffer */
! 18653: int n_buf;
! 18654: unsigned int len; /* the minimum free size to allocate */
! 18655: int n_len;
! 18656:
! 18657: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 18658: for (n_len = 0;n_len < gen_nb_unsigned_int;n_len++) {
! 18659: mem_base = xmlMemBlocks();
! 18660: buf = gen_xmlBufferPtr(n_buf, 0);
! 18661: len = gen_unsigned_int(n_len, 1);
! 18662:
! 18663: ret_val = xmlBufferGrow(buf, len);
! 18664: desret_int(ret_val);
! 18665: call_tests++;
! 18666: des_xmlBufferPtr(n_buf, buf, 0);
! 18667: des_unsigned_int(n_len, len, 1);
! 18668: xmlResetLastError();
! 18669: if (mem_base != xmlMemBlocks()) {
! 18670: printf("Leak of %d blocks found in xmlBufferGrow",
! 18671: xmlMemBlocks() - mem_base);
! 18672: test_ret++;
! 18673: printf(" %d", n_buf);
! 18674: printf(" %d", n_len);
! 18675: printf("\n");
! 18676: }
! 18677: }
! 18678: }
! 18679: function_tests++;
! 18680:
! 18681: return(test_ret);
! 18682: }
! 18683:
! 18684:
! 18685: static int
! 18686: test_xmlBufferLength(void) {
! 18687: int test_ret = 0;
! 18688:
! 18689: int mem_base;
! 18690: int ret_val;
! 18691: xmlBufferPtr buf; /* the buffer */
! 18692: int n_buf;
! 18693:
! 18694: for (n_buf = 0;n_buf < gen_nb_const_xmlBufferPtr;n_buf++) {
! 18695: mem_base = xmlMemBlocks();
! 18696: buf = gen_const_xmlBufferPtr(n_buf, 0);
! 18697:
! 18698: ret_val = xmlBufferLength((const xmlBufferPtr)buf);
! 18699: desret_int(ret_val);
! 18700: call_tests++;
! 18701: des_const_xmlBufferPtr(n_buf, (const xmlBufferPtr)buf, 0);
! 18702: xmlResetLastError();
! 18703: if (mem_base != xmlMemBlocks()) {
! 18704: printf("Leak of %d blocks found in xmlBufferLength",
! 18705: xmlMemBlocks() - mem_base);
! 18706: test_ret++;
! 18707: printf(" %d", n_buf);
! 18708: printf("\n");
! 18709: }
! 18710: }
! 18711: function_tests++;
! 18712:
! 18713: return(test_ret);
! 18714: }
! 18715:
! 18716:
! 18717: static int
! 18718: test_xmlBufferResize(void) {
! 18719: int test_ret = 0;
! 18720:
! 18721: int mem_base;
! 18722: int ret_val;
! 18723: xmlBufferPtr buf; /* the buffer to resize */
! 18724: int n_buf;
! 18725: unsigned int size; /* the desired size */
! 18726: int n_size;
! 18727:
! 18728: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 18729: for (n_size = 0;n_size < gen_nb_unsigned_int;n_size++) {
! 18730: mem_base = xmlMemBlocks();
! 18731: buf = gen_xmlBufferPtr(n_buf, 0);
! 18732: size = gen_unsigned_int(n_size, 1);
! 18733:
! 18734: ret_val = xmlBufferResize(buf, size);
! 18735: desret_int(ret_val);
! 18736: call_tests++;
! 18737: des_xmlBufferPtr(n_buf, buf, 0);
! 18738: des_unsigned_int(n_size, size, 1);
! 18739: xmlResetLastError();
! 18740: if (mem_base != xmlMemBlocks()) {
! 18741: printf("Leak of %d blocks found in xmlBufferResize",
! 18742: xmlMemBlocks() - mem_base);
! 18743: test_ret++;
! 18744: printf(" %d", n_buf);
! 18745: printf(" %d", n_size);
! 18746: printf("\n");
! 18747: }
! 18748: }
! 18749: }
! 18750: function_tests++;
! 18751:
! 18752: return(test_ret);
! 18753: }
! 18754:
! 18755:
! 18756: static int
! 18757: test_xmlBufferSetAllocationScheme(void) {
! 18758: int test_ret = 0;
! 18759:
! 18760: int mem_base;
! 18761: xmlBufferPtr buf; /* the buffer to tune */
! 18762: int n_buf;
! 18763: xmlBufferAllocationScheme scheme; /* allocation scheme to use */
! 18764: int n_scheme;
! 18765:
! 18766: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 18767: for (n_scheme = 0;n_scheme < gen_nb_xmlBufferAllocationScheme;n_scheme++) {
! 18768: mem_base = xmlMemBlocks();
! 18769: buf = gen_xmlBufferPtr(n_buf, 0);
! 18770: scheme = gen_xmlBufferAllocationScheme(n_scheme, 1);
! 18771:
! 18772: xmlBufferSetAllocationScheme(buf, scheme);
! 18773: if ((buf != NULL) && (scheme == XML_BUFFER_ALLOC_IMMUTABLE) && (buf->content != NULL) && (buf->content != static_buf_content)) { xmlFree(buf->content); buf->content = NULL;}
! 18774: call_tests++;
! 18775: des_xmlBufferPtr(n_buf, buf, 0);
! 18776: des_xmlBufferAllocationScheme(n_scheme, scheme, 1);
! 18777: xmlResetLastError();
! 18778: if (mem_base != xmlMemBlocks()) {
! 18779: printf("Leak of %d blocks found in xmlBufferSetAllocationScheme",
! 18780: xmlMemBlocks() - mem_base);
! 18781: test_ret++;
! 18782: printf(" %d", n_buf);
! 18783: printf(" %d", n_scheme);
! 18784: printf("\n");
! 18785: }
! 18786: }
! 18787: }
! 18788: function_tests++;
! 18789:
! 18790: return(test_ret);
! 18791: }
! 18792:
! 18793:
! 18794: static int
! 18795: test_xmlBufferShrink(void) {
! 18796: int test_ret = 0;
! 18797:
! 18798: int mem_base;
! 18799: int ret_val;
! 18800: xmlBufferPtr buf; /* the buffer to dump */
! 18801: int n_buf;
! 18802: unsigned int len; /* the number of xmlChar to remove */
! 18803: int n_len;
! 18804:
! 18805: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 18806: for (n_len = 0;n_len < gen_nb_unsigned_int;n_len++) {
! 18807: mem_base = xmlMemBlocks();
! 18808: buf = gen_xmlBufferPtr(n_buf, 0);
! 18809: len = gen_unsigned_int(n_len, 1);
! 18810:
! 18811: ret_val = xmlBufferShrink(buf, len);
! 18812: desret_int(ret_val);
! 18813: call_tests++;
! 18814: des_xmlBufferPtr(n_buf, buf, 0);
! 18815: des_unsigned_int(n_len, len, 1);
! 18816: xmlResetLastError();
! 18817: if (mem_base != xmlMemBlocks()) {
! 18818: printf("Leak of %d blocks found in xmlBufferShrink",
! 18819: xmlMemBlocks() - mem_base);
! 18820: test_ret++;
! 18821: printf(" %d", n_buf);
! 18822: printf(" %d", n_len);
! 18823: printf("\n");
! 18824: }
! 18825: }
! 18826: }
! 18827: function_tests++;
! 18828:
! 18829: return(test_ret);
! 18830: }
! 18831:
! 18832:
! 18833: static int
! 18834: test_xmlBufferWriteCHAR(void) {
! 18835: int test_ret = 0;
! 18836:
! 18837: int mem_base;
! 18838: xmlBufferPtr buf; /* the XML buffer */
! 18839: int n_buf;
! 18840: xmlChar * string; /* the string to add */
! 18841: int n_string;
! 18842:
! 18843: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 18844: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
! 18845: mem_base = xmlMemBlocks();
! 18846: buf = gen_xmlBufferPtr(n_buf, 0);
! 18847: string = gen_const_xmlChar_ptr(n_string, 1);
! 18848:
! 18849: xmlBufferWriteCHAR(buf, (const xmlChar *)string);
! 18850: call_tests++;
! 18851: des_xmlBufferPtr(n_buf, buf, 0);
! 18852: des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 1);
! 18853: xmlResetLastError();
! 18854: if (mem_base != xmlMemBlocks()) {
! 18855: printf("Leak of %d blocks found in xmlBufferWriteCHAR",
! 18856: xmlMemBlocks() - mem_base);
! 18857: test_ret++;
! 18858: printf(" %d", n_buf);
! 18859: printf(" %d", n_string);
! 18860: printf("\n");
! 18861: }
! 18862: }
! 18863: }
! 18864: function_tests++;
! 18865:
! 18866: return(test_ret);
! 18867: }
! 18868:
! 18869:
! 18870: static int
! 18871: test_xmlBufferWriteChar(void) {
! 18872: int test_ret = 0;
! 18873:
! 18874: int mem_base;
! 18875: xmlBufferPtr buf; /* the XML buffer output */
! 18876: int n_buf;
! 18877: char * string; /* the string to add */
! 18878: int n_string;
! 18879:
! 18880: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 18881: for (n_string = 0;n_string < gen_nb_const_char_ptr;n_string++) {
! 18882: mem_base = xmlMemBlocks();
! 18883: buf = gen_xmlBufferPtr(n_buf, 0);
! 18884: string = gen_const_char_ptr(n_string, 1);
! 18885:
! 18886: xmlBufferWriteChar(buf, (const char *)string);
! 18887: call_tests++;
! 18888: des_xmlBufferPtr(n_buf, buf, 0);
! 18889: des_const_char_ptr(n_string, (const char *)string, 1);
! 18890: xmlResetLastError();
! 18891: if (mem_base != xmlMemBlocks()) {
! 18892: printf("Leak of %d blocks found in xmlBufferWriteChar",
! 18893: xmlMemBlocks() - mem_base);
! 18894: test_ret++;
! 18895: printf(" %d", n_buf);
! 18896: printf(" %d", n_string);
! 18897: printf("\n");
! 18898: }
! 18899: }
! 18900: }
! 18901: function_tests++;
! 18902:
! 18903: return(test_ret);
! 18904: }
! 18905:
! 18906:
! 18907: static int
! 18908: test_xmlBufferWriteQuotedString(void) {
! 18909: int test_ret = 0;
! 18910:
! 18911: int mem_base;
! 18912: xmlBufferPtr buf; /* the XML buffer output */
! 18913: int n_buf;
! 18914: xmlChar * string; /* the string to add */
! 18915: int n_string;
! 18916:
! 18917: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 18918: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
! 18919: mem_base = xmlMemBlocks();
! 18920: buf = gen_xmlBufferPtr(n_buf, 0);
! 18921: string = gen_const_xmlChar_ptr(n_string, 1);
! 18922:
! 18923: xmlBufferWriteQuotedString(buf, (const xmlChar *)string);
! 18924: call_tests++;
! 18925: des_xmlBufferPtr(n_buf, buf, 0);
! 18926: des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 1);
! 18927: xmlResetLastError();
! 18928: if (mem_base != xmlMemBlocks()) {
! 18929: printf("Leak of %d blocks found in xmlBufferWriteQuotedString",
! 18930: xmlMemBlocks() - mem_base);
! 18931: test_ret++;
! 18932: printf(" %d", n_buf);
! 18933: printf(" %d", n_string);
! 18934: printf("\n");
! 18935: }
! 18936: }
! 18937: }
! 18938: function_tests++;
! 18939:
! 18940: return(test_ret);
! 18941: }
! 18942:
! 18943:
! 18944: static int
! 18945: test_xmlBuildQName(void) {
! 18946: int test_ret = 0;
! 18947:
! 18948: int mem_base;
! 18949: xmlChar * ret_val;
! 18950: xmlChar * ncname; /* the Name */
! 18951: int n_ncname;
! 18952: xmlChar * prefix; /* the prefix */
! 18953: int n_prefix;
! 18954: xmlChar * memory; /* preallocated memory */
! 18955: int n_memory;
! 18956: int len; /* preallocated memory length */
! 18957: int n_len;
! 18958:
! 18959: for (n_ncname = 0;n_ncname < gen_nb_const_xmlChar_ptr;n_ncname++) {
! 18960: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
! 18961: for (n_memory = 0;n_memory < gen_nb_xmlChar_ptr;n_memory++) {
! 18962: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 18963: mem_base = xmlMemBlocks();
! 18964: ncname = gen_const_xmlChar_ptr(n_ncname, 0);
! 18965: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
! 18966: memory = gen_xmlChar_ptr(n_memory, 2);
! 18967: len = gen_int(n_len, 3);
! 18968:
! 18969: ret_val = xmlBuildQName((const xmlChar *)ncname, (const xmlChar *)prefix, memory, len);
! 18970: if ((ret_val != NULL) && (ret_val != ncname) &&
! 18971: (ret_val != prefix) && (ret_val != memory))
! 18972: xmlFree(ret_val);
! 18973: ret_val = NULL;
! 18974: desret_xmlChar_ptr(ret_val);
! 18975: call_tests++;
! 18976: des_const_xmlChar_ptr(n_ncname, (const xmlChar *)ncname, 0);
! 18977: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
! 18978: des_xmlChar_ptr(n_memory, memory, 2);
! 18979: des_int(n_len, len, 3);
! 18980: xmlResetLastError();
! 18981: if (mem_base != xmlMemBlocks()) {
! 18982: printf("Leak of %d blocks found in xmlBuildQName",
! 18983: xmlMemBlocks() - mem_base);
! 18984: test_ret++;
! 18985: printf(" %d", n_ncname);
! 18986: printf(" %d", n_prefix);
! 18987: printf(" %d", n_memory);
! 18988: printf(" %d", n_len);
! 18989: printf("\n");
! 18990: }
! 18991: }
! 18992: }
! 18993: }
! 18994: }
! 18995: function_tests++;
! 18996:
! 18997: return(test_ret);
! 18998: }
! 18999:
! 19000:
! 19001: static int
! 19002: test_xmlChildElementCount(void) {
! 19003: int test_ret = 0;
! 19004:
! 19005: #if defined(LIBXML_TREE_ENABLED)
! 19006: int mem_base;
! 19007: unsigned long ret_val;
! 19008: xmlNodePtr parent; /* the parent node */
! 19009: int n_parent;
! 19010:
! 19011: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
! 19012: mem_base = xmlMemBlocks();
! 19013: parent = gen_xmlNodePtr(n_parent, 0);
! 19014:
! 19015: ret_val = xmlChildElementCount(parent);
! 19016: desret_unsigned_long(ret_val);
! 19017: call_tests++;
! 19018: des_xmlNodePtr(n_parent, parent, 0);
! 19019: xmlResetLastError();
! 19020: if (mem_base != xmlMemBlocks()) {
! 19021: printf("Leak of %d blocks found in xmlChildElementCount",
! 19022: xmlMemBlocks() - mem_base);
! 19023: test_ret++;
! 19024: printf(" %d", n_parent);
! 19025: printf("\n");
! 19026: }
! 19027: }
! 19028: function_tests++;
! 19029: #endif
! 19030:
! 19031: return(test_ret);
! 19032: }
! 19033:
! 19034:
! 19035: static int
! 19036: test_xmlCopyDoc(void) {
! 19037: int test_ret = 0;
! 19038:
! 19039: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 19040: int mem_base;
! 19041: xmlDocPtr ret_val;
! 19042: xmlDocPtr doc; /* the document */
! 19043: int n_doc;
! 19044: int recursive; /* if not zero do a recursive copy. */
! 19045: int n_recursive;
! 19046:
! 19047: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 19048: for (n_recursive = 0;n_recursive < gen_nb_int;n_recursive++) {
! 19049: mem_base = xmlMemBlocks();
! 19050: doc = gen_xmlDocPtr(n_doc, 0);
! 19051: recursive = gen_int(n_recursive, 1);
! 19052:
! 19053: ret_val = xmlCopyDoc(doc, recursive);
! 19054: desret_xmlDocPtr(ret_val);
! 19055: call_tests++;
! 19056: des_xmlDocPtr(n_doc, doc, 0);
! 19057: des_int(n_recursive, recursive, 1);
! 19058: xmlResetLastError();
! 19059: if (mem_base != xmlMemBlocks()) {
! 19060: printf("Leak of %d blocks found in xmlCopyDoc",
! 19061: xmlMemBlocks() - mem_base);
! 19062: test_ret++;
! 19063: printf(" %d", n_doc);
! 19064: printf(" %d", n_recursive);
! 19065: printf("\n");
! 19066: }
! 19067: }
! 19068: }
! 19069: function_tests++;
! 19070: #endif
! 19071:
! 19072: return(test_ret);
! 19073: }
! 19074:
! 19075:
! 19076: static int
! 19077: test_xmlCopyDtd(void) {
! 19078: int test_ret = 0;
! 19079:
! 19080: #if defined(LIBXML_TREE_ENABLED)
! 19081: int mem_base;
! 19082: xmlDtdPtr ret_val;
! 19083: xmlDtdPtr dtd; /* the dtd */
! 19084: int n_dtd;
! 19085:
! 19086: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
! 19087: mem_base = xmlMemBlocks();
! 19088: dtd = gen_xmlDtdPtr(n_dtd, 0);
! 19089:
! 19090: ret_val = xmlCopyDtd(dtd);
! 19091: desret_xmlDtdPtr(ret_val);
! 19092: call_tests++;
! 19093: des_xmlDtdPtr(n_dtd, dtd, 0);
! 19094: xmlResetLastError();
! 19095: if (mem_base != xmlMemBlocks()) {
! 19096: printf("Leak of %d blocks found in xmlCopyDtd",
! 19097: xmlMemBlocks() - mem_base);
! 19098: test_ret++;
! 19099: printf(" %d", n_dtd);
! 19100: printf("\n");
! 19101: }
! 19102: }
! 19103: function_tests++;
! 19104: #endif
! 19105:
! 19106: return(test_ret);
! 19107: }
! 19108:
! 19109:
! 19110: static int
! 19111: test_xmlCopyNamespace(void) {
! 19112: int test_ret = 0;
! 19113:
! 19114: int mem_base;
! 19115: xmlNsPtr ret_val;
! 19116: xmlNsPtr cur; /* the namespace */
! 19117: int n_cur;
! 19118:
! 19119: for (n_cur = 0;n_cur < gen_nb_xmlNsPtr;n_cur++) {
! 19120: mem_base = xmlMemBlocks();
! 19121: cur = gen_xmlNsPtr(n_cur, 0);
! 19122:
! 19123: ret_val = xmlCopyNamespace(cur);
! 19124: if (ret_val != NULL) xmlFreeNs(ret_val);
! 19125: desret_xmlNsPtr(ret_val);
! 19126: call_tests++;
! 19127: des_xmlNsPtr(n_cur, cur, 0);
! 19128: xmlResetLastError();
! 19129: if (mem_base != xmlMemBlocks()) {
! 19130: printf("Leak of %d blocks found in xmlCopyNamespace",
! 19131: xmlMemBlocks() - mem_base);
! 19132: test_ret++;
! 19133: printf(" %d", n_cur);
! 19134: printf("\n");
! 19135: }
! 19136: }
! 19137: function_tests++;
! 19138:
! 19139: return(test_ret);
! 19140: }
! 19141:
! 19142:
! 19143: static int
! 19144: test_xmlCopyNamespaceList(void) {
! 19145: int test_ret = 0;
! 19146:
! 19147: int mem_base;
! 19148: xmlNsPtr ret_val;
! 19149: xmlNsPtr cur; /* the first namespace */
! 19150: int n_cur;
! 19151:
! 19152: for (n_cur = 0;n_cur < gen_nb_xmlNsPtr;n_cur++) {
! 19153: mem_base = xmlMemBlocks();
! 19154: cur = gen_xmlNsPtr(n_cur, 0);
! 19155:
! 19156: ret_val = xmlCopyNamespaceList(cur);
! 19157: if (ret_val != NULL) xmlFreeNsList(ret_val);
! 19158: desret_xmlNsPtr(ret_val);
! 19159: call_tests++;
! 19160: des_xmlNsPtr(n_cur, cur, 0);
! 19161: xmlResetLastError();
! 19162: if (mem_base != xmlMemBlocks()) {
! 19163: printf("Leak of %d blocks found in xmlCopyNamespaceList",
! 19164: xmlMemBlocks() - mem_base);
! 19165: test_ret++;
! 19166: printf(" %d", n_cur);
! 19167: printf("\n");
! 19168: }
! 19169: }
! 19170: function_tests++;
! 19171:
! 19172: return(test_ret);
! 19173: }
! 19174:
! 19175:
! 19176: static int
! 19177: test_xmlCopyNode(void) {
! 19178: int test_ret = 0;
! 19179:
! 19180: int mem_base;
! 19181: xmlNodePtr ret_val;
! 19182: xmlNodePtr node; /* the node */
! 19183: int n_node;
! 19184: int extended; /* if 1 do a recursive copy (properties, namespaces and children when applicable) if 2 copy properties and namespaces (when applicable) */
! 19185: int n_extended;
! 19186:
! 19187: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
! 19188: for (n_extended = 0;n_extended < gen_nb_int;n_extended++) {
! 19189: mem_base = xmlMemBlocks();
! 19190: node = gen_const_xmlNodePtr(n_node, 0);
! 19191: extended = gen_int(n_extended, 1);
! 19192:
! 19193: ret_val = xmlCopyNode((const xmlNodePtr)node, extended);
! 19194: desret_xmlNodePtr(ret_val);
! 19195: call_tests++;
! 19196: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 0);
! 19197: des_int(n_extended, extended, 1);
! 19198: xmlResetLastError();
! 19199: if (mem_base != xmlMemBlocks()) {
! 19200: printf("Leak of %d blocks found in xmlCopyNode",
! 19201: xmlMemBlocks() - mem_base);
! 19202: test_ret++;
! 19203: printf(" %d", n_node);
! 19204: printf(" %d", n_extended);
! 19205: printf("\n");
! 19206: }
! 19207: }
! 19208: }
! 19209: function_tests++;
! 19210:
! 19211: return(test_ret);
! 19212: }
! 19213:
! 19214:
! 19215: static int
! 19216: test_xmlCopyNodeList(void) {
! 19217: int test_ret = 0;
! 19218:
! 19219: int mem_base;
! 19220: xmlNodePtr ret_val;
! 19221: xmlNodePtr node; /* the first node in the list. */
! 19222: int n_node;
! 19223:
! 19224: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
! 19225: mem_base = xmlMemBlocks();
! 19226: node = gen_const_xmlNodePtr(n_node, 0);
! 19227:
! 19228: ret_val = xmlCopyNodeList((const xmlNodePtr)node);
! 19229: desret_xmlNodePtr(ret_val);
! 19230: call_tests++;
! 19231: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 0);
! 19232: xmlResetLastError();
! 19233: if (mem_base != xmlMemBlocks()) {
! 19234: printf("Leak of %d blocks found in xmlCopyNodeList",
! 19235: xmlMemBlocks() - mem_base);
! 19236: test_ret++;
! 19237: printf(" %d", n_node);
! 19238: printf("\n");
! 19239: }
! 19240: }
! 19241: function_tests++;
! 19242:
! 19243: return(test_ret);
! 19244: }
! 19245:
! 19246:
! 19247: static int
! 19248: test_xmlCopyProp(void) {
! 19249: int test_ret = 0;
! 19250:
! 19251: int mem_base;
! 19252: xmlAttrPtr ret_val;
! 19253: xmlNodePtr target; /* the element where the attribute will be grafted */
! 19254: int n_target;
! 19255: xmlAttrPtr cur; /* the attribute */
! 19256: int n_cur;
! 19257:
! 19258: for (n_target = 0;n_target < gen_nb_xmlNodePtr;n_target++) {
! 19259: for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) {
! 19260: mem_base = xmlMemBlocks();
! 19261: target = gen_xmlNodePtr(n_target, 0);
! 19262: cur = gen_xmlAttrPtr(n_cur, 1);
! 19263:
! 19264: ret_val = xmlCopyProp(target, cur);
! 19265: desret_xmlAttrPtr(ret_val);
! 19266: call_tests++;
! 19267: des_xmlNodePtr(n_target, target, 0);
! 19268: des_xmlAttrPtr(n_cur, cur, 1);
! 19269: xmlResetLastError();
! 19270: if (mem_base != xmlMemBlocks()) {
! 19271: printf("Leak of %d blocks found in xmlCopyProp",
! 19272: xmlMemBlocks() - mem_base);
! 19273: test_ret++;
! 19274: printf(" %d", n_target);
! 19275: printf(" %d", n_cur);
! 19276: printf("\n");
! 19277: }
! 19278: }
! 19279: }
! 19280: function_tests++;
! 19281:
! 19282: return(test_ret);
! 19283: }
! 19284:
! 19285:
! 19286: static int
! 19287: test_xmlCopyPropList(void) {
! 19288: int test_ret = 0;
! 19289:
! 19290: int mem_base;
! 19291: xmlAttrPtr ret_val;
! 19292: xmlNodePtr target; /* the element where the attributes will be grafted */
! 19293: int n_target;
! 19294: xmlAttrPtr cur; /* the first attribute */
! 19295: int n_cur;
! 19296:
! 19297: for (n_target = 0;n_target < gen_nb_xmlNodePtr;n_target++) {
! 19298: for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) {
! 19299: mem_base = xmlMemBlocks();
! 19300: target = gen_xmlNodePtr(n_target, 0);
! 19301: cur = gen_xmlAttrPtr(n_cur, 1);
! 19302:
! 19303: ret_val = xmlCopyPropList(target, cur);
! 19304: desret_xmlAttrPtr(ret_val);
! 19305: call_tests++;
! 19306: des_xmlNodePtr(n_target, target, 0);
! 19307: des_xmlAttrPtr(n_cur, cur, 1);
! 19308: xmlResetLastError();
! 19309: if (mem_base != xmlMemBlocks()) {
! 19310: printf("Leak of %d blocks found in xmlCopyPropList",
! 19311: xmlMemBlocks() - mem_base);
! 19312: test_ret++;
! 19313: printf(" %d", n_target);
! 19314: printf(" %d", n_cur);
! 19315: printf("\n");
! 19316: }
! 19317: }
! 19318: }
! 19319: function_tests++;
! 19320:
! 19321: return(test_ret);
! 19322: }
! 19323:
! 19324:
! 19325: static int
! 19326: test_xmlCreateIntSubset(void) {
! 19327: int test_ret = 0;
! 19328:
! 19329: int mem_base;
! 19330: xmlDtdPtr ret_val;
! 19331: xmlDocPtr doc; /* the document pointer */
! 19332: int n_doc;
! 19333: xmlChar * name; /* the DTD name */
! 19334: int n_name;
! 19335: xmlChar * ExternalID; /* the external (PUBLIC) ID */
! 19336: int n_ExternalID;
! 19337: xmlChar * SystemID; /* the system ID */
! 19338: int n_SystemID;
! 19339:
! 19340: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 19341: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 19342: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
! 19343: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
! 19344: mem_base = xmlMemBlocks();
! 19345: doc = gen_xmlDocPtr(n_doc, 0);
! 19346: name = gen_const_xmlChar_ptr(n_name, 1);
! 19347: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
! 19348: SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
! 19349:
! 19350: ret_val = xmlCreateIntSubset(doc, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
! 19351: desret_xmlDtdPtr(ret_val);
! 19352: call_tests++;
! 19353: des_xmlDocPtr(n_doc, doc, 0);
! 19354: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 19355: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2);
! 19356: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3);
! 19357: xmlResetLastError();
! 19358: if (mem_base != xmlMemBlocks()) {
! 19359: printf("Leak of %d blocks found in xmlCreateIntSubset",
! 19360: xmlMemBlocks() - mem_base);
! 19361: test_ret++;
! 19362: printf(" %d", n_doc);
! 19363: printf(" %d", n_name);
! 19364: printf(" %d", n_ExternalID);
! 19365: printf(" %d", n_SystemID);
! 19366: printf("\n");
! 19367: }
! 19368: }
! 19369: }
! 19370: }
! 19371: }
! 19372: function_tests++;
! 19373:
! 19374: return(test_ret);
! 19375: }
! 19376:
! 19377:
! 19378: #define gen_nb_xmlDOMWrapCtxtPtr 1
! 19379: static xmlDOMWrapCtxtPtr gen_xmlDOMWrapCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 19380: return(NULL);
! 19381: }
! 19382: static void des_xmlDOMWrapCtxtPtr(int no ATTRIBUTE_UNUSED, xmlDOMWrapCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 19383: }
! 19384:
! 19385: static int
! 19386: test_xmlDOMWrapAdoptNode(void) {
! 19387: int test_ret = 0;
! 19388:
! 19389: int mem_base;
! 19390: int ret_val;
! 19391: xmlDOMWrapCtxtPtr ctxt; /* the optional context for custom processing */
! 19392: int n_ctxt;
! 19393: xmlDocPtr sourceDoc; /* the optional sourceDoc */
! 19394: int n_sourceDoc;
! 19395: xmlNodePtr node; /* the node to start with */
! 19396: int n_node;
! 19397: xmlDocPtr destDoc; /* the destination doc */
! 19398: int n_destDoc;
! 19399: xmlNodePtr destParent; /* the optional new parent of @node in @destDoc */
! 19400: int n_destParent;
! 19401: int options; /* option flags */
! 19402: int n_options;
! 19403:
! 19404: for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
! 19405: for (n_sourceDoc = 0;n_sourceDoc < gen_nb_xmlDocPtr;n_sourceDoc++) {
! 19406: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 19407: for (n_destDoc = 0;n_destDoc < gen_nb_xmlDocPtr;n_destDoc++) {
! 19408: for (n_destParent = 0;n_destParent < gen_nb_xmlNodePtr;n_destParent++) {
! 19409: for (n_options = 0;n_options < gen_nb_int;n_options++) {
! 19410: mem_base = xmlMemBlocks();
! 19411: ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
! 19412: sourceDoc = gen_xmlDocPtr(n_sourceDoc, 1);
! 19413: node = gen_xmlNodePtr(n_node, 2);
! 19414: destDoc = gen_xmlDocPtr(n_destDoc, 3);
! 19415: destParent = gen_xmlNodePtr(n_destParent, 4);
! 19416: options = gen_int(n_options, 5);
! 19417:
! 19418: ret_val = xmlDOMWrapAdoptNode(ctxt, sourceDoc, node, destDoc, destParent, options);
! 19419: if ((node != NULL) && (node->parent == NULL)) {xmlUnlinkNode(node);xmlFreeNode(node);node = NULL;}
! 19420: desret_int(ret_val);
! 19421: call_tests++;
! 19422: des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
! 19423: des_xmlDocPtr(n_sourceDoc, sourceDoc, 1);
! 19424: des_xmlNodePtr(n_node, node, 2);
! 19425: des_xmlDocPtr(n_destDoc, destDoc, 3);
! 19426: des_xmlNodePtr(n_destParent, destParent, 4);
! 19427: des_int(n_options, options, 5);
! 19428: xmlResetLastError();
! 19429: if (mem_base != xmlMemBlocks()) {
! 19430: printf("Leak of %d blocks found in xmlDOMWrapAdoptNode",
! 19431: xmlMemBlocks() - mem_base);
! 19432: test_ret++;
! 19433: printf(" %d", n_ctxt);
! 19434: printf(" %d", n_sourceDoc);
! 19435: printf(" %d", n_node);
! 19436: printf(" %d", n_destDoc);
! 19437: printf(" %d", n_destParent);
! 19438: printf(" %d", n_options);
! 19439: printf("\n");
! 19440: }
! 19441: }
! 19442: }
! 19443: }
! 19444: }
! 19445: }
! 19446: }
! 19447: function_tests++;
! 19448:
! 19449: return(test_ret);
! 19450: }
! 19451:
! 19452:
! 19453: static int
! 19454: test_xmlDOMWrapCloneNode(void) {
! 19455: int test_ret = 0;
! 19456:
! 19457: int mem_base;
! 19458: int ret_val;
! 19459: xmlDOMWrapCtxtPtr ctxt; /* the optional context for custom processing */
! 19460: int n_ctxt;
! 19461: xmlDocPtr sourceDoc; /* the optional sourceDoc */
! 19462: int n_sourceDoc;
! 19463: xmlNodePtr node; /* the node to start with */
! 19464: int n_node;
! 19465: xmlNodePtr * resNode; /* the clone of the given @node */
! 19466: int n_resNode;
! 19467: xmlDocPtr destDoc; /* the destination doc */
! 19468: int n_destDoc;
! 19469: xmlNodePtr destParent; /* the optional new parent of @node in @destDoc */
! 19470: int n_destParent;
! 19471: int deep; /* descend into child if set */
! 19472: int n_deep;
! 19473: int options; /* option flags */
! 19474: int n_options;
! 19475:
! 19476: for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
! 19477: for (n_sourceDoc = 0;n_sourceDoc < gen_nb_xmlDocPtr;n_sourceDoc++) {
! 19478: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 19479: for (n_resNode = 0;n_resNode < gen_nb_xmlNodePtr_ptr;n_resNode++) {
! 19480: for (n_destDoc = 0;n_destDoc < gen_nb_xmlDocPtr;n_destDoc++) {
! 19481: for (n_destParent = 0;n_destParent < gen_nb_xmlNodePtr;n_destParent++) {
! 19482: for (n_deep = 0;n_deep < gen_nb_int;n_deep++) {
! 19483: for (n_options = 0;n_options < gen_nb_int;n_options++) {
! 19484: mem_base = xmlMemBlocks();
! 19485: ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
! 19486: sourceDoc = gen_xmlDocPtr(n_sourceDoc, 1);
! 19487: node = gen_xmlNodePtr(n_node, 2);
! 19488: resNode = gen_xmlNodePtr_ptr(n_resNode, 3);
! 19489: destDoc = gen_xmlDocPtr(n_destDoc, 4);
! 19490: destParent = gen_xmlNodePtr(n_destParent, 5);
! 19491: deep = gen_int(n_deep, 6);
! 19492: options = gen_int(n_options, 7);
! 19493:
! 19494: ret_val = xmlDOMWrapCloneNode(ctxt, sourceDoc, node, resNode, destDoc, destParent, deep, options);
! 19495: desret_int(ret_val);
! 19496: call_tests++;
! 19497: des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
! 19498: des_xmlDocPtr(n_sourceDoc, sourceDoc, 1);
! 19499: des_xmlNodePtr(n_node, node, 2);
! 19500: des_xmlNodePtr_ptr(n_resNode, resNode, 3);
! 19501: des_xmlDocPtr(n_destDoc, destDoc, 4);
! 19502: des_xmlNodePtr(n_destParent, destParent, 5);
! 19503: des_int(n_deep, deep, 6);
! 19504: des_int(n_options, options, 7);
! 19505: xmlResetLastError();
! 19506: if (mem_base != xmlMemBlocks()) {
! 19507: printf("Leak of %d blocks found in xmlDOMWrapCloneNode",
! 19508: xmlMemBlocks() - mem_base);
! 19509: test_ret++;
! 19510: printf(" %d", n_ctxt);
! 19511: printf(" %d", n_sourceDoc);
! 19512: printf(" %d", n_node);
! 19513: printf(" %d", n_resNode);
! 19514: printf(" %d", n_destDoc);
! 19515: printf(" %d", n_destParent);
! 19516: printf(" %d", n_deep);
! 19517: printf(" %d", n_options);
! 19518: printf("\n");
! 19519: }
! 19520: }
! 19521: }
! 19522: }
! 19523: }
! 19524: }
! 19525: }
! 19526: }
! 19527: }
! 19528: function_tests++;
! 19529:
! 19530: return(test_ret);
! 19531: }
! 19532:
! 19533:
! 19534: static int
! 19535: test_xmlDOMWrapNewCtxt(void) {
! 19536: int test_ret = 0;
! 19537:
! 19538:
! 19539: /* missing type support */
! 19540: return(test_ret);
! 19541: }
! 19542:
! 19543:
! 19544: static int
! 19545: test_xmlDOMWrapReconcileNamespaces(void) {
! 19546: int test_ret = 0;
! 19547:
! 19548: int mem_base;
! 19549: int ret_val;
! 19550: xmlDOMWrapCtxtPtr ctxt; /* DOM wrapper context, unused at the moment */
! 19551: int n_ctxt;
! 19552: xmlNodePtr elem; /* the element-node */
! 19553: int n_elem;
! 19554: int options; /* option flags */
! 19555: int n_options;
! 19556:
! 19557: for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
! 19558: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
! 19559: for (n_options = 0;n_options < gen_nb_int;n_options++) {
! 19560: mem_base = xmlMemBlocks();
! 19561: ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
! 19562: elem = gen_xmlNodePtr(n_elem, 1);
! 19563: options = gen_int(n_options, 2);
! 19564:
! 19565: ret_val = xmlDOMWrapReconcileNamespaces(ctxt, elem, options);
! 19566: desret_int(ret_val);
! 19567: call_tests++;
! 19568: des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
! 19569: des_xmlNodePtr(n_elem, elem, 1);
! 19570: des_int(n_options, options, 2);
! 19571: xmlResetLastError();
! 19572: if (mem_base != xmlMemBlocks()) {
! 19573: printf("Leak of %d blocks found in xmlDOMWrapReconcileNamespaces",
! 19574: xmlMemBlocks() - mem_base);
! 19575: test_ret++;
! 19576: printf(" %d", n_ctxt);
! 19577: printf(" %d", n_elem);
! 19578: printf(" %d", n_options);
! 19579: printf("\n");
! 19580: }
! 19581: }
! 19582: }
! 19583: }
! 19584: function_tests++;
! 19585:
! 19586: return(test_ret);
! 19587: }
! 19588:
! 19589:
! 19590: static int
! 19591: test_xmlDOMWrapRemoveNode(void) {
! 19592: int test_ret = 0;
! 19593:
! 19594: int mem_base;
! 19595: int ret_val;
! 19596: xmlDOMWrapCtxtPtr ctxt; /* a DOM wrapper context */
! 19597: int n_ctxt;
! 19598: xmlDocPtr doc; /* the doc */
! 19599: int n_doc;
! 19600: xmlNodePtr node; /* the node to be removed. */
! 19601: int n_node;
! 19602: int options; /* set of options, unused at the moment */
! 19603: int n_options;
! 19604:
! 19605: for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
! 19606: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 19607: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 19608: for (n_options = 0;n_options < gen_nb_int;n_options++) {
! 19609: mem_base = xmlMemBlocks();
! 19610: ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
! 19611: doc = gen_xmlDocPtr(n_doc, 1);
! 19612: node = gen_xmlNodePtr(n_node, 2);
! 19613: options = gen_int(n_options, 3);
! 19614:
! 19615: ret_val = xmlDOMWrapRemoveNode(ctxt, doc, node, options);
! 19616: desret_int(ret_val);
! 19617: call_tests++;
! 19618: des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
! 19619: des_xmlDocPtr(n_doc, doc, 1);
! 19620: des_xmlNodePtr(n_node, node, 2);
! 19621: des_int(n_options, options, 3);
! 19622: xmlResetLastError();
! 19623: if (mem_base != xmlMemBlocks()) {
! 19624: printf("Leak of %d blocks found in xmlDOMWrapRemoveNode",
! 19625: xmlMemBlocks() - mem_base);
! 19626: test_ret++;
! 19627: printf(" %d", n_ctxt);
! 19628: printf(" %d", n_doc);
! 19629: printf(" %d", n_node);
! 19630: printf(" %d", n_options);
! 19631: printf("\n");
! 19632: }
! 19633: }
! 19634: }
! 19635: }
! 19636: }
! 19637: function_tests++;
! 19638:
! 19639: return(test_ret);
! 19640: }
! 19641:
! 19642:
! 19643: static int
! 19644: test_xmlDocCopyNode(void) {
! 19645: int test_ret = 0;
! 19646:
! 19647: int mem_base;
! 19648: xmlNodePtr ret_val;
! 19649: xmlNodePtr node; /* the node */
! 19650: int n_node;
! 19651: xmlDocPtr doc; /* the document */
! 19652: int n_doc;
! 19653: int extended; /* if 1 do a recursive copy (properties, namespaces and children when applicable) if 2 copy properties and namespaces (when applicable) */
! 19654: int n_extended;
! 19655:
! 19656: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
! 19657: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 19658: for (n_extended = 0;n_extended < gen_nb_int;n_extended++) {
! 19659: mem_base = xmlMemBlocks();
! 19660: node = gen_const_xmlNodePtr(n_node, 0);
! 19661: doc = gen_xmlDocPtr(n_doc, 1);
! 19662: extended = gen_int(n_extended, 2);
! 19663:
! 19664: ret_val = xmlDocCopyNode((const xmlNodePtr)node, doc, extended);
! 19665: desret_xmlNodePtr(ret_val);
! 19666: call_tests++;
! 19667: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 0);
! 19668: des_xmlDocPtr(n_doc, doc, 1);
! 19669: des_int(n_extended, extended, 2);
! 19670: xmlResetLastError();
! 19671: if (mem_base != xmlMemBlocks()) {
! 19672: printf("Leak of %d blocks found in xmlDocCopyNode",
! 19673: xmlMemBlocks() - mem_base);
! 19674: test_ret++;
! 19675: printf(" %d", n_node);
! 19676: printf(" %d", n_doc);
! 19677: printf(" %d", n_extended);
! 19678: printf("\n");
! 19679: }
! 19680: }
! 19681: }
! 19682: }
! 19683: function_tests++;
! 19684:
! 19685: return(test_ret);
! 19686: }
! 19687:
! 19688:
! 19689: static int
! 19690: test_xmlDocCopyNodeList(void) {
! 19691: int test_ret = 0;
! 19692:
! 19693: int mem_base;
! 19694: xmlNodePtr ret_val;
! 19695: xmlDocPtr doc; /* the target document */
! 19696: int n_doc;
! 19697: xmlNodePtr node; /* the first node in the list. */
! 19698: int n_node;
! 19699:
! 19700: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 19701: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
! 19702: mem_base = xmlMemBlocks();
! 19703: doc = gen_xmlDocPtr(n_doc, 0);
! 19704: node = gen_const_xmlNodePtr(n_node, 1);
! 19705:
! 19706: ret_val = xmlDocCopyNodeList(doc, (const xmlNodePtr)node);
! 19707: desret_xmlNodePtr(ret_val);
! 19708: call_tests++;
! 19709: des_xmlDocPtr(n_doc, doc, 0);
! 19710: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 1);
! 19711: xmlResetLastError();
! 19712: if (mem_base != xmlMemBlocks()) {
! 19713: printf("Leak of %d blocks found in xmlDocCopyNodeList",
! 19714: xmlMemBlocks() - mem_base);
! 19715: test_ret++;
! 19716: printf(" %d", n_doc);
! 19717: printf(" %d", n_node);
! 19718: printf("\n");
! 19719: }
! 19720: }
! 19721: }
! 19722: function_tests++;
! 19723:
! 19724: return(test_ret);
! 19725: }
! 19726:
! 19727:
! 19728: static int
! 19729: test_xmlDocDump(void) {
! 19730: int test_ret = 0;
! 19731:
! 19732: #if defined(LIBXML_OUTPUT_ENABLED)
! 19733: int mem_base;
! 19734: int ret_val;
! 19735: FILE * f; /* the FILE* */
! 19736: int n_f;
! 19737: xmlDocPtr cur; /* the document */
! 19738: int n_cur;
! 19739:
! 19740: for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
! 19741: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
! 19742: mem_base = xmlMemBlocks();
! 19743: f = gen_FILE_ptr(n_f, 0);
! 19744: cur = gen_xmlDocPtr(n_cur, 1);
! 19745:
! 19746: ret_val = xmlDocDump(f, cur);
! 19747: desret_int(ret_val);
! 19748: call_tests++;
! 19749: des_FILE_ptr(n_f, f, 0);
! 19750: des_xmlDocPtr(n_cur, cur, 1);
! 19751: xmlResetLastError();
! 19752: if (mem_base != xmlMemBlocks()) {
! 19753: printf("Leak of %d blocks found in xmlDocDump",
! 19754: xmlMemBlocks() - mem_base);
! 19755: test_ret++;
! 19756: printf(" %d", n_f);
! 19757: printf(" %d", n_cur);
! 19758: printf("\n");
! 19759: }
! 19760: }
! 19761: }
! 19762: function_tests++;
! 19763: #endif
! 19764:
! 19765: return(test_ret);
! 19766: }
! 19767:
! 19768:
! 19769: static int
! 19770: test_xmlDocDumpFormatMemory(void) {
! 19771: int test_ret = 0;
! 19772:
! 19773: #if defined(LIBXML_OUTPUT_ENABLED)
! 19774: int mem_base;
! 19775: xmlDocPtr cur; /* the document */
! 19776: int n_cur;
! 19777: xmlChar ** mem; /* OUT: the memory pointer */
! 19778: int n_mem;
! 19779: int * size; /* OUT: the memory length */
! 19780: int n_size;
! 19781: int format; /* should formatting spaces been added */
! 19782: int n_format;
! 19783:
! 19784: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
! 19785: for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
! 19786: for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
! 19787: for (n_format = 0;n_format < gen_nb_int;n_format++) {
! 19788: mem_base = xmlMemBlocks();
! 19789: cur = gen_xmlDocPtr(n_cur, 0);
! 19790: mem = gen_xmlChar_ptr_ptr(n_mem, 1);
! 19791: size = gen_int_ptr(n_size, 2);
! 19792: format = gen_int(n_format, 3);
! 19793:
! 19794: xmlDocDumpFormatMemory(cur, mem, size, format);
! 19795: call_tests++;
! 19796: des_xmlDocPtr(n_cur, cur, 0);
! 19797: des_xmlChar_ptr_ptr(n_mem, mem, 1);
! 19798: des_int_ptr(n_size, size, 2);
! 19799: des_int(n_format, format, 3);
! 19800: xmlResetLastError();
! 19801: if (mem_base != xmlMemBlocks()) {
! 19802: printf("Leak of %d blocks found in xmlDocDumpFormatMemory",
! 19803: xmlMemBlocks() - mem_base);
! 19804: test_ret++;
! 19805: printf(" %d", n_cur);
! 19806: printf(" %d", n_mem);
! 19807: printf(" %d", n_size);
! 19808: printf(" %d", n_format);
! 19809: printf("\n");
! 19810: }
! 19811: }
! 19812: }
! 19813: }
! 19814: }
! 19815: function_tests++;
! 19816: #endif
! 19817:
! 19818: return(test_ret);
! 19819: }
! 19820:
! 19821:
! 19822: static int
! 19823: test_xmlDocDumpFormatMemoryEnc(void) {
! 19824: int test_ret = 0;
! 19825:
! 19826: #if defined(LIBXML_OUTPUT_ENABLED)
! 19827: int mem_base;
! 19828: xmlDocPtr out_doc; /* Document to generate XML text from */
! 19829: int n_out_doc;
! 19830: xmlChar ** doc_txt_ptr; /* Memory pointer for allocated XML text */
! 19831: int n_doc_txt_ptr;
! 19832: int * doc_txt_len; /* Length of the generated XML text */
! 19833: int n_doc_txt_len;
! 19834: char * txt_encoding; /* Character encoding to use when generating XML text */
! 19835: int n_txt_encoding;
! 19836: int format; /* should formatting spaces been added */
! 19837: int n_format;
! 19838:
! 19839: for (n_out_doc = 0;n_out_doc < gen_nb_xmlDocPtr;n_out_doc++) {
! 19840: for (n_doc_txt_ptr = 0;n_doc_txt_ptr < gen_nb_xmlChar_ptr_ptr;n_doc_txt_ptr++) {
! 19841: for (n_doc_txt_len = 0;n_doc_txt_len < gen_nb_int_ptr;n_doc_txt_len++) {
! 19842: for (n_txt_encoding = 0;n_txt_encoding < gen_nb_const_char_ptr;n_txt_encoding++) {
! 19843: for (n_format = 0;n_format < gen_nb_int;n_format++) {
! 19844: mem_base = xmlMemBlocks();
! 19845: out_doc = gen_xmlDocPtr(n_out_doc, 0);
! 19846: doc_txt_ptr = gen_xmlChar_ptr_ptr(n_doc_txt_ptr, 1);
! 19847: doc_txt_len = gen_int_ptr(n_doc_txt_len, 2);
! 19848: txt_encoding = gen_const_char_ptr(n_txt_encoding, 3);
! 19849: format = gen_int(n_format, 4);
! 19850:
! 19851: xmlDocDumpFormatMemoryEnc(out_doc, doc_txt_ptr, doc_txt_len, (const char *)txt_encoding, format);
! 19852: call_tests++;
! 19853: des_xmlDocPtr(n_out_doc, out_doc, 0);
! 19854: des_xmlChar_ptr_ptr(n_doc_txt_ptr, doc_txt_ptr, 1);
! 19855: des_int_ptr(n_doc_txt_len, doc_txt_len, 2);
! 19856: des_const_char_ptr(n_txt_encoding, (const char *)txt_encoding, 3);
! 19857: des_int(n_format, format, 4);
! 19858: xmlResetLastError();
! 19859: if (mem_base != xmlMemBlocks()) {
! 19860: printf("Leak of %d blocks found in xmlDocDumpFormatMemoryEnc",
! 19861: xmlMemBlocks() - mem_base);
! 19862: test_ret++;
! 19863: printf(" %d", n_out_doc);
! 19864: printf(" %d", n_doc_txt_ptr);
! 19865: printf(" %d", n_doc_txt_len);
! 19866: printf(" %d", n_txt_encoding);
! 19867: printf(" %d", n_format);
! 19868: printf("\n");
! 19869: }
! 19870: }
! 19871: }
! 19872: }
! 19873: }
! 19874: }
! 19875: function_tests++;
! 19876: #endif
! 19877:
! 19878: return(test_ret);
! 19879: }
! 19880:
! 19881:
! 19882: static int
! 19883: test_xmlDocDumpMemory(void) {
! 19884: int test_ret = 0;
! 19885:
! 19886: #if defined(LIBXML_OUTPUT_ENABLED)
! 19887: int mem_base;
! 19888: xmlDocPtr cur; /* the document */
! 19889: int n_cur;
! 19890: xmlChar ** mem; /* OUT: the memory pointer */
! 19891: int n_mem;
! 19892: int * size; /* OUT: the memory length */
! 19893: int n_size;
! 19894:
! 19895: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
! 19896: for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
! 19897: for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
! 19898: mem_base = xmlMemBlocks();
! 19899: cur = gen_xmlDocPtr(n_cur, 0);
! 19900: mem = gen_xmlChar_ptr_ptr(n_mem, 1);
! 19901: size = gen_int_ptr(n_size, 2);
! 19902:
! 19903: xmlDocDumpMemory(cur, mem, size);
! 19904: call_tests++;
! 19905: des_xmlDocPtr(n_cur, cur, 0);
! 19906: des_xmlChar_ptr_ptr(n_mem, mem, 1);
! 19907: des_int_ptr(n_size, size, 2);
! 19908: xmlResetLastError();
! 19909: if (mem_base != xmlMemBlocks()) {
! 19910: printf("Leak of %d blocks found in xmlDocDumpMemory",
! 19911: xmlMemBlocks() - mem_base);
! 19912: test_ret++;
! 19913: printf(" %d", n_cur);
! 19914: printf(" %d", n_mem);
! 19915: printf(" %d", n_size);
! 19916: printf("\n");
! 19917: }
! 19918: }
! 19919: }
! 19920: }
! 19921: function_tests++;
! 19922: #endif
! 19923:
! 19924: return(test_ret);
! 19925: }
! 19926:
! 19927:
! 19928: static int
! 19929: test_xmlDocDumpMemoryEnc(void) {
! 19930: int test_ret = 0;
! 19931:
! 19932: #if defined(LIBXML_OUTPUT_ENABLED)
! 19933: int mem_base;
! 19934: xmlDocPtr out_doc; /* Document to generate XML text from */
! 19935: int n_out_doc;
! 19936: xmlChar ** doc_txt_ptr; /* Memory pointer for allocated XML text */
! 19937: int n_doc_txt_ptr;
! 19938: int * doc_txt_len; /* Length of the generated XML text */
! 19939: int n_doc_txt_len;
! 19940: char * txt_encoding; /* Character encoding to use when generating XML text */
! 19941: int n_txt_encoding;
! 19942:
! 19943: for (n_out_doc = 0;n_out_doc < gen_nb_xmlDocPtr;n_out_doc++) {
! 19944: for (n_doc_txt_ptr = 0;n_doc_txt_ptr < gen_nb_xmlChar_ptr_ptr;n_doc_txt_ptr++) {
! 19945: for (n_doc_txt_len = 0;n_doc_txt_len < gen_nb_int_ptr;n_doc_txt_len++) {
! 19946: for (n_txt_encoding = 0;n_txt_encoding < gen_nb_const_char_ptr;n_txt_encoding++) {
! 19947: mem_base = xmlMemBlocks();
! 19948: out_doc = gen_xmlDocPtr(n_out_doc, 0);
! 19949: doc_txt_ptr = gen_xmlChar_ptr_ptr(n_doc_txt_ptr, 1);
! 19950: doc_txt_len = gen_int_ptr(n_doc_txt_len, 2);
! 19951: txt_encoding = gen_const_char_ptr(n_txt_encoding, 3);
! 19952:
! 19953: xmlDocDumpMemoryEnc(out_doc, doc_txt_ptr, doc_txt_len, (const char *)txt_encoding);
! 19954: call_tests++;
! 19955: des_xmlDocPtr(n_out_doc, out_doc, 0);
! 19956: des_xmlChar_ptr_ptr(n_doc_txt_ptr, doc_txt_ptr, 1);
! 19957: des_int_ptr(n_doc_txt_len, doc_txt_len, 2);
! 19958: des_const_char_ptr(n_txt_encoding, (const char *)txt_encoding, 3);
! 19959: xmlResetLastError();
! 19960: if (mem_base != xmlMemBlocks()) {
! 19961: printf("Leak of %d blocks found in xmlDocDumpMemoryEnc",
! 19962: xmlMemBlocks() - mem_base);
! 19963: test_ret++;
! 19964: printf(" %d", n_out_doc);
! 19965: printf(" %d", n_doc_txt_ptr);
! 19966: printf(" %d", n_doc_txt_len);
! 19967: printf(" %d", n_txt_encoding);
! 19968: printf("\n");
! 19969: }
! 19970: }
! 19971: }
! 19972: }
! 19973: }
! 19974: function_tests++;
! 19975: #endif
! 19976:
! 19977: return(test_ret);
! 19978: }
! 19979:
! 19980:
! 19981: static int
! 19982: test_xmlDocFormatDump(void) {
! 19983: int test_ret = 0;
! 19984:
! 19985: #if defined(LIBXML_OUTPUT_ENABLED)
! 19986: int mem_base;
! 19987: int ret_val;
! 19988: FILE * f; /* the FILE* */
! 19989: int n_f;
! 19990: xmlDocPtr cur; /* the document */
! 19991: int n_cur;
! 19992: int format; /* should formatting spaces been added */
! 19993: int n_format;
! 19994:
! 19995: for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
! 19996: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
! 19997: for (n_format = 0;n_format < gen_nb_int;n_format++) {
! 19998: mem_base = xmlMemBlocks();
! 19999: f = gen_FILE_ptr(n_f, 0);
! 20000: cur = gen_xmlDocPtr(n_cur, 1);
! 20001: format = gen_int(n_format, 2);
! 20002:
! 20003: ret_val = xmlDocFormatDump(f, cur, format);
! 20004: desret_int(ret_val);
! 20005: call_tests++;
! 20006: des_FILE_ptr(n_f, f, 0);
! 20007: des_xmlDocPtr(n_cur, cur, 1);
! 20008: des_int(n_format, format, 2);
! 20009: xmlResetLastError();
! 20010: if (mem_base != xmlMemBlocks()) {
! 20011: printf("Leak of %d blocks found in xmlDocFormatDump",
! 20012: xmlMemBlocks() - mem_base);
! 20013: test_ret++;
! 20014: printf(" %d", n_f);
! 20015: printf(" %d", n_cur);
! 20016: printf(" %d", n_format);
! 20017: printf("\n");
! 20018: }
! 20019: }
! 20020: }
! 20021: }
! 20022: function_tests++;
! 20023: #endif
! 20024:
! 20025: return(test_ret);
! 20026: }
! 20027:
! 20028:
! 20029: static int
! 20030: test_xmlDocGetRootElement(void) {
! 20031: int test_ret = 0;
! 20032:
! 20033: int mem_base;
! 20034: xmlNodePtr ret_val;
! 20035: xmlDocPtr doc; /* the document */
! 20036: int n_doc;
! 20037:
! 20038: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 20039: mem_base = xmlMemBlocks();
! 20040: doc = gen_xmlDocPtr(n_doc, 0);
! 20041:
! 20042: ret_val = xmlDocGetRootElement(doc);
! 20043: desret_xmlNodePtr(ret_val);
! 20044: call_tests++;
! 20045: des_xmlDocPtr(n_doc, doc, 0);
! 20046: xmlResetLastError();
! 20047: if (mem_base != xmlMemBlocks()) {
! 20048: printf("Leak of %d blocks found in xmlDocGetRootElement",
! 20049: xmlMemBlocks() - mem_base);
! 20050: test_ret++;
! 20051: printf(" %d", n_doc);
! 20052: printf("\n");
! 20053: }
! 20054: }
! 20055: function_tests++;
! 20056:
! 20057: return(test_ret);
! 20058: }
! 20059:
! 20060:
! 20061: static int
! 20062: test_xmlDocSetRootElement(void) {
! 20063: int test_ret = 0;
! 20064:
! 20065: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
! 20066: int mem_base;
! 20067: xmlNodePtr ret_val;
! 20068: xmlDocPtr doc; /* the document */
! 20069: int n_doc;
! 20070: 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. */
! 20071: int n_root;
! 20072:
! 20073: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 20074: for (n_root = 0;n_root < gen_nb_xmlNodePtr_in;n_root++) {
! 20075: mem_base = xmlMemBlocks();
! 20076: doc = gen_xmlDocPtr(n_doc, 0);
! 20077: root = gen_xmlNodePtr_in(n_root, 1);
! 20078:
! 20079: ret_val = xmlDocSetRootElement(doc, root);
! 20080: if (doc == NULL) { xmlFreeNode(root) ; root = NULL ; }
! 20081: desret_xmlNodePtr(ret_val);
! 20082: call_tests++;
! 20083: des_xmlDocPtr(n_doc, doc, 0);
! 20084: des_xmlNodePtr_in(n_root, root, 1);
! 20085: xmlResetLastError();
! 20086: if (mem_base != xmlMemBlocks()) {
! 20087: printf("Leak of %d blocks found in xmlDocSetRootElement",
! 20088: xmlMemBlocks() - mem_base);
! 20089: test_ret++;
! 20090: printf(" %d", n_doc);
! 20091: printf(" %d", n_root);
! 20092: printf("\n");
! 20093: }
! 20094: }
! 20095: }
! 20096: function_tests++;
! 20097: #endif
! 20098:
! 20099: return(test_ret);
! 20100: }
! 20101:
! 20102:
! 20103: static int
! 20104: test_xmlElemDump(void) {
! 20105: int test_ret = 0;
! 20106:
! 20107: #if defined(LIBXML_OUTPUT_ENABLED)
! 20108: int mem_base;
! 20109: FILE * f; /* the FILE * for the output */
! 20110: int n_f;
! 20111: xmlDocPtr doc; /* the document */
! 20112: int n_doc;
! 20113: xmlNodePtr cur; /* the current node */
! 20114: int n_cur;
! 20115:
! 20116: for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
! 20117: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 20118: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 20119: mem_base = xmlMemBlocks();
! 20120: f = gen_FILE_ptr(n_f, 0);
! 20121: doc = gen_xmlDocPtr(n_doc, 1);
! 20122: cur = gen_xmlNodePtr(n_cur, 2);
! 20123:
! 20124: xmlElemDump(f, doc, cur);
! 20125: call_tests++;
! 20126: des_FILE_ptr(n_f, f, 0);
! 20127: des_xmlDocPtr(n_doc, doc, 1);
! 20128: des_xmlNodePtr(n_cur, cur, 2);
! 20129: xmlResetLastError();
! 20130: if (mem_base != xmlMemBlocks()) {
! 20131: printf("Leak of %d blocks found in xmlElemDump",
! 20132: xmlMemBlocks() - mem_base);
! 20133: test_ret++;
! 20134: printf(" %d", n_f);
! 20135: printf(" %d", n_doc);
! 20136: printf(" %d", n_cur);
! 20137: printf("\n");
! 20138: }
! 20139: }
! 20140: }
! 20141: }
! 20142: function_tests++;
! 20143: #endif
! 20144:
! 20145: return(test_ret);
! 20146: }
! 20147:
! 20148:
! 20149: static int
! 20150: test_xmlFirstElementChild(void) {
! 20151: int test_ret = 0;
! 20152:
! 20153: #if defined(LIBXML_TREE_ENABLED)
! 20154: int mem_base;
! 20155: xmlNodePtr ret_val;
! 20156: xmlNodePtr parent; /* the parent node */
! 20157: int n_parent;
! 20158:
! 20159: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
! 20160: mem_base = xmlMemBlocks();
! 20161: parent = gen_xmlNodePtr(n_parent, 0);
! 20162:
! 20163: ret_val = xmlFirstElementChild(parent);
! 20164: desret_xmlNodePtr(ret_val);
! 20165: call_tests++;
! 20166: des_xmlNodePtr(n_parent, parent, 0);
! 20167: xmlResetLastError();
! 20168: if (mem_base != xmlMemBlocks()) {
! 20169: printf("Leak of %d blocks found in xmlFirstElementChild",
! 20170: xmlMemBlocks() - mem_base);
! 20171: test_ret++;
! 20172: printf(" %d", n_parent);
! 20173: printf("\n");
! 20174: }
! 20175: }
! 20176: function_tests++;
! 20177: #endif
! 20178:
! 20179: return(test_ret);
! 20180: }
! 20181:
! 20182:
! 20183: static int
! 20184: test_xmlGetBufferAllocationScheme(void) {
! 20185: int test_ret = 0;
! 20186:
! 20187: int mem_base;
! 20188: xmlBufferAllocationScheme ret_val;
! 20189:
! 20190: mem_base = xmlMemBlocks();
! 20191:
! 20192: ret_val = xmlGetBufferAllocationScheme();
! 20193: desret_xmlBufferAllocationScheme(ret_val);
! 20194: call_tests++;
! 20195: xmlResetLastError();
! 20196: if (mem_base != xmlMemBlocks()) {
! 20197: printf("Leak of %d blocks found in xmlGetBufferAllocationScheme",
! 20198: xmlMemBlocks() - mem_base);
! 20199: test_ret++;
! 20200: printf("\n");
! 20201: }
! 20202: function_tests++;
! 20203:
! 20204: return(test_ret);
! 20205: }
! 20206:
! 20207:
! 20208: static int
! 20209: test_xmlGetCompressMode(void) {
! 20210: int test_ret = 0;
! 20211:
! 20212: int mem_base;
! 20213: int ret_val;
! 20214:
! 20215: mem_base = xmlMemBlocks();
! 20216:
! 20217: ret_val = xmlGetCompressMode();
! 20218: desret_int(ret_val);
! 20219: call_tests++;
! 20220: xmlResetLastError();
! 20221: if (mem_base != xmlMemBlocks()) {
! 20222: printf("Leak of %d blocks found in xmlGetCompressMode",
! 20223: xmlMemBlocks() - mem_base);
! 20224: test_ret++;
! 20225: printf("\n");
! 20226: }
! 20227: function_tests++;
! 20228:
! 20229: return(test_ret);
! 20230: }
! 20231:
! 20232:
! 20233: static int
! 20234: test_xmlGetDocCompressMode(void) {
! 20235: int test_ret = 0;
! 20236:
! 20237: int mem_base;
! 20238: int ret_val;
! 20239: xmlDocPtr doc; /* the document */
! 20240: int n_doc;
! 20241:
! 20242: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 20243: mem_base = xmlMemBlocks();
! 20244: doc = gen_xmlDocPtr(n_doc, 0);
! 20245:
! 20246: ret_val = xmlGetDocCompressMode(doc);
! 20247: desret_int(ret_val);
! 20248: call_tests++;
! 20249: des_xmlDocPtr(n_doc, doc, 0);
! 20250: xmlResetLastError();
! 20251: if (mem_base != xmlMemBlocks()) {
! 20252: printf("Leak of %d blocks found in xmlGetDocCompressMode",
! 20253: xmlMemBlocks() - mem_base);
! 20254: test_ret++;
! 20255: printf(" %d", n_doc);
! 20256: printf("\n");
! 20257: }
! 20258: }
! 20259: function_tests++;
! 20260:
! 20261: return(test_ret);
! 20262: }
! 20263:
! 20264:
! 20265: static int
! 20266: test_xmlGetIntSubset(void) {
! 20267: int test_ret = 0;
! 20268:
! 20269: int mem_base;
! 20270: xmlDtdPtr ret_val;
! 20271: xmlDocPtr doc; /* the document pointer */
! 20272: int n_doc;
! 20273:
! 20274: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 20275: mem_base = xmlMemBlocks();
! 20276: doc = gen_xmlDocPtr(n_doc, 0);
! 20277:
! 20278: ret_val = xmlGetIntSubset(doc);
! 20279: desret_xmlDtdPtr(ret_val);
! 20280: call_tests++;
! 20281: des_xmlDocPtr(n_doc, doc, 0);
! 20282: xmlResetLastError();
! 20283: if (mem_base != xmlMemBlocks()) {
! 20284: printf("Leak of %d blocks found in xmlGetIntSubset",
! 20285: xmlMemBlocks() - mem_base);
! 20286: test_ret++;
! 20287: printf(" %d", n_doc);
! 20288: printf("\n");
! 20289: }
! 20290: }
! 20291: function_tests++;
! 20292:
! 20293: return(test_ret);
! 20294: }
! 20295:
! 20296:
! 20297: static int
! 20298: test_xmlGetLastChild(void) {
! 20299: int test_ret = 0;
! 20300:
! 20301: int mem_base;
! 20302: xmlNodePtr ret_val;
! 20303: xmlNodePtr parent; /* the parent node */
! 20304: int n_parent;
! 20305:
! 20306: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
! 20307: mem_base = xmlMemBlocks();
! 20308: parent = gen_xmlNodePtr(n_parent, 0);
! 20309:
! 20310: ret_val = xmlGetLastChild(parent);
! 20311: desret_xmlNodePtr(ret_val);
! 20312: call_tests++;
! 20313: des_xmlNodePtr(n_parent, parent, 0);
! 20314: xmlResetLastError();
! 20315: if (mem_base != xmlMemBlocks()) {
! 20316: printf("Leak of %d blocks found in xmlGetLastChild",
! 20317: xmlMemBlocks() - mem_base);
! 20318: test_ret++;
! 20319: printf(" %d", n_parent);
! 20320: printf("\n");
! 20321: }
! 20322: }
! 20323: function_tests++;
! 20324:
! 20325: return(test_ret);
! 20326: }
! 20327:
! 20328:
! 20329: static int
! 20330: test_xmlGetLineNo(void) {
! 20331: int test_ret = 0;
! 20332:
! 20333: int mem_base;
! 20334: long ret_val;
! 20335: xmlNodePtr node; /* valid node */
! 20336: int n_node;
! 20337:
! 20338: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 20339: mem_base = xmlMemBlocks();
! 20340: node = gen_xmlNodePtr(n_node, 0);
! 20341:
! 20342: ret_val = xmlGetLineNo(node);
! 20343: desret_long(ret_val);
! 20344: call_tests++;
! 20345: des_xmlNodePtr(n_node, node, 0);
! 20346: xmlResetLastError();
! 20347: if (mem_base != xmlMemBlocks()) {
! 20348: printf("Leak of %d blocks found in xmlGetLineNo",
! 20349: xmlMemBlocks() - mem_base);
! 20350: test_ret++;
! 20351: printf(" %d", n_node);
! 20352: printf("\n");
! 20353: }
! 20354: }
! 20355: function_tests++;
! 20356:
! 20357: return(test_ret);
! 20358: }
! 20359:
! 20360:
! 20361: static int
! 20362: test_xmlGetNoNsProp(void) {
! 20363: int test_ret = 0;
! 20364:
! 20365: int mem_base;
! 20366: xmlChar * ret_val;
! 20367: xmlNodePtr node; /* the node */
! 20368: int n_node;
! 20369: xmlChar * name; /* the attribute name */
! 20370: int n_name;
! 20371:
! 20372: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 20373: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 20374: mem_base = xmlMemBlocks();
! 20375: node = gen_xmlNodePtr(n_node, 0);
! 20376: name = gen_const_xmlChar_ptr(n_name, 1);
! 20377:
! 20378: ret_val = xmlGetNoNsProp(node, (const xmlChar *)name);
! 20379: desret_xmlChar_ptr(ret_val);
! 20380: call_tests++;
! 20381: des_xmlNodePtr(n_node, node, 0);
! 20382: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 20383: xmlResetLastError();
! 20384: if (mem_base != xmlMemBlocks()) {
! 20385: printf("Leak of %d blocks found in xmlGetNoNsProp",
! 20386: xmlMemBlocks() - mem_base);
! 20387: test_ret++;
! 20388: printf(" %d", n_node);
! 20389: printf(" %d", n_name);
! 20390: printf("\n");
! 20391: }
! 20392: }
! 20393: }
! 20394: function_tests++;
! 20395:
! 20396: return(test_ret);
! 20397: }
! 20398:
! 20399:
! 20400: static int
! 20401: test_xmlGetNodePath(void) {
! 20402: int test_ret = 0;
! 20403:
! 20404: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
! 20405: int mem_base;
! 20406: xmlChar * ret_val;
! 20407: xmlNodePtr node; /* a node */
! 20408: int n_node;
! 20409:
! 20410: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 20411: mem_base = xmlMemBlocks();
! 20412: node = gen_xmlNodePtr(n_node, 0);
! 20413:
! 20414: ret_val = xmlGetNodePath(node);
! 20415: desret_xmlChar_ptr(ret_val);
! 20416: call_tests++;
! 20417: des_xmlNodePtr(n_node, node, 0);
! 20418: xmlResetLastError();
! 20419: if (mem_base != xmlMemBlocks()) {
! 20420: printf("Leak of %d blocks found in xmlGetNodePath",
! 20421: xmlMemBlocks() - mem_base);
! 20422: test_ret++;
! 20423: printf(" %d", n_node);
! 20424: printf("\n");
! 20425: }
! 20426: }
! 20427: function_tests++;
! 20428: #endif
! 20429:
! 20430: return(test_ret);
! 20431: }
! 20432:
! 20433:
! 20434: static int
! 20435: test_xmlGetNsList(void) {
! 20436: int test_ret = 0;
! 20437:
! 20438:
! 20439: /* missing type support */
! 20440: return(test_ret);
! 20441: }
! 20442:
! 20443:
! 20444: static int
! 20445: test_xmlGetNsProp(void) {
! 20446: int test_ret = 0;
! 20447:
! 20448: int mem_base;
! 20449: xmlChar * ret_val;
! 20450: xmlNodePtr node; /* the node */
! 20451: int n_node;
! 20452: xmlChar * name; /* the attribute name */
! 20453: int n_name;
! 20454: xmlChar * nameSpace; /* the URI of the namespace */
! 20455: int n_nameSpace;
! 20456:
! 20457: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 20458: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 20459: for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) {
! 20460: mem_base = xmlMemBlocks();
! 20461: node = gen_xmlNodePtr(n_node, 0);
! 20462: name = gen_const_xmlChar_ptr(n_name, 1);
! 20463: nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2);
! 20464:
! 20465: ret_val = xmlGetNsProp(node, (const xmlChar *)name, (const xmlChar *)nameSpace);
! 20466: desret_xmlChar_ptr(ret_val);
! 20467: call_tests++;
! 20468: des_xmlNodePtr(n_node, node, 0);
! 20469: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 20470: des_const_xmlChar_ptr(n_nameSpace, (const xmlChar *)nameSpace, 2);
! 20471: xmlResetLastError();
! 20472: if (mem_base != xmlMemBlocks()) {
! 20473: printf("Leak of %d blocks found in xmlGetNsProp",
! 20474: xmlMemBlocks() - mem_base);
! 20475: test_ret++;
! 20476: printf(" %d", n_node);
! 20477: printf(" %d", n_name);
! 20478: printf(" %d", n_nameSpace);
! 20479: printf("\n");
! 20480: }
! 20481: }
! 20482: }
! 20483: }
! 20484: function_tests++;
! 20485:
! 20486: return(test_ret);
! 20487: }
! 20488:
! 20489:
! 20490: static int
! 20491: test_xmlGetProp(void) {
! 20492: int test_ret = 0;
! 20493:
! 20494: int mem_base;
! 20495: xmlChar * ret_val;
! 20496: xmlNodePtr node; /* the node */
! 20497: int n_node;
! 20498: xmlChar * name; /* the attribute name */
! 20499: int n_name;
! 20500:
! 20501: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 20502: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 20503: mem_base = xmlMemBlocks();
! 20504: node = gen_xmlNodePtr(n_node, 0);
! 20505: name = gen_const_xmlChar_ptr(n_name, 1);
! 20506:
! 20507: ret_val = xmlGetProp(node, (const xmlChar *)name);
! 20508: desret_xmlChar_ptr(ret_val);
! 20509: call_tests++;
! 20510: des_xmlNodePtr(n_node, node, 0);
! 20511: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 20512: xmlResetLastError();
! 20513: if (mem_base != xmlMemBlocks()) {
! 20514: printf("Leak of %d blocks found in xmlGetProp",
! 20515: xmlMemBlocks() - mem_base);
! 20516: test_ret++;
! 20517: printf(" %d", n_node);
! 20518: printf(" %d", n_name);
! 20519: printf("\n");
! 20520: }
! 20521: }
! 20522: }
! 20523: function_tests++;
! 20524:
! 20525: return(test_ret);
! 20526: }
! 20527:
! 20528:
! 20529: static int
! 20530: test_xmlHasNsProp(void) {
! 20531: int test_ret = 0;
! 20532:
! 20533: int mem_base;
! 20534: xmlAttrPtr ret_val;
! 20535: xmlNodePtr node; /* the node */
! 20536: int n_node;
! 20537: xmlChar * name; /* the attribute name */
! 20538: int n_name;
! 20539: xmlChar * nameSpace; /* the URI of the namespace */
! 20540: int n_nameSpace;
! 20541:
! 20542: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 20543: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 20544: for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) {
! 20545: mem_base = xmlMemBlocks();
! 20546: node = gen_xmlNodePtr(n_node, 0);
! 20547: name = gen_const_xmlChar_ptr(n_name, 1);
! 20548: nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2);
! 20549:
! 20550: ret_val = xmlHasNsProp(node, (const xmlChar *)name, (const xmlChar *)nameSpace);
! 20551: desret_xmlAttrPtr(ret_val);
! 20552: call_tests++;
! 20553: des_xmlNodePtr(n_node, node, 0);
! 20554: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 20555: des_const_xmlChar_ptr(n_nameSpace, (const xmlChar *)nameSpace, 2);
! 20556: xmlResetLastError();
! 20557: if (mem_base != xmlMemBlocks()) {
! 20558: printf("Leak of %d blocks found in xmlHasNsProp",
! 20559: xmlMemBlocks() - mem_base);
! 20560: test_ret++;
! 20561: printf(" %d", n_node);
! 20562: printf(" %d", n_name);
! 20563: printf(" %d", n_nameSpace);
! 20564: printf("\n");
! 20565: }
! 20566: }
! 20567: }
! 20568: }
! 20569: function_tests++;
! 20570:
! 20571: return(test_ret);
! 20572: }
! 20573:
! 20574:
! 20575: static int
! 20576: test_xmlHasProp(void) {
! 20577: int test_ret = 0;
! 20578:
! 20579: int mem_base;
! 20580: xmlAttrPtr ret_val;
! 20581: xmlNodePtr node; /* the node */
! 20582: int n_node;
! 20583: xmlChar * name; /* the attribute name */
! 20584: int n_name;
! 20585:
! 20586: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 20587: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 20588: mem_base = xmlMemBlocks();
! 20589: node = gen_xmlNodePtr(n_node, 0);
! 20590: name = gen_const_xmlChar_ptr(n_name, 1);
! 20591:
! 20592: ret_val = xmlHasProp(node, (const xmlChar *)name);
! 20593: desret_xmlAttrPtr(ret_val);
! 20594: call_tests++;
! 20595: des_xmlNodePtr(n_node, node, 0);
! 20596: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 20597: xmlResetLastError();
! 20598: if (mem_base != xmlMemBlocks()) {
! 20599: printf("Leak of %d blocks found in xmlHasProp",
! 20600: xmlMemBlocks() - mem_base);
! 20601: test_ret++;
! 20602: printf(" %d", n_node);
! 20603: printf(" %d", n_name);
! 20604: printf("\n");
! 20605: }
! 20606: }
! 20607: }
! 20608: function_tests++;
! 20609:
! 20610: return(test_ret);
! 20611: }
! 20612:
! 20613:
! 20614: static int
! 20615: test_xmlIsBlankNode(void) {
! 20616: int test_ret = 0;
! 20617:
! 20618: int mem_base;
! 20619: int ret_val;
! 20620: xmlNodePtr node; /* the node */
! 20621: int n_node;
! 20622:
! 20623: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 20624: mem_base = xmlMemBlocks();
! 20625: node = gen_xmlNodePtr(n_node, 0);
! 20626:
! 20627: ret_val = xmlIsBlankNode(node);
! 20628: desret_int(ret_val);
! 20629: call_tests++;
! 20630: des_xmlNodePtr(n_node, node, 0);
! 20631: xmlResetLastError();
! 20632: if (mem_base != xmlMemBlocks()) {
! 20633: printf("Leak of %d blocks found in xmlIsBlankNode",
! 20634: xmlMemBlocks() - mem_base);
! 20635: test_ret++;
! 20636: printf(" %d", n_node);
! 20637: printf("\n");
! 20638: }
! 20639: }
! 20640: function_tests++;
! 20641:
! 20642: return(test_ret);
! 20643: }
! 20644:
! 20645:
! 20646: static int
! 20647: test_xmlIsXHTML(void) {
! 20648: int test_ret = 0;
! 20649:
! 20650: int mem_base;
! 20651: int ret_val;
! 20652: xmlChar * systemID; /* the system identifier */
! 20653: int n_systemID;
! 20654: xmlChar * publicID; /* the public identifier */
! 20655: int n_publicID;
! 20656:
! 20657: for (n_systemID = 0;n_systemID < gen_nb_const_xmlChar_ptr;n_systemID++) {
! 20658: for (n_publicID = 0;n_publicID < gen_nb_const_xmlChar_ptr;n_publicID++) {
! 20659: mem_base = xmlMemBlocks();
! 20660: systemID = gen_const_xmlChar_ptr(n_systemID, 0);
! 20661: publicID = gen_const_xmlChar_ptr(n_publicID, 1);
! 20662:
! 20663: ret_val = xmlIsXHTML((const xmlChar *)systemID, (const xmlChar *)publicID);
! 20664: desret_int(ret_val);
! 20665: call_tests++;
! 20666: des_const_xmlChar_ptr(n_systemID, (const xmlChar *)systemID, 0);
! 20667: des_const_xmlChar_ptr(n_publicID, (const xmlChar *)publicID, 1);
! 20668: xmlResetLastError();
! 20669: if (mem_base != xmlMemBlocks()) {
! 20670: printf("Leak of %d blocks found in xmlIsXHTML",
! 20671: xmlMemBlocks() - mem_base);
! 20672: test_ret++;
! 20673: printf(" %d", n_systemID);
! 20674: printf(" %d", n_publicID);
! 20675: printf("\n");
! 20676: }
! 20677: }
! 20678: }
! 20679: function_tests++;
! 20680:
! 20681: return(test_ret);
! 20682: }
! 20683:
! 20684:
! 20685: static int
! 20686: test_xmlLastElementChild(void) {
! 20687: int test_ret = 0;
! 20688:
! 20689: #if defined(LIBXML_TREE_ENABLED)
! 20690: int mem_base;
! 20691: xmlNodePtr ret_val;
! 20692: xmlNodePtr parent; /* the parent node */
! 20693: int n_parent;
! 20694:
! 20695: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
! 20696: mem_base = xmlMemBlocks();
! 20697: parent = gen_xmlNodePtr(n_parent, 0);
! 20698:
! 20699: ret_val = xmlLastElementChild(parent);
! 20700: desret_xmlNodePtr(ret_val);
! 20701: call_tests++;
! 20702: des_xmlNodePtr(n_parent, parent, 0);
! 20703: xmlResetLastError();
! 20704: if (mem_base != xmlMemBlocks()) {
! 20705: printf("Leak of %d blocks found in xmlLastElementChild",
! 20706: xmlMemBlocks() - mem_base);
! 20707: test_ret++;
! 20708: printf(" %d", n_parent);
! 20709: printf("\n");
! 20710: }
! 20711: }
! 20712: function_tests++;
! 20713: #endif
! 20714:
! 20715: return(test_ret);
! 20716: }
! 20717:
! 20718:
! 20719: static int
! 20720: test_xmlNewCDataBlock(void) {
! 20721: int test_ret = 0;
! 20722:
! 20723: int mem_base;
! 20724: xmlNodePtr ret_val;
! 20725: xmlDocPtr doc; /* the document */
! 20726: int n_doc;
! 20727: xmlChar * content; /* the CDATA block content content */
! 20728: int n_content;
! 20729: int len; /* the length of the block */
! 20730: int n_len;
! 20731:
! 20732: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 20733: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 20734: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 20735: mem_base = xmlMemBlocks();
! 20736: doc = gen_xmlDocPtr(n_doc, 0);
! 20737: content = gen_const_xmlChar_ptr(n_content, 1);
! 20738: len = gen_int(n_len, 2);
! 20739:
! 20740: ret_val = xmlNewCDataBlock(doc, (const xmlChar *)content, len);
! 20741: desret_xmlNodePtr(ret_val);
! 20742: call_tests++;
! 20743: des_xmlDocPtr(n_doc, doc, 0);
! 20744: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
! 20745: des_int(n_len, len, 2);
! 20746: xmlResetLastError();
! 20747: if (mem_base != xmlMemBlocks()) {
! 20748: printf("Leak of %d blocks found in xmlNewCDataBlock",
! 20749: xmlMemBlocks() - mem_base);
! 20750: test_ret++;
! 20751: printf(" %d", n_doc);
! 20752: printf(" %d", n_content);
! 20753: printf(" %d", n_len);
! 20754: printf("\n");
! 20755: }
! 20756: }
! 20757: }
! 20758: }
! 20759: function_tests++;
! 20760:
! 20761: return(test_ret);
! 20762: }
! 20763:
! 20764:
! 20765: static int
! 20766: test_xmlNewCharRef(void) {
! 20767: int test_ret = 0;
! 20768:
! 20769: int mem_base;
! 20770: xmlNodePtr ret_val;
! 20771: xmlDocPtr doc; /* the document */
! 20772: int n_doc;
! 20773: xmlChar * name; /* the char ref string, starting with # or "&# ... ;" */
! 20774: int n_name;
! 20775:
! 20776: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 20777: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 20778: mem_base = xmlMemBlocks();
! 20779: doc = gen_xmlDocPtr(n_doc, 0);
! 20780: name = gen_const_xmlChar_ptr(n_name, 1);
! 20781:
! 20782: ret_val = xmlNewCharRef(doc, (const xmlChar *)name);
! 20783: desret_xmlNodePtr(ret_val);
! 20784: call_tests++;
! 20785: des_xmlDocPtr(n_doc, doc, 0);
! 20786: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 20787: xmlResetLastError();
! 20788: if (mem_base != xmlMemBlocks()) {
! 20789: printf("Leak of %d blocks found in xmlNewCharRef",
! 20790: xmlMemBlocks() - mem_base);
! 20791: test_ret++;
! 20792: printf(" %d", n_doc);
! 20793: printf(" %d", n_name);
! 20794: printf("\n");
! 20795: }
! 20796: }
! 20797: }
! 20798: function_tests++;
! 20799:
! 20800: return(test_ret);
! 20801: }
! 20802:
! 20803:
! 20804: static int
! 20805: test_xmlNewChild(void) {
! 20806: int test_ret = 0;
! 20807:
! 20808: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 20809: #ifdef LIBXML_TREE_ENABLED
! 20810: int mem_base;
! 20811: xmlNodePtr ret_val;
! 20812: xmlNodePtr parent; /* the parent node */
! 20813: int n_parent;
! 20814: xmlNsPtr ns; /* a namespace if any */
! 20815: int n_ns;
! 20816: xmlChar * name; /* the name of the child */
! 20817: int n_name;
! 20818: xmlChar * content; /* the XML content of the child if any. */
! 20819: int n_content;
! 20820:
! 20821: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
! 20822: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
! 20823: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 20824: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 20825: mem_base = xmlMemBlocks();
! 20826: parent = gen_xmlNodePtr(n_parent, 0);
! 20827: ns = gen_xmlNsPtr(n_ns, 1);
! 20828: name = gen_const_xmlChar_ptr(n_name, 2);
! 20829: content = gen_const_xmlChar_ptr(n_content, 3);
! 20830:
! 20831: ret_val = xmlNewChild(parent, ns, (const xmlChar *)name, (const xmlChar *)content);
! 20832: desret_xmlNodePtr(ret_val);
! 20833: call_tests++;
! 20834: des_xmlNodePtr(n_parent, parent, 0);
! 20835: des_xmlNsPtr(n_ns, ns, 1);
! 20836: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 20837: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
! 20838: xmlResetLastError();
! 20839: if (mem_base != xmlMemBlocks()) {
! 20840: printf("Leak of %d blocks found in xmlNewChild",
! 20841: xmlMemBlocks() - mem_base);
! 20842: test_ret++;
! 20843: printf(" %d", n_parent);
! 20844: printf(" %d", n_ns);
! 20845: printf(" %d", n_name);
! 20846: printf(" %d", n_content);
! 20847: printf("\n");
! 20848: }
! 20849: }
! 20850: }
! 20851: }
! 20852: }
! 20853: function_tests++;
! 20854: #endif
! 20855: #endif
! 20856:
! 20857: return(test_ret);
! 20858: }
! 20859:
! 20860:
! 20861: static int
! 20862: test_xmlNewComment(void) {
! 20863: int test_ret = 0;
! 20864:
! 20865: int mem_base;
! 20866: xmlNodePtr ret_val;
! 20867: xmlChar * content; /* the comment content */
! 20868: int n_content;
! 20869:
! 20870: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 20871: mem_base = xmlMemBlocks();
! 20872: content = gen_const_xmlChar_ptr(n_content, 0);
! 20873:
! 20874: ret_val = xmlNewComment((const xmlChar *)content);
! 20875: desret_xmlNodePtr(ret_val);
! 20876: call_tests++;
! 20877: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 0);
! 20878: xmlResetLastError();
! 20879: if (mem_base != xmlMemBlocks()) {
! 20880: printf("Leak of %d blocks found in xmlNewComment",
! 20881: xmlMemBlocks() - mem_base);
! 20882: test_ret++;
! 20883: printf(" %d", n_content);
! 20884: printf("\n");
! 20885: }
! 20886: }
! 20887: function_tests++;
! 20888:
! 20889: return(test_ret);
! 20890: }
! 20891:
! 20892:
! 20893: static int
! 20894: test_xmlNewDoc(void) {
! 20895: int test_ret = 0;
! 20896:
! 20897: int mem_base;
! 20898: xmlDocPtr ret_val;
! 20899: xmlChar * version; /* xmlChar string giving the version of XML "1.0" */
! 20900: int n_version;
! 20901:
! 20902: for (n_version = 0;n_version < gen_nb_const_xmlChar_ptr;n_version++) {
! 20903: mem_base = xmlMemBlocks();
! 20904: version = gen_const_xmlChar_ptr(n_version, 0);
! 20905:
! 20906: ret_val = xmlNewDoc((const xmlChar *)version);
! 20907: desret_xmlDocPtr(ret_val);
! 20908: call_tests++;
! 20909: des_const_xmlChar_ptr(n_version, (const xmlChar *)version, 0);
! 20910: xmlResetLastError();
! 20911: if (mem_base != xmlMemBlocks()) {
! 20912: printf("Leak of %d blocks found in xmlNewDoc",
! 20913: xmlMemBlocks() - mem_base);
! 20914: test_ret++;
! 20915: printf(" %d", n_version);
! 20916: printf("\n");
! 20917: }
! 20918: }
! 20919: function_tests++;
! 20920:
! 20921: return(test_ret);
! 20922: }
! 20923:
! 20924:
! 20925: static int
! 20926: test_xmlNewDocComment(void) {
! 20927: int test_ret = 0;
! 20928:
! 20929: int mem_base;
! 20930: xmlNodePtr ret_val;
! 20931: xmlDocPtr doc; /* the document */
! 20932: int n_doc;
! 20933: xmlChar * content; /* the comment content */
! 20934: int n_content;
! 20935:
! 20936: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 20937: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 20938: mem_base = xmlMemBlocks();
! 20939: doc = gen_xmlDocPtr(n_doc, 0);
! 20940: content = gen_const_xmlChar_ptr(n_content, 1);
! 20941:
! 20942: ret_val = xmlNewDocComment(doc, (const xmlChar *)content);
! 20943: desret_xmlNodePtr(ret_val);
! 20944: call_tests++;
! 20945: des_xmlDocPtr(n_doc, doc, 0);
! 20946: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
! 20947: xmlResetLastError();
! 20948: if (mem_base != xmlMemBlocks()) {
! 20949: printf("Leak of %d blocks found in xmlNewDocComment",
! 20950: xmlMemBlocks() - mem_base);
! 20951: test_ret++;
! 20952: printf(" %d", n_doc);
! 20953: printf(" %d", n_content);
! 20954: printf("\n");
! 20955: }
! 20956: }
! 20957: }
! 20958: function_tests++;
! 20959:
! 20960: return(test_ret);
! 20961: }
! 20962:
! 20963:
! 20964: static int
! 20965: test_xmlNewDocFragment(void) {
! 20966: int test_ret = 0;
! 20967:
! 20968: #if defined(LIBXML_TREE_ENABLED)
! 20969: int mem_base;
! 20970: xmlNodePtr ret_val;
! 20971: xmlDocPtr doc; /* the document owning the fragment */
! 20972: int n_doc;
! 20973:
! 20974: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 20975: mem_base = xmlMemBlocks();
! 20976: doc = gen_xmlDocPtr(n_doc, 0);
! 20977:
! 20978: ret_val = xmlNewDocFragment(doc);
! 20979: desret_xmlNodePtr(ret_val);
! 20980: call_tests++;
! 20981: des_xmlDocPtr(n_doc, doc, 0);
! 20982: xmlResetLastError();
! 20983: if (mem_base != xmlMemBlocks()) {
! 20984: printf("Leak of %d blocks found in xmlNewDocFragment",
! 20985: xmlMemBlocks() - mem_base);
! 20986: test_ret++;
! 20987: printf(" %d", n_doc);
! 20988: printf("\n");
! 20989: }
! 20990: }
! 20991: function_tests++;
! 20992: #endif
! 20993:
! 20994: return(test_ret);
! 20995: }
! 20996:
! 20997:
! 20998: static int
! 20999: test_xmlNewDocNode(void) {
! 21000: int test_ret = 0;
! 21001:
! 21002: int mem_base;
! 21003: xmlNodePtr ret_val;
! 21004: xmlDocPtr doc; /* the document */
! 21005: int n_doc;
! 21006: xmlNsPtr ns; /* namespace if any */
! 21007: int n_ns;
! 21008: xmlChar * name; /* the node name */
! 21009: int n_name;
! 21010: xmlChar * content; /* the XML text content if any */
! 21011: int n_content;
! 21012:
! 21013: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 21014: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
! 21015: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 21016: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 21017: mem_base = xmlMemBlocks();
! 21018: doc = gen_xmlDocPtr(n_doc, 0);
! 21019: ns = gen_xmlNsPtr(n_ns, 1);
! 21020: name = gen_const_xmlChar_ptr(n_name, 2);
! 21021: content = gen_const_xmlChar_ptr(n_content, 3);
! 21022:
! 21023: ret_val = xmlNewDocNode(doc, ns, (const xmlChar *)name, (const xmlChar *)content);
! 21024: desret_xmlNodePtr(ret_val);
! 21025: call_tests++;
! 21026: des_xmlDocPtr(n_doc, doc, 0);
! 21027: des_xmlNsPtr(n_ns, ns, 1);
! 21028: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 21029: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
! 21030: xmlResetLastError();
! 21031: if (mem_base != xmlMemBlocks()) {
! 21032: printf("Leak of %d blocks found in xmlNewDocNode",
! 21033: xmlMemBlocks() - mem_base);
! 21034: test_ret++;
! 21035: printf(" %d", n_doc);
! 21036: printf(" %d", n_ns);
! 21037: printf(" %d", n_name);
! 21038: printf(" %d", n_content);
! 21039: printf("\n");
! 21040: }
! 21041: }
! 21042: }
! 21043: }
! 21044: }
! 21045: function_tests++;
! 21046:
! 21047: return(test_ret);
! 21048: }
! 21049:
! 21050:
! 21051: static int
! 21052: test_xmlNewDocNodeEatName(void) {
! 21053: int test_ret = 0;
! 21054:
! 21055: int mem_base;
! 21056: xmlNodePtr ret_val;
! 21057: xmlDocPtr doc; /* the document */
! 21058: int n_doc;
! 21059: xmlNsPtr ns; /* namespace if any */
! 21060: int n_ns;
! 21061: xmlChar * name; /* the node name */
! 21062: int n_name;
! 21063: xmlChar * content; /* the XML text content if any */
! 21064: int n_content;
! 21065:
! 21066: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 21067: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
! 21068: for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) {
! 21069: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 21070: mem_base = xmlMemBlocks();
! 21071: doc = gen_xmlDocPtr(n_doc, 0);
! 21072: ns = gen_xmlNsPtr(n_ns, 1);
! 21073: name = gen_eaten_name(n_name, 2);
! 21074: content = gen_const_xmlChar_ptr(n_content, 3);
! 21075:
! 21076: ret_val = xmlNewDocNodeEatName(doc, ns, name, (const xmlChar *)content);
! 21077: desret_xmlNodePtr(ret_val);
! 21078: call_tests++;
! 21079: des_xmlDocPtr(n_doc, doc, 0);
! 21080: des_xmlNsPtr(n_ns, ns, 1);
! 21081: des_eaten_name(n_name, name, 2);
! 21082: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
! 21083: xmlResetLastError();
! 21084: if (mem_base != xmlMemBlocks()) {
! 21085: printf("Leak of %d blocks found in xmlNewDocNodeEatName",
! 21086: xmlMemBlocks() - mem_base);
! 21087: test_ret++;
! 21088: printf(" %d", n_doc);
! 21089: printf(" %d", n_ns);
! 21090: printf(" %d", n_name);
! 21091: printf(" %d", n_content);
! 21092: printf("\n");
! 21093: }
! 21094: }
! 21095: }
! 21096: }
! 21097: }
! 21098: function_tests++;
! 21099:
! 21100: return(test_ret);
! 21101: }
! 21102:
! 21103:
! 21104: static int
! 21105: test_xmlNewDocPI(void) {
! 21106: int test_ret = 0;
! 21107:
! 21108: int mem_base;
! 21109: xmlNodePtr ret_val;
! 21110: xmlDocPtr doc; /* the target document */
! 21111: int n_doc;
! 21112: xmlChar * name; /* the processing instruction name */
! 21113: int n_name;
! 21114: xmlChar * content; /* the PI content */
! 21115: int n_content;
! 21116:
! 21117: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 21118: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 21119: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 21120: mem_base = xmlMemBlocks();
! 21121: doc = gen_xmlDocPtr(n_doc, 0);
! 21122: name = gen_const_xmlChar_ptr(n_name, 1);
! 21123: content = gen_const_xmlChar_ptr(n_content, 2);
! 21124:
! 21125: ret_val = xmlNewDocPI(doc, (const xmlChar *)name, (const xmlChar *)content);
! 21126: desret_xmlNodePtr(ret_val);
! 21127: call_tests++;
! 21128: des_xmlDocPtr(n_doc, doc, 0);
! 21129: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 21130: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
! 21131: xmlResetLastError();
! 21132: if (mem_base != xmlMemBlocks()) {
! 21133: printf("Leak of %d blocks found in xmlNewDocPI",
! 21134: xmlMemBlocks() - mem_base);
! 21135: test_ret++;
! 21136: printf(" %d", n_doc);
! 21137: printf(" %d", n_name);
! 21138: printf(" %d", n_content);
! 21139: printf("\n");
! 21140: }
! 21141: }
! 21142: }
! 21143: }
! 21144: function_tests++;
! 21145:
! 21146: return(test_ret);
! 21147: }
! 21148:
! 21149:
! 21150: static int
! 21151: test_xmlNewDocProp(void) {
! 21152: int test_ret = 0;
! 21153:
! 21154: int mem_base;
! 21155: xmlAttrPtr ret_val;
! 21156: xmlDocPtr doc; /* the document */
! 21157: int n_doc;
! 21158: xmlChar * name; /* the name of the attribute */
! 21159: int n_name;
! 21160: xmlChar * value; /* the value of the attribute */
! 21161: int n_value;
! 21162:
! 21163: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 21164: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 21165: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 21166: mem_base = xmlMemBlocks();
! 21167: doc = gen_xmlDocPtr(n_doc, 0);
! 21168: name = gen_const_xmlChar_ptr(n_name, 1);
! 21169: value = gen_const_xmlChar_ptr(n_value, 2);
! 21170:
! 21171: ret_val = xmlNewDocProp(doc, (const xmlChar *)name, (const xmlChar *)value);
! 21172: desret_xmlAttrPtr(ret_val);
! 21173: call_tests++;
! 21174: des_xmlDocPtr(n_doc, doc, 0);
! 21175: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 21176: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
! 21177: xmlResetLastError();
! 21178: if (mem_base != xmlMemBlocks()) {
! 21179: printf("Leak of %d blocks found in xmlNewDocProp",
! 21180: xmlMemBlocks() - mem_base);
! 21181: test_ret++;
! 21182: printf(" %d", n_doc);
! 21183: printf(" %d", n_name);
! 21184: printf(" %d", n_value);
! 21185: printf("\n");
! 21186: }
! 21187: }
! 21188: }
! 21189: }
! 21190: function_tests++;
! 21191:
! 21192: return(test_ret);
! 21193: }
! 21194:
! 21195:
! 21196: static int
! 21197: test_xmlNewDocRawNode(void) {
! 21198: int test_ret = 0;
! 21199:
! 21200: #if defined(LIBXML_TREE_ENABLED)
! 21201: #ifdef LIBXML_TREE_ENABLED
! 21202: int mem_base;
! 21203: xmlNodePtr ret_val;
! 21204: xmlDocPtr doc; /* the document */
! 21205: int n_doc;
! 21206: xmlNsPtr ns; /* namespace if any */
! 21207: int n_ns;
! 21208: xmlChar * name; /* the node name */
! 21209: int n_name;
! 21210: xmlChar * content; /* the text content if any */
! 21211: int n_content;
! 21212:
! 21213: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 21214: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
! 21215: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 21216: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 21217: mem_base = xmlMemBlocks();
! 21218: doc = gen_xmlDocPtr(n_doc, 0);
! 21219: ns = gen_xmlNsPtr(n_ns, 1);
! 21220: name = gen_const_xmlChar_ptr(n_name, 2);
! 21221: content = gen_const_xmlChar_ptr(n_content, 3);
! 21222:
! 21223: ret_val = xmlNewDocRawNode(doc, ns, (const xmlChar *)name, (const xmlChar *)content);
! 21224: desret_xmlNodePtr(ret_val);
! 21225: call_tests++;
! 21226: des_xmlDocPtr(n_doc, doc, 0);
! 21227: des_xmlNsPtr(n_ns, ns, 1);
! 21228: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 21229: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
! 21230: xmlResetLastError();
! 21231: if (mem_base != xmlMemBlocks()) {
! 21232: printf("Leak of %d blocks found in xmlNewDocRawNode",
! 21233: xmlMemBlocks() - mem_base);
! 21234: test_ret++;
! 21235: printf(" %d", n_doc);
! 21236: printf(" %d", n_ns);
! 21237: printf(" %d", n_name);
! 21238: printf(" %d", n_content);
! 21239: printf("\n");
! 21240: }
! 21241: }
! 21242: }
! 21243: }
! 21244: }
! 21245: function_tests++;
! 21246: #endif
! 21247: #endif
! 21248:
! 21249: return(test_ret);
! 21250: }
! 21251:
! 21252:
! 21253: static int
! 21254: test_xmlNewDocText(void) {
! 21255: int test_ret = 0;
! 21256:
! 21257: int mem_base;
! 21258: xmlNodePtr ret_val;
! 21259: xmlDocPtr doc; /* the document */
! 21260: int n_doc;
! 21261: xmlChar * content; /* the text content */
! 21262: int n_content;
! 21263:
! 21264: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 21265: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 21266: mem_base = xmlMemBlocks();
! 21267: doc = gen_xmlDocPtr(n_doc, 0);
! 21268: content = gen_const_xmlChar_ptr(n_content, 1);
! 21269:
! 21270: ret_val = xmlNewDocText(doc, (const xmlChar *)content);
! 21271: desret_xmlNodePtr(ret_val);
! 21272: call_tests++;
! 21273: des_xmlDocPtr(n_doc, doc, 0);
! 21274: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
! 21275: xmlResetLastError();
! 21276: if (mem_base != xmlMemBlocks()) {
! 21277: printf("Leak of %d blocks found in xmlNewDocText",
! 21278: xmlMemBlocks() - mem_base);
! 21279: test_ret++;
! 21280: printf(" %d", n_doc);
! 21281: printf(" %d", n_content);
! 21282: printf("\n");
! 21283: }
! 21284: }
! 21285: }
! 21286: function_tests++;
! 21287:
! 21288: return(test_ret);
! 21289: }
! 21290:
! 21291:
! 21292: static int
! 21293: test_xmlNewDocTextLen(void) {
! 21294: int test_ret = 0;
! 21295:
! 21296: int mem_base;
! 21297: xmlNodePtr ret_val;
! 21298: xmlDocPtr doc; /* the document */
! 21299: int n_doc;
! 21300: xmlChar * content; /* the text content */
! 21301: int n_content;
! 21302: int len; /* the text len. */
! 21303: int n_len;
! 21304:
! 21305: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 21306: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 21307: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 21308: mem_base = xmlMemBlocks();
! 21309: doc = gen_xmlDocPtr(n_doc, 0);
! 21310: content = gen_const_xmlChar_ptr(n_content, 1);
! 21311: len = gen_int(n_len, 2);
! 21312:
! 21313: ret_val = xmlNewDocTextLen(doc, (const xmlChar *)content, len);
! 21314: desret_xmlNodePtr(ret_val);
! 21315: call_tests++;
! 21316: des_xmlDocPtr(n_doc, doc, 0);
! 21317: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
! 21318: des_int(n_len, len, 2);
! 21319: xmlResetLastError();
! 21320: if (mem_base != xmlMemBlocks()) {
! 21321: printf("Leak of %d blocks found in xmlNewDocTextLen",
! 21322: xmlMemBlocks() - mem_base);
! 21323: test_ret++;
! 21324: printf(" %d", n_doc);
! 21325: printf(" %d", n_content);
! 21326: printf(" %d", n_len);
! 21327: printf("\n");
! 21328: }
! 21329: }
! 21330: }
! 21331: }
! 21332: function_tests++;
! 21333:
! 21334: return(test_ret);
! 21335: }
! 21336:
! 21337:
! 21338: static int
! 21339: test_xmlNewDtd(void) {
! 21340: int test_ret = 0;
! 21341:
! 21342: int mem_base;
! 21343: xmlDtdPtr ret_val;
! 21344: xmlDocPtr doc; /* the document pointer */
! 21345: int n_doc;
! 21346: xmlChar * name; /* the DTD name */
! 21347: int n_name;
! 21348: xmlChar * ExternalID; /* the external ID */
! 21349: int n_ExternalID;
! 21350: xmlChar * SystemID; /* the system ID */
! 21351: int n_SystemID;
! 21352:
! 21353: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 21354: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 21355: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
! 21356: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
! 21357: mem_base = xmlMemBlocks();
! 21358: doc = gen_xmlDocPtr(n_doc, 0);
! 21359: name = gen_const_xmlChar_ptr(n_name, 1);
! 21360: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
! 21361: SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
! 21362:
! 21363: ret_val = xmlNewDtd(doc, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
! 21364: desret_xmlDtdPtr(ret_val);
! 21365: call_tests++;
! 21366: des_xmlDocPtr(n_doc, doc, 0);
! 21367: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 21368: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2);
! 21369: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3);
! 21370: xmlResetLastError();
! 21371: if (mem_base != xmlMemBlocks()) {
! 21372: printf("Leak of %d blocks found in xmlNewDtd",
! 21373: xmlMemBlocks() - mem_base);
! 21374: test_ret++;
! 21375: printf(" %d", n_doc);
! 21376: printf(" %d", n_name);
! 21377: printf(" %d", n_ExternalID);
! 21378: printf(" %d", n_SystemID);
! 21379: printf("\n");
! 21380: }
! 21381: }
! 21382: }
! 21383: }
! 21384: }
! 21385: function_tests++;
! 21386:
! 21387: return(test_ret);
! 21388: }
! 21389:
! 21390:
! 21391: static int
! 21392: test_xmlNewNode(void) {
! 21393: int test_ret = 0;
! 21394:
! 21395: int mem_base;
! 21396: xmlNodePtr ret_val;
! 21397: xmlNsPtr ns; /* namespace if any */
! 21398: int n_ns;
! 21399: xmlChar * name; /* the node name */
! 21400: int n_name;
! 21401:
! 21402: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
! 21403: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 21404: mem_base = xmlMemBlocks();
! 21405: ns = gen_xmlNsPtr(n_ns, 0);
! 21406: name = gen_const_xmlChar_ptr(n_name, 1);
! 21407:
! 21408: ret_val = xmlNewNode(ns, (const xmlChar *)name);
! 21409: desret_xmlNodePtr(ret_val);
! 21410: call_tests++;
! 21411: des_xmlNsPtr(n_ns, ns, 0);
! 21412: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 21413: xmlResetLastError();
! 21414: if (mem_base != xmlMemBlocks()) {
! 21415: printf("Leak of %d blocks found in xmlNewNode",
! 21416: xmlMemBlocks() - mem_base);
! 21417: test_ret++;
! 21418: printf(" %d", n_ns);
! 21419: printf(" %d", n_name);
! 21420: printf("\n");
! 21421: }
! 21422: }
! 21423: }
! 21424: function_tests++;
! 21425:
! 21426: return(test_ret);
! 21427: }
! 21428:
! 21429:
! 21430: static int
! 21431: test_xmlNewNodeEatName(void) {
! 21432: int test_ret = 0;
! 21433:
! 21434: int mem_base;
! 21435: xmlNodePtr ret_val;
! 21436: xmlNsPtr ns; /* namespace if any */
! 21437: int n_ns;
! 21438: xmlChar * name; /* the node name */
! 21439: int n_name;
! 21440:
! 21441: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
! 21442: for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) {
! 21443: mem_base = xmlMemBlocks();
! 21444: ns = gen_xmlNsPtr(n_ns, 0);
! 21445: name = gen_eaten_name(n_name, 1);
! 21446:
! 21447: ret_val = xmlNewNodeEatName(ns, name);
! 21448: desret_xmlNodePtr(ret_val);
! 21449: call_tests++;
! 21450: des_xmlNsPtr(n_ns, ns, 0);
! 21451: des_eaten_name(n_name, name, 1);
! 21452: xmlResetLastError();
! 21453: if (mem_base != xmlMemBlocks()) {
! 21454: printf("Leak of %d blocks found in xmlNewNodeEatName",
! 21455: xmlMemBlocks() - mem_base);
! 21456: test_ret++;
! 21457: printf(" %d", n_ns);
! 21458: printf(" %d", n_name);
! 21459: printf("\n");
! 21460: }
! 21461: }
! 21462: }
! 21463: function_tests++;
! 21464:
! 21465: return(test_ret);
! 21466: }
! 21467:
! 21468:
! 21469: static int
! 21470: test_xmlNewNs(void) {
! 21471: int test_ret = 0;
! 21472:
! 21473: int mem_base;
! 21474: xmlNsPtr ret_val;
! 21475: xmlNodePtr node; /* the element carrying the namespace */
! 21476: int n_node;
! 21477: xmlChar * href; /* the URI associated */
! 21478: int n_href;
! 21479: xmlChar * prefix; /* the prefix for the namespace */
! 21480: int n_prefix;
! 21481:
! 21482: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 21483: for (n_href = 0;n_href < gen_nb_const_xmlChar_ptr;n_href++) {
! 21484: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
! 21485: mem_base = xmlMemBlocks();
! 21486: node = gen_xmlNodePtr(n_node, 0);
! 21487: href = gen_const_xmlChar_ptr(n_href, 1);
! 21488: prefix = gen_const_xmlChar_ptr(n_prefix, 2);
! 21489:
! 21490: ret_val = xmlNewNs(node, (const xmlChar *)href, (const xmlChar *)prefix);
! 21491: if ((node == NULL) && (ret_val != NULL)) xmlFreeNs(ret_val);
! 21492: desret_xmlNsPtr(ret_val);
! 21493: call_tests++;
! 21494: des_xmlNodePtr(n_node, node, 0);
! 21495: des_const_xmlChar_ptr(n_href, (const xmlChar *)href, 1);
! 21496: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2);
! 21497: xmlResetLastError();
! 21498: if (mem_base != xmlMemBlocks()) {
! 21499: printf("Leak of %d blocks found in xmlNewNs",
! 21500: xmlMemBlocks() - mem_base);
! 21501: test_ret++;
! 21502: printf(" %d", n_node);
! 21503: printf(" %d", n_href);
! 21504: printf(" %d", n_prefix);
! 21505: printf("\n");
! 21506: }
! 21507: }
! 21508: }
! 21509: }
! 21510: function_tests++;
! 21511:
! 21512: return(test_ret);
! 21513: }
! 21514:
! 21515:
! 21516: static int
! 21517: test_xmlNewNsProp(void) {
! 21518: int test_ret = 0;
! 21519:
! 21520: int mem_base;
! 21521: xmlAttrPtr ret_val;
! 21522: xmlNodePtr node; /* the holding node */
! 21523: int n_node;
! 21524: xmlNsPtr ns; /* the namespace */
! 21525: int n_ns;
! 21526: xmlChar * name; /* the name of the attribute */
! 21527: int n_name;
! 21528: xmlChar * value; /* the value of the attribute */
! 21529: int n_value;
! 21530:
! 21531: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 21532: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
! 21533: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 21534: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 21535: mem_base = xmlMemBlocks();
! 21536: node = gen_xmlNodePtr(n_node, 0);
! 21537: ns = gen_xmlNsPtr(n_ns, 1);
! 21538: name = gen_const_xmlChar_ptr(n_name, 2);
! 21539: value = gen_const_xmlChar_ptr(n_value, 3);
! 21540:
! 21541: ret_val = xmlNewNsProp(node, ns, (const xmlChar *)name, (const xmlChar *)value);
! 21542: desret_xmlAttrPtr(ret_val);
! 21543: call_tests++;
! 21544: des_xmlNodePtr(n_node, node, 0);
! 21545: des_xmlNsPtr(n_ns, ns, 1);
! 21546: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 21547: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
! 21548: xmlResetLastError();
! 21549: if (mem_base != xmlMemBlocks()) {
! 21550: printf("Leak of %d blocks found in xmlNewNsProp",
! 21551: xmlMemBlocks() - mem_base);
! 21552: test_ret++;
! 21553: printf(" %d", n_node);
! 21554: printf(" %d", n_ns);
! 21555: printf(" %d", n_name);
! 21556: printf(" %d", n_value);
! 21557: printf("\n");
! 21558: }
! 21559: }
! 21560: }
! 21561: }
! 21562: }
! 21563: function_tests++;
! 21564:
! 21565: return(test_ret);
! 21566: }
! 21567:
! 21568:
! 21569: static int
! 21570: test_xmlNewNsPropEatName(void) {
! 21571: int test_ret = 0;
! 21572:
! 21573: int mem_base;
! 21574: xmlAttrPtr ret_val;
! 21575: xmlNodePtr node; /* the holding node */
! 21576: int n_node;
! 21577: xmlNsPtr ns; /* the namespace */
! 21578: int n_ns;
! 21579: xmlChar * name; /* the name of the attribute */
! 21580: int n_name;
! 21581: xmlChar * value; /* the value of the attribute */
! 21582: int n_value;
! 21583:
! 21584: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 21585: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
! 21586: for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) {
! 21587: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 21588: mem_base = xmlMemBlocks();
! 21589: node = gen_xmlNodePtr(n_node, 0);
! 21590: ns = gen_xmlNsPtr(n_ns, 1);
! 21591: name = gen_eaten_name(n_name, 2);
! 21592: value = gen_const_xmlChar_ptr(n_value, 3);
! 21593:
! 21594: ret_val = xmlNewNsPropEatName(node, ns, name, (const xmlChar *)value);
! 21595: desret_xmlAttrPtr(ret_val);
! 21596: call_tests++;
! 21597: des_xmlNodePtr(n_node, node, 0);
! 21598: des_xmlNsPtr(n_ns, ns, 1);
! 21599: des_eaten_name(n_name, name, 2);
! 21600: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
! 21601: xmlResetLastError();
! 21602: if (mem_base != xmlMemBlocks()) {
! 21603: printf("Leak of %d blocks found in xmlNewNsPropEatName",
! 21604: xmlMemBlocks() - mem_base);
! 21605: test_ret++;
! 21606: printf(" %d", n_node);
! 21607: printf(" %d", n_ns);
! 21608: printf(" %d", n_name);
! 21609: printf(" %d", n_value);
! 21610: printf("\n");
! 21611: }
! 21612: }
! 21613: }
! 21614: }
! 21615: }
! 21616: function_tests++;
! 21617:
! 21618: return(test_ret);
! 21619: }
! 21620:
! 21621:
! 21622: static int
! 21623: test_xmlNewPI(void) {
! 21624: int test_ret = 0;
! 21625:
! 21626: int mem_base;
! 21627: xmlNodePtr ret_val;
! 21628: xmlChar * name; /* the processing instruction name */
! 21629: int n_name;
! 21630: xmlChar * content; /* the PI content */
! 21631: int n_content;
! 21632:
! 21633: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 21634: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 21635: mem_base = xmlMemBlocks();
! 21636: name = gen_const_xmlChar_ptr(n_name, 0);
! 21637: content = gen_const_xmlChar_ptr(n_content, 1);
! 21638:
! 21639: ret_val = xmlNewPI((const xmlChar *)name, (const xmlChar *)content);
! 21640: desret_xmlNodePtr(ret_val);
! 21641: call_tests++;
! 21642: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
! 21643: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
! 21644: xmlResetLastError();
! 21645: if (mem_base != xmlMemBlocks()) {
! 21646: printf("Leak of %d blocks found in xmlNewPI",
! 21647: xmlMemBlocks() - mem_base);
! 21648: test_ret++;
! 21649: printf(" %d", n_name);
! 21650: printf(" %d", n_content);
! 21651: printf("\n");
! 21652: }
! 21653: }
! 21654: }
! 21655: function_tests++;
! 21656:
! 21657: return(test_ret);
! 21658: }
! 21659:
! 21660:
! 21661: static int
! 21662: test_xmlNewProp(void) {
! 21663: int test_ret = 0;
! 21664:
! 21665: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 21666: #ifdef LIBXML_TREE_ENABLED
! 21667: int mem_base;
! 21668: xmlAttrPtr ret_val;
! 21669: xmlNodePtr node; /* the holding node */
! 21670: int n_node;
! 21671: xmlChar * name; /* the name of the attribute */
! 21672: int n_name;
! 21673: xmlChar * value; /* the value of the attribute */
! 21674: int n_value;
! 21675:
! 21676: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 21677: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 21678: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 21679: mem_base = xmlMemBlocks();
! 21680: node = gen_xmlNodePtr(n_node, 0);
! 21681: name = gen_const_xmlChar_ptr(n_name, 1);
! 21682: value = gen_const_xmlChar_ptr(n_value, 2);
! 21683:
! 21684: ret_val = xmlNewProp(node, (const xmlChar *)name, (const xmlChar *)value);
! 21685: desret_xmlAttrPtr(ret_val);
! 21686: call_tests++;
! 21687: des_xmlNodePtr(n_node, node, 0);
! 21688: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 21689: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
! 21690: xmlResetLastError();
! 21691: if (mem_base != xmlMemBlocks()) {
! 21692: printf("Leak of %d blocks found in xmlNewProp",
! 21693: xmlMemBlocks() - mem_base);
! 21694: test_ret++;
! 21695: printf(" %d", n_node);
! 21696: printf(" %d", n_name);
! 21697: printf(" %d", n_value);
! 21698: printf("\n");
! 21699: }
! 21700: }
! 21701: }
! 21702: }
! 21703: function_tests++;
! 21704: #endif
! 21705: #endif
! 21706:
! 21707: return(test_ret);
! 21708: }
! 21709:
! 21710:
! 21711: static int
! 21712: test_xmlNewReference(void) {
! 21713: int test_ret = 0;
! 21714:
! 21715: int mem_base;
! 21716: xmlNodePtr ret_val;
! 21717: xmlDocPtr doc; /* the document */
! 21718: int n_doc;
! 21719: xmlChar * name; /* the reference name, or the reference string with & and ; */
! 21720: int n_name;
! 21721:
! 21722: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 21723: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 21724: mem_base = xmlMemBlocks();
! 21725: doc = gen_xmlDocPtr(n_doc, 0);
! 21726: name = gen_const_xmlChar_ptr(n_name, 1);
! 21727:
! 21728: ret_val = xmlNewReference(doc, (const xmlChar *)name);
! 21729: desret_xmlNodePtr(ret_val);
! 21730: call_tests++;
! 21731: des_xmlDocPtr(n_doc, doc, 0);
! 21732: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 21733: xmlResetLastError();
! 21734: if (mem_base != xmlMemBlocks()) {
! 21735: printf("Leak of %d blocks found in xmlNewReference",
! 21736: xmlMemBlocks() - mem_base);
! 21737: test_ret++;
! 21738: printf(" %d", n_doc);
! 21739: printf(" %d", n_name);
! 21740: printf("\n");
! 21741: }
! 21742: }
! 21743: }
! 21744: function_tests++;
! 21745:
! 21746: return(test_ret);
! 21747: }
! 21748:
! 21749:
! 21750: static int
! 21751: test_xmlNewText(void) {
! 21752: int test_ret = 0;
! 21753:
! 21754: int mem_base;
! 21755: xmlNodePtr ret_val;
! 21756: xmlChar * content; /* the text content */
! 21757: int n_content;
! 21758:
! 21759: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 21760: mem_base = xmlMemBlocks();
! 21761: content = gen_const_xmlChar_ptr(n_content, 0);
! 21762:
! 21763: ret_val = xmlNewText((const xmlChar *)content);
! 21764: desret_xmlNodePtr(ret_val);
! 21765: call_tests++;
! 21766: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 0);
! 21767: xmlResetLastError();
! 21768: if (mem_base != xmlMemBlocks()) {
! 21769: printf("Leak of %d blocks found in xmlNewText",
! 21770: xmlMemBlocks() - mem_base);
! 21771: test_ret++;
! 21772: printf(" %d", n_content);
! 21773: printf("\n");
! 21774: }
! 21775: }
! 21776: function_tests++;
! 21777:
! 21778: return(test_ret);
! 21779: }
! 21780:
! 21781:
! 21782: static int
! 21783: test_xmlNewTextChild(void) {
! 21784: int test_ret = 0;
! 21785:
! 21786: #if defined(LIBXML_TREE_ENABLED)
! 21787: #ifdef LIBXML_TREE_ENABLED
! 21788: int mem_base;
! 21789: xmlNodePtr ret_val;
! 21790: xmlNodePtr parent; /* the parent node */
! 21791: int n_parent;
! 21792: xmlNsPtr ns; /* a namespace if any */
! 21793: int n_ns;
! 21794: xmlChar * name; /* the name of the child */
! 21795: int n_name;
! 21796: xmlChar * content; /* the text content of the child if any. */
! 21797: int n_content;
! 21798:
! 21799: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
! 21800: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
! 21801: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 21802: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 21803: mem_base = xmlMemBlocks();
! 21804: parent = gen_xmlNodePtr(n_parent, 0);
! 21805: ns = gen_xmlNsPtr(n_ns, 1);
! 21806: name = gen_const_xmlChar_ptr(n_name, 2);
! 21807: content = gen_const_xmlChar_ptr(n_content, 3);
! 21808:
! 21809: ret_val = xmlNewTextChild(parent, ns, (const xmlChar *)name, (const xmlChar *)content);
! 21810: desret_xmlNodePtr(ret_val);
! 21811: call_tests++;
! 21812: des_xmlNodePtr(n_parent, parent, 0);
! 21813: des_xmlNsPtr(n_ns, ns, 1);
! 21814: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 21815: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
! 21816: xmlResetLastError();
! 21817: if (mem_base != xmlMemBlocks()) {
! 21818: printf("Leak of %d blocks found in xmlNewTextChild",
! 21819: xmlMemBlocks() - mem_base);
! 21820: test_ret++;
! 21821: printf(" %d", n_parent);
! 21822: printf(" %d", n_ns);
! 21823: printf(" %d", n_name);
! 21824: printf(" %d", n_content);
! 21825: printf("\n");
! 21826: }
! 21827: }
! 21828: }
! 21829: }
! 21830: }
! 21831: function_tests++;
! 21832: #endif
! 21833: #endif
! 21834:
! 21835: return(test_ret);
! 21836: }
! 21837:
! 21838:
! 21839: static int
! 21840: test_xmlNewTextLen(void) {
! 21841: int test_ret = 0;
! 21842:
! 21843: int mem_base;
! 21844: xmlNodePtr ret_val;
! 21845: xmlChar * content; /* the text content */
! 21846: int n_content;
! 21847: int len; /* the text len. */
! 21848: int n_len;
! 21849:
! 21850: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 21851: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 21852: mem_base = xmlMemBlocks();
! 21853: content = gen_const_xmlChar_ptr(n_content, 0);
! 21854: len = gen_int(n_len, 1);
! 21855:
! 21856: ret_val = xmlNewTextLen((const xmlChar *)content, len);
! 21857: desret_xmlNodePtr(ret_val);
! 21858: call_tests++;
! 21859: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 0);
! 21860: des_int(n_len, len, 1);
! 21861: xmlResetLastError();
! 21862: if (mem_base != xmlMemBlocks()) {
! 21863: printf("Leak of %d blocks found in xmlNewTextLen",
! 21864: xmlMemBlocks() - mem_base);
! 21865: test_ret++;
! 21866: printf(" %d", n_content);
! 21867: printf(" %d", n_len);
! 21868: printf("\n");
! 21869: }
! 21870: }
! 21871: }
! 21872: function_tests++;
! 21873:
! 21874: return(test_ret);
! 21875: }
! 21876:
! 21877:
! 21878: static int
! 21879: test_xmlNextElementSibling(void) {
! 21880: int test_ret = 0;
! 21881:
! 21882: #if defined(LIBXML_TREE_ENABLED)
! 21883: int mem_base;
! 21884: xmlNodePtr ret_val;
! 21885: xmlNodePtr node; /* the current node */
! 21886: int n_node;
! 21887:
! 21888: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 21889: mem_base = xmlMemBlocks();
! 21890: node = gen_xmlNodePtr(n_node, 0);
! 21891:
! 21892: ret_val = xmlNextElementSibling(node);
! 21893: desret_xmlNodePtr(ret_val);
! 21894: call_tests++;
! 21895: des_xmlNodePtr(n_node, node, 0);
! 21896: xmlResetLastError();
! 21897: if (mem_base != xmlMemBlocks()) {
! 21898: printf("Leak of %d blocks found in xmlNextElementSibling",
! 21899: xmlMemBlocks() - mem_base);
! 21900: test_ret++;
! 21901: printf(" %d", n_node);
! 21902: printf("\n");
! 21903: }
! 21904: }
! 21905: function_tests++;
! 21906: #endif
! 21907:
! 21908: return(test_ret);
! 21909: }
! 21910:
! 21911:
! 21912: static int
! 21913: test_xmlNodeAddContent(void) {
! 21914: int test_ret = 0;
! 21915:
! 21916: int mem_base;
! 21917: xmlNodePtr cur; /* the node being modified */
! 21918: int n_cur;
! 21919: xmlChar * content; /* extra content */
! 21920: int n_content;
! 21921:
! 21922: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 21923: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 21924: mem_base = xmlMemBlocks();
! 21925: cur = gen_xmlNodePtr(n_cur, 0);
! 21926: content = gen_const_xmlChar_ptr(n_content, 1);
! 21927:
! 21928: xmlNodeAddContent(cur, (const xmlChar *)content);
! 21929: call_tests++;
! 21930: des_xmlNodePtr(n_cur, cur, 0);
! 21931: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
! 21932: xmlResetLastError();
! 21933: if (mem_base != xmlMemBlocks()) {
! 21934: printf("Leak of %d blocks found in xmlNodeAddContent",
! 21935: xmlMemBlocks() - mem_base);
! 21936: test_ret++;
! 21937: printf(" %d", n_cur);
! 21938: printf(" %d", n_content);
! 21939: printf("\n");
! 21940: }
! 21941: }
! 21942: }
! 21943: function_tests++;
! 21944:
! 21945: return(test_ret);
! 21946: }
! 21947:
! 21948:
! 21949: static int
! 21950: test_xmlNodeAddContentLen(void) {
! 21951: int test_ret = 0;
! 21952:
! 21953: int mem_base;
! 21954: xmlNodePtr cur; /* the node being modified */
! 21955: int n_cur;
! 21956: xmlChar * content; /* extra content */
! 21957: int n_content;
! 21958: int len; /* the size of @content */
! 21959: int n_len;
! 21960:
! 21961: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 21962: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 21963: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 21964: mem_base = xmlMemBlocks();
! 21965: cur = gen_xmlNodePtr(n_cur, 0);
! 21966: content = gen_const_xmlChar_ptr(n_content, 1);
! 21967: len = gen_int(n_len, 2);
! 21968:
! 21969: xmlNodeAddContentLen(cur, (const xmlChar *)content, len);
! 21970: call_tests++;
! 21971: des_xmlNodePtr(n_cur, cur, 0);
! 21972: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
! 21973: des_int(n_len, len, 2);
! 21974: xmlResetLastError();
! 21975: if (mem_base != xmlMemBlocks()) {
! 21976: printf("Leak of %d blocks found in xmlNodeAddContentLen",
! 21977: xmlMemBlocks() - mem_base);
! 21978: test_ret++;
! 21979: printf(" %d", n_cur);
! 21980: printf(" %d", n_content);
! 21981: printf(" %d", n_len);
! 21982: printf("\n");
! 21983: }
! 21984: }
! 21985: }
! 21986: }
! 21987: function_tests++;
! 21988:
! 21989: return(test_ret);
! 21990: }
! 21991:
! 21992:
! 21993: static int
! 21994: test_xmlNodeBufGetContent(void) {
! 21995: int test_ret = 0;
! 21996:
! 21997: int mem_base;
! 21998: int ret_val;
! 21999: xmlBufferPtr buffer; /* a buffer */
! 22000: int n_buffer;
! 22001: xmlNodePtr cur; /* the node being read */
! 22002: int n_cur;
! 22003:
! 22004: for (n_buffer = 0;n_buffer < gen_nb_xmlBufferPtr;n_buffer++) {
! 22005: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 22006: mem_base = xmlMemBlocks();
! 22007: buffer = gen_xmlBufferPtr(n_buffer, 0);
! 22008: cur = gen_xmlNodePtr(n_cur, 1);
! 22009:
! 22010: ret_val = xmlNodeBufGetContent(buffer, cur);
! 22011: desret_int(ret_val);
! 22012: call_tests++;
! 22013: des_xmlBufferPtr(n_buffer, buffer, 0);
! 22014: des_xmlNodePtr(n_cur, cur, 1);
! 22015: xmlResetLastError();
! 22016: if (mem_base != xmlMemBlocks()) {
! 22017: printf("Leak of %d blocks found in xmlNodeBufGetContent",
! 22018: xmlMemBlocks() - mem_base);
! 22019: test_ret++;
! 22020: printf(" %d", n_buffer);
! 22021: printf(" %d", n_cur);
! 22022: printf("\n");
! 22023: }
! 22024: }
! 22025: }
! 22026: function_tests++;
! 22027:
! 22028: return(test_ret);
! 22029: }
! 22030:
! 22031:
! 22032: static int
! 22033: test_xmlNodeDump(void) {
! 22034: int test_ret = 0;
! 22035:
! 22036: #if defined(LIBXML_OUTPUT_ENABLED)
! 22037: int mem_base;
! 22038: int ret_val;
! 22039: xmlBufferPtr buf; /* the XML buffer output */
! 22040: int n_buf;
! 22041: xmlDocPtr doc; /* the document */
! 22042: int n_doc;
! 22043: xmlNodePtr cur; /* the current node */
! 22044: int n_cur;
! 22045: int level; /* the imbrication level for indenting */
! 22046: int n_level;
! 22047: int format; /* is formatting allowed */
! 22048: int n_format;
! 22049:
! 22050: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 22051: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 22052: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 22053: for (n_level = 0;n_level < gen_nb_int;n_level++) {
! 22054: for (n_format = 0;n_format < gen_nb_int;n_format++) {
! 22055: mem_base = xmlMemBlocks();
! 22056: buf = gen_xmlBufferPtr(n_buf, 0);
! 22057: doc = gen_xmlDocPtr(n_doc, 1);
! 22058: cur = gen_xmlNodePtr(n_cur, 2);
! 22059: level = gen_int(n_level, 3);
! 22060: format = gen_int(n_format, 4);
! 22061:
! 22062: ret_val = xmlNodeDump(buf, doc, cur, level, format);
! 22063: desret_int(ret_val);
! 22064: call_tests++;
! 22065: des_xmlBufferPtr(n_buf, buf, 0);
! 22066: des_xmlDocPtr(n_doc, doc, 1);
! 22067: des_xmlNodePtr(n_cur, cur, 2);
! 22068: des_int(n_level, level, 3);
! 22069: des_int(n_format, format, 4);
! 22070: xmlResetLastError();
! 22071: if (mem_base != xmlMemBlocks()) {
! 22072: printf("Leak of %d blocks found in xmlNodeDump",
! 22073: xmlMemBlocks() - mem_base);
! 22074: test_ret++;
! 22075: printf(" %d", n_buf);
! 22076: printf(" %d", n_doc);
! 22077: printf(" %d", n_cur);
! 22078: printf(" %d", n_level);
! 22079: printf(" %d", n_format);
! 22080: printf("\n");
! 22081: }
! 22082: }
! 22083: }
! 22084: }
! 22085: }
! 22086: }
! 22087: function_tests++;
! 22088: #endif
! 22089:
! 22090: return(test_ret);
! 22091: }
! 22092:
! 22093:
! 22094: static int
! 22095: test_xmlNodeDumpOutput(void) {
! 22096: int test_ret = 0;
! 22097:
! 22098: #if defined(LIBXML_OUTPUT_ENABLED)
! 22099: int mem_base;
! 22100: xmlOutputBufferPtr buf; /* the XML buffer output */
! 22101: int n_buf;
! 22102: xmlDocPtr doc; /* the document */
! 22103: int n_doc;
! 22104: xmlNodePtr cur; /* the current node */
! 22105: int n_cur;
! 22106: int level; /* the imbrication level for indenting */
! 22107: int n_level;
! 22108: int format; /* is formatting allowed */
! 22109: int n_format;
! 22110: char * encoding; /* an optional encoding string */
! 22111: int n_encoding;
! 22112:
! 22113: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
! 22114: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 22115: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 22116: for (n_level = 0;n_level < gen_nb_int;n_level++) {
! 22117: for (n_format = 0;n_format < gen_nb_int;n_format++) {
! 22118: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 22119: mem_base = xmlMemBlocks();
! 22120: buf = gen_xmlOutputBufferPtr(n_buf, 0);
! 22121: doc = gen_xmlDocPtr(n_doc, 1);
! 22122: cur = gen_xmlNodePtr(n_cur, 2);
! 22123: level = gen_int(n_level, 3);
! 22124: format = gen_int(n_format, 4);
! 22125: encoding = gen_const_char_ptr(n_encoding, 5);
! 22126:
! 22127: xmlNodeDumpOutput(buf, doc, cur, level, format, (const char *)encoding);
! 22128: call_tests++;
! 22129: des_xmlOutputBufferPtr(n_buf, buf, 0);
! 22130: des_xmlDocPtr(n_doc, doc, 1);
! 22131: des_xmlNodePtr(n_cur, cur, 2);
! 22132: des_int(n_level, level, 3);
! 22133: des_int(n_format, format, 4);
! 22134: des_const_char_ptr(n_encoding, (const char *)encoding, 5);
! 22135: xmlResetLastError();
! 22136: if (mem_base != xmlMemBlocks()) {
! 22137: printf("Leak of %d blocks found in xmlNodeDumpOutput",
! 22138: xmlMemBlocks() - mem_base);
! 22139: test_ret++;
! 22140: printf(" %d", n_buf);
! 22141: printf(" %d", n_doc);
! 22142: printf(" %d", n_cur);
! 22143: printf(" %d", n_level);
! 22144: printf(" %d", n_format);
! 22145: printf(" %d", n_encoding);
! 22146: printf("\n");
! 22147: }
! 22148: }
! 22149: }
! 22150: }
! 22151: }
! 22152: }
! 22153: }
! 22154: function_tests++;
! 22155: #endif
! 22156:
! 22157: return(test_ret);
! 22158: }
! 22159:
! 22160:
! 22161: static int
! 22162: test_xmlNodeGetBase(void) {
! 22163: int test_ret = 0;
! 22164:
! 22165: int mem_base;
! 22166: xmlChar * ret_val;
! 22167: xmlDocPtr doc; /* the document the node pertains to */
! 22168: int n_doc;
! 22169: xmlNodePtr cur; /* the node being checked */
! 22170: int n_cur;
! 22171:
! 22172: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 22173: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 22174: mem_base = xmlMemBlocks();
! 22175: doc = gen_xmlDocPtr(n_doc, 0);
! 22176: cur = gen_xmlNodePtr(n_cur, 1);
! 22177:
! 22178: ret_val = xmlNodeGetBase(doc, cur);
! 22179: desret_xmlChar_ptr(ret_val);
! 22180: call_tests++;
! 22181: des_xmlDocPtr(n_doc, doc, 0);
! 22182: des_xmlNodePtr(n_cur, cur, 1);
! 22183: xmlResetLastError();
! 22184: if (mem_base != xmlMemBlocks()) {
! 22185: printf("Leak of %d blocks found in xmlNodeGetBase",
! 22186: xmlMemBlocks() - mem_base);
! 22187: test_ret++;
! 22188: printf(" %d", n_doc);
! 22189: printf(" %d", n_cur);
! 22190: printf("\n");
! 22191: }
! 22192: }
! 22193: }
! 22194: function_tests++;
! 22195:
! 22196: return(test_ret);
! 22197: }
! 22198:
! 22199:
! 22200: static int
! 22201: test_xmlNodeGetContent(void) {
! 22202: int test_ret = 0;
! 22203:
! 22204: int mem_base;
! 22205: xmlChar * ret_val;
! 22206: xmlNodePtr cur; /* the node being read */
! 22207: int n_cur;
! 22208:
! 22209: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 22210: mem_base = xmlMemBlocks();
! 22211: cur = gen_xmlNodePtr(n_cur, 0);
! 22212:
! 22213: ret_val = xmlNodeGetContent(cur);
! 22214: desret_xmlChar_ptr(ret_val);
! 22215: call_tests++;
! 22216: des_xmlNodePtr(n_cur, cur, 0);
! 22217: xmlResetLastError();
! 22218: if (mem_base != xmlMemBlocks()) {
! 22219: printf("Leak of %d blocks found in xmlNodeGetContent",
! 22220: xmlMemBlocks() - mem_base);
! 22221: test_ret++;
! 22222: printf(" %d", n_cur);
! 22223: printf("\n");
! 22224: }
! 22225: }
! 22226: function_tests++;
! 22227:
! 22228: return(test_ret);
! 22229: }
! 22230:
! 22231:
! 22232: static int
! 22233: test_xmlNodeGetLang(void) {
! 22234: int test_ret = 0;
! 22235:
! 22236: int mem_base;
! 22237: xmlChar * ret_val;
! 22238: xmlNodePtr cur; /* the node being checked */
! 22239: int n_cur;
! 22240:
! 22241: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 22242: mem_base = xmlMemBlocks();
! 22243: cur = gen_xmlNodePtr(n_cur, 0);
! 22244:
! 22245: ret_val = xmlNodeGetLang(cur);
! 22246: desret_xmlChar_ptr(ret_val);
! 22247: call_tests++;
! 22248: des_xmlNodePtr(n_cur, cur, 0);
! 22249: xmlResetLastError();
! 22250: if (mem_base != xmlMemBlocks()) {
! 22251: printf("Leak of %d blocks found in xmlNodeGetLang",
! 22252: xmlMemBlocks() - mem_base);
! 22253: test_ret++;
! 22254: printf(" %d", n_cur);
! 22255: printf("\n");
! 22256: }
! 22257: }
! 22258: function_tests++;
! 22259:
! 22260: return(test_ret);
! 22261: }
! 22262:
! 22263:
! 22264: static int
! 22265: test_xmlNodeGetSpacePreserve(void) {
! 22266: int test_ret = 0;
! 22267:
! 22268: int mem_base;
! 22269: int ret_val;
! 22270: xmlNodePtr cur; /* the node being checked */
! 22271: int n_cur;
! 22272:
! 22273: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 22274: mem_base = xmlMemBlocks();
! 22275: cur = gen_xmlNodePtr(n_cur, 0);
! 22276:
! 22277: ret_val = xmlNodeGetSpacePreserve(cur);
! 22278: desret_int(ret_val);
! 22279: call_tests++;
! 22280: des_xmlNodePtr(n_cur, cur, 0);
! 22281: xmlResetLastError();
! 22282: if (mem_base != xmlMemBlocks()) {
! 22283: printf("Leak of %d blocks found in xmlNodeGetSpacePreserve",
! 22284: xmlMemBlocks() - mem_base);
! 22285: test_ret++;
! 22286: printf(" %d", n_cur);
! 22287: printf("\n");
! 22288: }
! 22289: }
! 22290: function_tests++;
! 22291:
! 22292: return(test_ret);
! 22293: }
! 22294:
! 22295:
! 22296: static int
! 22297: test_xmlNodeIsText(void) {
! 22298: int test_ret = 0;
! 22299:
! 22300: int mem_base;
! 22301: int ret_val;
! 22302: xmlNodePtr node; /* the node */
! 22303: int n_node;
! 22304:
! 22305: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 22306: mem_base = xmlMemBlocks();
! 22307: node = gen_xmlNodePtr(n_node, 0);
! 22308:
! 22309: ret_val = xmlNodeIsText(node);
! 22310: desret_int(ret_val);
! 22311: call_tests++;
! 22312: des_xmlNodePtr(n_node, node, 0);
! 22313: xmlResetLastError();
! 22314: if (mem_base != xmlMemBlocks()) {
! 22315: printf("Leak of %d blocks found in xmlNodeIsText",
! 22316: xmlMemBlocks() - mem_base);
! 22317: test_ret++;
! 22318: printf(" %d", n_node);
! 22319: printf("\n");
! 22320: }
! 22321: }
! 22322: function_tests++;
! 22323:
! 22324: return(test_ret);
! 22325: }
! 22326:
! 22327:
! 22328: static int
! 22329: test_xmlNodeListGetRawString(void) {
! 22330: int test_ret = 0;
! 22331:
! 22332: #if defined(LIBXML_TREE_ENABLED)
! 22333: int mem_base;
! 22334: xmlChar * ret_val;
! 22335: xmlDocPtr doc; /* the document */
! 22336: int n_doc;
! 22337: xmlNodePtr list; /* a Node list */
! 22338: int n_list;
! 22339: int inLine; /* should we replace entity contents or show their external form */
! 22340: int n_inLine;
! 22341:
! 22342: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 22343: for (n_list = 0;n_list < gen_nb_xmlNodePtr;n_list++) {
! 22344: for (n_inLine = 0;n_inLine < gen_nb_int;n_inLine++) {
! 22345: mem_base = xmlMemBlocks();
! 22346: doc = gen_xmlDocPtr(n_doc, 0);
! 22347: list = gen_xmlNodePtr(n_list, 1);
! 22348: inLine = gen_int(n_inLine, 2);
! 22349:
! 22350: ret_val = xmlNodeListGetRawString(doc, list, inLine);
! 22351: desret_xmlChar_ptr(ret_val);
! 22352: call_tests++;
! 22353: des_xmlDocPtr(n_doc, doc, 0);
! 22354: des_xmlNodePtr(n_list, list, 1);
! 22355: des_int(n_inLine, inLine, 2);
! 22356: xmlResetLastError();
! 22357: if (mem_base != xmlMemBlocks()) {
! 22358: printf("Leak of %d blocks found in xmlNodeListGetRawString",
! 22359: xmlMemBlocks() - mem_base);
! 22360: test_ret++;
! 22361: printf(" %d", n_doc);
! 22362: printf(" %d", n_list);
! 22363: printf(" %d", n_inLine);
! 22364: printf("\n");
! 22365: }
! 22366: }
! 22367: }
! 22368: }
! 22369: function_tests++;
! 22370: #endif
! 22371:
! 22372: return(test_ret);
! 22373: }
! 22374:
! 22375:
! 22376: static int
! 22377: test_xmlNodeListGetString(void) {
! 22378: int test_ret = 0;
! 22379:
! 22380: int mem_base;
! 22381: xmlChar * ret_val;
! 22382: xmlDocPtr doc; /* the document */
! 22383: int n_doc;
! 22384: xmlNodePtr list; /* a Node list */
! 22385: int n_list;
! 22386: int inLine; /* should we replace entity contents or show their external form */
! 22387: int n_inLine;
! 22388:
! 22389: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 22390: for (n_list = 0;n_list < gen_nb_xmlNodePtr;n_list++) {
! 22391: for (n_inLine = 0;n_inLine < gen_nb_int;n_inLine++) {
! 22392: mem_base = xmlMemBlocks();
! 22393: doc = gen_xmlDocPtr(n_doc, 0);
! 22394: list = gen_xmlNodePtr(n_list, 1);
! 22395: inLine = gen_int(n_inLine, 2);
! 22396:
! 22397: ret_val = xmlNodeListGetString(doc, list, inLine);
! 22398: desret_xmlChar_ptr(ret_val);
! 22399: call_tests++;
! 22400: des_xmlDocPtr(n_doc, doc, 0);
! 22401: des_xmlNodePtr(n_list, list, 1);
! 22402: des_int(n_inLine, inLine, 2);
! 22403: xmlResetLastError();
! 22404: if (mem_base != xmlMemBlocks()) {
! 22405: printf("Leak of %d blocks found in xmlNodeListGetString",
! 22406: xmlMemBlocks() - mem_base);
! 22407: test_ret++;
! 22408: printf(" %d", n_doc);
! 22409: printf(" %d", n_list);
! 22410: printf(" %d", n_inLine);
! 22411: printf("\n");
! 22412: }
! 22413: }
! 22414: }
! 22415: }
! 22416: function_tests++;
! 22417:
! 22418: return(test_ret);
! 22419: }
! 22420:
! 22421:
! 22422: static int
! 22423: test_xmlNodeSetBase(void) {
! 22424: int test_ret = 0;
! 22425:
! 22426: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
! 22427: int mem_base;
! 22428: xmlNodePtr cur; /* the node being changed */
! 22429: int n_cur;
! 22430: xmlChar * uri; /* the new base URI */
! 22431: int n_uri;
! 22432:
! 22433: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 22434: for (n_uri = 0;n_uri < gen_nb_const_xmlChar_ptr;n_uri++) {
! 22435: mem_base = xmlMemBlocks();
! 22436: cur = gen_xmlNodePtr(n_cur, 0);
! 22437: uri = gen_const_xmlChar_ptr(n_uri, 1);
! 22438:
! 22439: xmlNodeSetBase(cur, (const xmlChar *)uri);
! 22440: call_tests++;
! 22441: des_xmlNodePtr(n_cur, cur, 0);
! 22442: des_const_xmlChar_ptr(n_uri, (const xmlChar *)uri, 1);
! 22443: xmlResetLastError();
! 22444: if (mem_base != xmlMemBlocks()) {
! 22445: printf("Leak of %d blocks found in xmlNodeSetBase",
! 22446: xmlMemBlocks() - mem_base);
! 22447: test_ret++;
! 22448: printf(" %d", n_cur);
! 22449: printf(" %d", n_uri);
! 22450: printf("\n");
! 22451: }
! 22452: }
! 22453: }
! 22454: function_tests++;
! 22455: #endif
! 22456:
! 22457: return(test_ret);
! 22458: }
! 22459:
! 22460:
! 22461: static int
! 22462: test_xmlNodeSetContent(void) {
! 22463: int test_ret = 0;
! 22464:
! 22465: int mem_base;
! 22466: xmlNodePtr cur; /* the node being modified */
! 22467: int n_cur;
! 22468: xmlChar * content; /* the new value of the content */
! 22469: int n_content;
! 22470:
! 22471: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 22472: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 22473: mem_base = xmlMemBlocks();
! 22474: cur = gen_xmlNodePtr(n_cur, 0);
! 22475: content = gen_const_xmlChar_ptr(n_content, 1);
! 22476:
! 22477: xmlNodeSetContent(cur, (const xmlChar *)content);
! 22478: call_tests++;
! 22479: des_xmlNodePtr(n_cur, cur, 0);
! 22480: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
! 22481: xmlResetLastError();
! 22482: if (mem_base != xmlMemBlocks()) {
! 22483: printf("Leak of %d blocks found in xmlNodeSetContent",
! 22484: xmlMemBlocks() - mem_base);
! 22485: test_ret++;
! 22486: printf(" %d", n_cur);
! 22487: printf(" %d", n_content);
! 22488: printf("\n");
! 22489: }
! 22490: }
! 22491: }
! 22492: function_tests++;
! 22493:
! 22494: return(test_ret);
! 22495: }
! 22496:
! 22497:
! 22498: static int
! 22499: test_xmlNodeSetContentLen(void) {
! 22500: int test_ret = 0;
! 22501:
! 22502: #if defined(LIBXML_TREE_ENABLED)
! 22503: int mem_base;
! 22504: xmlNodePtr cur; /* the node being modified */
! 22505: int n_cur;
! 22506: xmlChar * content; /* the new value of the content */
! 22507: int n_content;
! 22508: int len; /* the size of @content */
! 22509: int n_len;
! 22510:
! 22511: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 22512: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 22513: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 22514: mem_base = xmlMemBlocks();
! 22515: cur = gen_xmlNodePtr(n_cur, 0);
! 22516: content = gen_const_xmlChar_ptr(n_content, 1);
! 22517: len = gen_int(n_len, 2);
! 22518:
! 22519: xmlNodeSetContentLen(cur, (const xmlChar *)content, len);
! 22520: call_tests++;
! 22521: des_xmlNodePtr(n_cur, cur, 0);
! 22522: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
! 22523: des_int(n_len, len, 2);
! 22524: xmlResetLastError();
! 22525: if (mem_base != xmlMemBlocks()) {
! 22526: printf("Leak of %d blocks found in xmlNodeSetContentLen",
! 22527: xmlMemBlocks() - mem_base);
! 22528: test_ret++;
! 22529: printf(" %d", n_cur);
! 22530: printf(" %d", n_content);
! 22531: printf(" %d", n_len);
! 22532: printf("\n");
! 22533: }
! 22534: }
! 22535: }
! 22536: }
! 22537: function_tests++;
! 22538: #endif
! 22539:
! 22540: return(test_ret);
! 22541: }
! 22542:
! 22543:
! 22544: static int
! 22545: test_xmlNodeSetLang(void) {
! 22546: int test_ret = 0;
! 22547:
! 22548: #if defined(LIBXML_TREE_ENABLED)
! 22549: int mem_base;
! 22550: xmlNodePtr cur; /* the node being changed */
! 22551: int n_cur;
! 22552: xmlChar * lang; /* the language description */
! 22553: int n_lang;
! 22554:
! 22555: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 22556: for (n_lang = 0;n_lang < gen_nb_const_xmlChar_ptr;n_lang++) {
! 22557: mem_base = xmlMemBlocks();
! 22558: cur = gen_xmlNodePtr(n_cur, 0);
! 22559: lang = gen_const_xmlChar_ptr(n_lang, 1);
! 22560:
! 22561: xmlNodeSetLang(cur, (const xmlChar *)lang);
! 22562: call_tests++;
! 22563: des_xmlNodePtr(n_cur, cur, 0);
! 22564: des_const_xmlChar_ptr(n_lang, (const xmlChar *)lang, 1);
! 22565: xmlResetLastError();
! 22566: if (mem_base != xmlMemBlocks()) {
! 22567: printf("Leak of %d blocks found in xmlNodeSetLang",
! 22568: xmlMemBlocks() - mem_base);
! 22569: test_ret++;
! 22570: printf(" %d", n_cur);
! 22571: printf(" %d", n_lang);
! 22572: printf("\n");
! 22573: }
! 22574: }
! 22575: }
! 22576: function_tests++;
! 22577: #endif
! 22578:
! 22579: return(test_ret);
! 22580: }
! 22581:
! 22582:
! 22583: static int
! 22584: test_xmlNodeSetName(void) {
! 22585: int test_ret = 0;
! 22586:
! 22587: #if defined(LIBXML_TREE_ENABLED)
! 22588: int mem_base;
! 22589: xmlNodePtr cur; /* the node being changed */
! 22590: int n_cur;
! 22591: xmlChar * name; /* the new tag name */
! 22592: int n_name;
! 22593:
! 22594: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 22595: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 22596: mem_base = xmlMemBlocks();
! 22597: cur = gen_xmlNodePtr(n_cur, 0);
! 22598: name = gen_const_xmlChar_ptr(n_name, 1);
! 22599:
! 22600: xmlNodeSetName(cur, (const xmlChar *)name);
! 22601: call_tests++;
! 22602: des_xmlNodePtr(n_cur, cur, 0);
! 22603: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 22604: xmlResetLastError();
! 22605: if (mem_base != xmlMemBlocks()) {
! 22606: printf("Leak of %d blocks found in xmlNodeSetName",
! 22607: xmlMemBlocks() - mem_base);
! 22608: test_ret++;
! 22609: printf(" %d", n_cur);
! 22610: printf(" %d", n_name);
! 22611: printf("\n");
! 22612: }
! 22613: }
! 22614: }
! 22615: function_tests++;
! 22616: #endif
! 22617:
! 22618: return(test_ret);
! 22619: }
! 22620:
! 22621:
! 22622: static int
! 22623: test_xmlNodeSetSpacePreserve(void) {
! 22624: int test_ret = 0;
! 22625:
! 22626: #if defined(LIBXML_TREE_ENABLED)
! 22627: int mem_base;
! 22628: xmlNodePtr cur; /* the node being changed */
! 22629: int n_cur;
! 22630: int val; /* the xml:space value ("0": default, 1: "preserve") */
! 22631: int n_val;
! 22632:
! 22633: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 22634: for (n_val = 0;n_val < gen_nb_int;n_val++) {
! 22635: mem_base = xmlMemBlocks();
! 22636: cur = gen_xmlNodePtr(n_cur, 0);
! 22637: val = gen_int(n_val, 1);
! 22638:
! 22639: xmlNodeSetSpacePreserve(cur, val);
! 22640: call_tests++;
! 22641: des_xmlNodePtr(n_cur, cur, 0);
! 22642: des_int(n_val, val, 1);
! 22643: xmlResetLastError();
! 22644: if (mem_base != xmlMemBlocks()) {
! 22645: printf("Leak of %d blocks found in xmlNodeSetSpacePreserve",
! 22646: xmlMemBlocks() - mem_base);
! 22647: test_ret++;
! 22648: printf(" %d", n_cur);
! 22649: printf(" %d", n_val);
! 22650: printf("\n");
! 22651: }
! 22652: }
! 22653: }
! 22654: function_tests++;
! 22655: #endif
! 22656:
! 22657: return(test_ret);
! 22658: }
! 22659:
! 22660:
! 22661: static int
! 22662: test_xmlPreviousElementSibling(void) {
! 22663: int test_ret = 0;
! 22664:
! 22665: #if defined(LIBXML_TREE_ENABLED)
! 22666: int mem_base;
! 22667: xmlNodePtr ret_val;
! 22668: xmlNodePtr node; /* the current node */
! 22669: int n_node;
! 22670:
! 22671: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 22672: mem_base = xmlMemBlocks();
! 22673: node = gen_xmlNodePtr(n_node, 0);
! 22674:
! 22675: ret_val = xmlPreviousElementSibling(node);
! 22676: desret_xmlNodePtr(ret_val);
! 22677: call_tests++;
! 22678: des_xmlNodePtr(n_node, node, 0);
! 22679: xmlResetLastError();
! 22680: if (mem_base != xmlMemBlocks()) {
! 22681: printf("Leak of %d blocks found in xmlPreviousElementSibling",
! 22682: xmlMemBlocks() - mem_base);
! 22683: test_ret++;
! 22684: printf(" %d", n_node);
! 22685: printf("\n");
! 22686: }
! 22687: }
! 22688: function_tests++;
! 22689: #endif
! 22690:
! 22691: return(test_ret);
! 22692: }
! 22693:
! 22694:
! 22695: static int
! 22696: test_xmlReconciliateNs(void) {
! 22697: int test_ret = 0;
! 22698:
! 22699: #if defined(LIBXML_TREE_ENABLED)
! 22700: #ifdef LIBXML_TREE_ENABLED
! 22701: int mem_base;
! 22702: int ret_val;
! 22703: xmlDocPtr doc; /* the document */
! 22704: int n_doc;
! 22705: xmlNodePtr tree; /* a node defining the subtree to reconciliate */
! 22706: int n_tree;
! 22707:
! 22708: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 22709: for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
! 22710: mem_base = xmlMemBlocks();
! 22711: doc = gen_xmlDocPtr(n_doc, 0);
! 22712: tree = gen_xmlNodePtr(n_tree, 1);
! 22713:
! 22714: ret_val = xmlReconciliateNs(doc, tree);
! 22715: desret_int(ret_val);
! 22716: call_tests++;
! 22717: des_xmlDocPtr(n_doc, doc, 0);
! 22718: des_xmlNodePtr(n_tree, tree, 1);
! 22719: xmlResetLastError();
! 22720: if (mem_base != xmlMemBlocks()) {
! 22721: printf("Leak of %d blocks found in xmlReconciliateNs",
! 22722: xmlMemBlocks() - mem_base);
! 22723: test_ret++;
! 22724: printf(" %d", n_doc);
! 22725: printf(" %d", n_tree);
! 22726: printf("\n");
! 22727: }
! 22728: }
! 22729: }
! 22730: function_tests++;
! 22731: #endif
! 22732: #endif
! 22733:
! 22734: return(test_ret);
! 22735: }
! 22736:
! 22737:
! 22738: static int
! 22739: test_xmlRemoveProp(void) {
! 22740: int test_ret = 0;
! 22741:
! 22742: int mem_base;
! 22743: int ret_val;
! 22744: xmlAttrPtr cur; /* an attribute */
! 22745: int n_cur;
! 22746:
! 22747: for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) {
! 22748: mem_base = xmlMemBlocks();
! 22749: cur = gen_xmlAttrPtr(n_cur, 0);
! 22750:
! 22751: ret_val = xmlRemoveProp(cur);
! 22752: cur = NULL;
! 22753: desret_int(ret_val);
! 22754: call_tests++;
! 22755: des_xmlAttrPtr(n_cur, cur, 0);
! 22756: xmlResetLastError();
! 22757: if (mem_base != xmlMemBlocks()) {
! 22758: printf("Leak of %d blocks found in xmlRemoveProp",
! 22759: xmlMemBlocks() - mem_base);
! 22760: test_ret++;
! 22761: printf(" %d", n_cur);
! 22762: printf("\n");
! 22763: }
! 22764: }
! 22765: function_tests++;
! 22766:
! 22767: return(test_ret);
! 22768: }
! 22769:
! 22770:
! 22771: static int
! 22772: test_xmlReplaceNode(void) {
! 22773: int test_ret = 0;
! 22774:
! 22775: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
! 22776: int mem_base;
! 22777: xmlNodePtr ret_val;
! 22778: xmlNodePtr old; /* the old node */
! 22779: int n_old;
! 22780: xmlNodePtr cur; /* the node */
! 22781: int n_cur;
! 22782:
! 22783: for (n_old = 0;n_old < gen_nb_xmlNodePtr;n_old++) {
! 22784: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) {
! 22785: mem_base = xmlMemBlocks();
! 22786: old = gen_xmlNodePtr(n_old, 0);
! 22787: cur = gen_xmlNodePtr_in(n_cur, 1);
! 22788:
! 22789: ret_val = xmlReplaceNode(old, cur);
! 22790: if (cur != NULL) {
! 22791: xmlUnlinkNode(cur);
! 22792: xmlFreeNode(cur) ; cur = NULL ; }
! 22793: if (old != NULL) {
! 22794: xmlUnlinkNode(old);
! 22795: xmlFreeNode(old) ; old = NULL ; }
! 22796: ret_val = NULL;
! 22797: desret_xmlNodePtr(ret_val);
! 22798: call_tests++;
! 22799: des_xmlNodePtr(n_old, old, 0);
! 22800: des_xmlNodePtr_in(n_cur, cur, 1);
! 22801: xmlResetLastError();
! 22802: if (mem_base != xmlMemBlocks()) {
! 22803: printf("Leak of %d blocks found in xmlReplaceNode",
! 22804: xmlMemBlocks() - mem_base);
! 22805: test_ret++;
! 22806: printf(" %d", n_old);
! 22807: printf(" %d", n_cur);
! 22808: printf("\n");
! 22809: }
! 22810: }
! 22811: }
! 22812: function_tests++;
! 22813: #endif
! 22814:
! 22815: return(test_ret);
! 22816: }
! 22817:
! 22818:
! 22819: static int
! 22820: test_xmlSaveFile(void) {
! 22821: int test_ret = 0;
! 22822:
! 22823: #if defined(LIBXML_OUTPUT_ENABLED)
! 22824: int mem_base;
! 22825: int ret_val;
! 22826: const char * filename; /* the filename (or URL) */
! 22827: int n_filename;
! 22828: xmlDocPtr cur; /* the document */
! 22829: int n_cur;
! 22830:
! 22831: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
! 22832: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
! 22833: mem_base = xmlMemBlocks();
! 22834: filename = gen_fileoutput(n_filename, 0);
! 22835: cur = gen_xmlDocPtr(n_cur, 1);
! 22836:
! 22837: ret_val = xmlSaveFile(filename, cur);
! 22838: desret_int(ret_val);
! 22839: call_tests++;
! 22840: des_fileoutput(n_filename, filename, 0);
! 22841: des_xmlDocPtr(n_cur, cur, 1);
! 22842: xmlResetLastError();
! 22843: if (mem_base != xmlMemBlocks()) {
! 22844: printf("Leak of %d blocks found in xmlSaveFile",
! 22845: xmlMemBlocks() - mem_base);
! 22846: test_ret++;
! 22847: printf(" %d", n_filename);
! 22848: printf(" %d", n_cur);
! 22849: printf("\n");
! 22850: }
! 22851: }
! 22852: }
! 22853: function_tests++;
! 22854: #endif
! 22855:
! 22856: return(test_ret);
! 22857: }
! 22858:
! 22859:
! 22860: static int
! 22861: test_xmlSaveFileEnc(void) {
! 22862: int test_ret = 0;
! 22863:
! 22864: #if defined(LIBXML_OUTPUT_ENABLED)
! 22865: int mem_base;
! 22866: int ret_val;
! 22867: const char * filename; /* the filename (or URL) */
! 22868: int n_filename;
! 22869: xmlDocPtr cur; /* the document */
! 22870: int n_cur;
! 22871: char * encoding; /* the name of an encoding (or NULL) */
! 22872: int n_encoding;
! 22873:
! 22874: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
! 22875: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
! 22876: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 22877: mem_base = xmlMemBlocks();
! 22878: filename = gen_fileoutput(n_filename, 0);
! 22879: cur = gen_xmlDocPtr(n_cur, 1);
! 22880: encoding = gen_const_char_ptr(n_encoding, 2);
! 22881:
! 22882: ret_val = xmlSaveFileEnc(filename, cur, (const char *)encoding);
! 22883: desret_int(ret_val);
! 22884: call_tests++;
! 22885: des_fileoutput(n_filename, filename, 0);
! 22886: des_xmlDocPtr(n_cur, cur, 1);
! 22887: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
! 22888: xmlResetLastError();
! 22889: if (mem_base != xmlMemBlocks()) {
! 22890: printf("Leak of %d blocks found in xmlSaveFileEnc",
! 22891: xmlMemBlocks() - mem_base);
! 22892: test_ret++;
! 22893: printf(" %d", n_filename);
! 22894: printf(" %d", n_cur);
! 22895: printf(" %d", n_encoding);
! 22896: printf("\n");
! 22897: }
! 22898: }
! 22899: }
! 22900: }
! 22901: function_tests++;
! 22902: #endif
! 22903:
! 22904: return(test_ret);
! 22905: }
! 22906:
! 22907:
! 22908: static int
! 22909: test_xmlSaveFileTo(void) {
! 22910: int test_ret = 0;
! 22911:
! 22912: #if defined(LIBXML_OUTPUT_ENABLED)
! 22913: int mem_base;
! 22914: int ret_val;
! 22915: xmlOutputBufferPtr buf; /* an output I/O buffer */
! 22916: int n_buf;
! 22917: xmlDocPtr cur; /* the document */
! 22918: int n_cur;
! 22919: char * encoding; /* the encoding if any assuming the I/O layer handles the trancoding */
! 22920: int n_encoding;
! 22921:
! 22922: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
! 22923: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
! 22924: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 22925: mem_base = xmlMemBlocks();
! 22926: buf = gen_xmlOutputBufferPtr(n_buf, 0);
! 22927: cur = gen_xmlDocPtr(n_cur, 1);
! 22928: encoding = gen_const_char_ptr(n_encoding, 2);
! 22929:
! 22930: ret_val = xmlSaveFileTo(buf, cur, (const char *)encoding);
! 22931: buf = NULL;
! 22932: desret_int(ret_val);
! 22933: call_tests++;
! 22934: des_xmlOutputBufferPtr(n_buf, buf, 0);
! 22935: des_xmlDocPtr(n_cur, cur, 1);
! 22936: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
! 22937: xmlResetLastError();
! 22938: if (mem_base != xmlMemBlocks()) {
! 22939: printf("Leak of %d blocks found in xmlSaveFileTo",
! 22940: xmlMemBlocks() - mem_base);
! 22941: test_ret++;
! 22942: printf(" %d", n_buf);
! 22943: printf(" %d", n_cur);
! 22944: printf(" %d", n_encoding);
! 22945: printf("\n");
! 22946: }
! 22947: }
! 22948: }
! 22949: }
! 22950: function_tests++;
! 22951: #endif
! 22952:
! 22953: return(test_ret);
! 22954: }
! 22955:
! 22956:
! 22957: static int
! 22958: test_xmlSaveFormatFile(void) {
! 22959: int test_ret = 0;
! 22960:
! 22961: #if defined(LIBXML_OUTPUT_ENABLED)
! 22962: int mem_base;
! 22963: int ret_val;
! 22964: const char * filename; /* the filename (or URL) */
! 22965: int n_filename;
! 22966: xmlDocPtr cur; /* the document */
! 22967: int n_cur;
! 22968: int format; /* should formatting spaces been added */
! 22969: int n_format;
! 22970:
! 22971: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
! 22972: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
! 22973: for (n_format = 0;n_format < gen_nb_int;n_format++) {
! 22974: mem_base = xmlMemBlocks();
! 22975: filename = gen_fileoutput(n_filename, 0);
! 22976: cur = gen_xmlDocPtr(n_cur, 1);
! 22977: format = gen_int(n_format, 2);
! 22978:
! 22979: ret_val = xmlSaveFormatFile(filename, cur, format);
! 22980: desret_int(ret_val);
! 22981: call_tests++;
! 22982: des_fileoutput(n_filename, filename, 0);
! 22983: des_xmlDocPtr(n_cur, cur, 1);
! 22984: des_int(n_format, format, 2);
! 22985: xmlResetLastError();
! 22986: if (mem_base != xmlMemBlocks()) {
! 22987: printf("Leak of %d blocks found in xmlSaveFormatFile",
! 22988: xmlMemBlocks() - mem_base);
! 22989: test_ret++;
! 22990: printf(" %d", n_filename);
! 22991: printf(" %d", n_cur);
! 22992: printf(" %d", n_format);
! 22993: printf("\n");
! 22994: }
! 22995: }
! 22996: }
! 22997: }
! 22998: function_tests++;
! 22999: #endif
! 23000:
! 23001: return(test_ret);
! 23002: }
! 23003:
! 23004:
! 23005: static int
! 23006: test_xmlSaveFormatFileEnc(void) {
! 23007: int test_ret = 0;
! 23008:
! 23009: #if defined(LIBXML_OUTPUT_ENABLED)
! 23010: int mem_base;
! 23011: int ret_val;
! 23012: const char * filename; /* the filename or URL to output */
! 23013: int n_filename;
! 23014: xmlDocPtr cur; /* the document being saved */
! 23015: int n_cur;
! 23016: char * encoding; /* the name of the encoding to use or NULL. */
! 23017: int n_encoding;
! 23018: int format; /* should formatting spaces be added. */
! 23019: int n_format;
! 23020:
! 23021: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
! 23022: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
! 23023: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 23024: for (n_format = 0;n_format < gen_nb_int;n_format++) {
! 23025: mem_base = xmlMemBlocks();
! 23026: filename = gen_fileoutput(n_filename, 0);
! 23027: cur = gen_xmlDocPtr(n_cur, 1);
! 23028: encoding = gen_const_char_ptr(n_encoding, 2);
! 23029: format = gen_int(n_format, 3);
! 23030:
! 23031: ret_val = xmlSaveFormatFileEnc(filename, cur, (const char *)encoding, format);
! 23032: desret_int(ret_val);
! 23033: call_tests++;
! 23034: des_fileoutput(n_filename, filename, 0);
! 23035: des_xmlDocPtr(n_cur, cur, 1);
! 23036: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
! 23037: des_int(n_format, format, 3);
! 23038: xmlResetLastError();
! 23039: if (mem_base != xmlMemBlocks()) {
! 23040: printf("Leak of %d blocks found in xmlSaveFormatFileEnc",
! 23041: xmlMemBlocks() - mem_base);
! 23042: test_ret++;
! 23043: printf(" %d", n_filename);
! 23044: printf(" %d", n_cur);
! 23045: printf(" %d", n_encoding);
! 23046: printf(" %d", n_format);
! 23047: printf("\n");
! 23048: }
! 23049: }
! 23050: }
! 23051: }
! 23052: }
! 23053: function_tests++;
! 23054: #endif
! 23055:
! 23056: return(test_ret);
! 23057: }
! 23058:
! 23059:
! 23060: static int
! 23061: test_xmlSaveFormatFileTo(void) {
! 23062: int test_ret = 0;
! 23063:
! 23064: #if defined(LIBXML_OUTPUT_ENABLED)
! 23065: int mem_base;
! 23066: int ret_val;
! 23067: xmlOutputBufferPtr buf; /* an output I/O buffer */
! 23068: int n_buf;
! 23069: xmlDocPtr cur; /* the document */
! 23070: int n_cur;
! 23071: char * encoding; /* the encoding if any assuming the I/O layer handles the trancoding */
! 23072: int n_encoding;
! 23073: int format; /* should formatting spaces been added */
! 23074: int n_format;
! 23075:
! 23076: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
! 23077: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
! 23078: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 23079: for (n_format = 0;n_format < gen_nb_int;n_format++) {
! 23080: mem_base = xmlMemBlocks();
! 23081: buf = gen_xmlOutputBufferPtr(n_buf, 0);
! 23082: cur = gen_xmlDocPtr(n_cur, 1);
! 23083: encoding = gen_const_char_ptr(n_encoding, 2);
! 23084: format = gen_int(n_format, 3);
! 23085:
! 23086: ret_val = xmlSaveFormatFileTo(buf, cur, (const char *)encoding, format);
! 23087: buf = NULL;
! 23088: desret_int(ret_val);
! 23089: call_tests++;
! 23090: des_xmlOutputBufferPtr(n_buf, buf, 0);
! 23091: des_xmlDocPtr(n_cur, cur, 1);
! 23092: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
! 23093: des_int(n_format, format, 3);
! 23094: xmlResetLastError();
! 23095: if (mem_base != xmlMemBlocks()) {
! 23096: printf("Leak of %d blocks found in xmlSaveFormatFileTo",
! 23097: xmlMemBlocks() - mem_base);
! 23098: test_ret++;
! 23099: printf(" %d", n_buf);
! 23100: printf(" %d", n_cur);
! 23101: printf(" %d", n_encoding);
! 23102: printf(" %d", n_format);
! 23103: printf("\n");
! 23104: }
! 23105: }
! 23106: }
! 23107: }
! 23108: }
! 23109: function_tests++;
! 23110: #endif
! 23111:
! 23112: return(test_ret);
! 23113: }
! 23114:
! 23115:
! 23116: static int
! 23117: test_xmlSearchNs(void) {
! 23118: int test_ret = 0;
! 23119:
! 23120: int mem_base;
! 23121: xmlNsPtr ret_val;
! 23122: xmlDocPtr doc; /* the document */
! 23123: int n_doc;
! 23124: xmlNodePtr node; /* the current node */
! 23125: int n_node;
! 23126: xmlChar * nameSpace; /* the namespace prefix */
! 23127: int n_nameSpace;
! 23128:
! 23129: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 23130: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 23131: for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) {
! 23132: mem_base = xmlMemBlocks();
! 23133: doc = gen_xmlDocPtr(n_doc, 0);
! 23134: node = gen_xmlNodePtr(n_node, 1);
! 23135: nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2);
! 23136:
! 23137: ret_val = xmlSearchNs(doc, node, (const xmlChar *)nameSpace);
! 23138: desret_xmlNsPtr(ret_val);
! 23139: call_tests++;
! 23140: des_xmlDocPtr(n_doc, doc, 0);
! 23141: des_xmlNodePtr(n_node, node, 1);
! 23142: des_const_xmlChar_ptr(n_nameSpace, (const xmlChar *)nameSpace, 2);
! 23143: xmlResetLastError();
! 23144: if (mem_base != xmlMemBlocks()) {
! 23145: printf("Leak of %d blocks found in xmlSearchNs",
! 23146: xmlMemBlocks() - mem_base);
! 23147: test_ret++;
! 23148: printf(" %d", n_doc);
! 23149: printf(" %d", n_node);
! 23150: printf(" %d", n_nameSpace);
! 23151: printf("\n");
! 23152: }
! 23153: }
! 23154: }
! 23155: }
! 23156: function_tests++;
! 23157:
! 23158: return(test_ret);
! 23159: }
! 23160:
! 23161:
! 23162: static int
! 23163: test_xmlSearchNsByHref(void) {
! 23164: int test_ret = 0;
! 23165:
! 23166: int mem_base;
! 23167: xmlNsPtr ret_val;
! 23168: xmlDocPtr doc; /* the document */
! 23169: int n_doc;
! 23170: xmlNodePtr node; /* the current node */
! 23171: int n_node;
! 23172: xmlChar * href; /* the namespace value */
! 23173: int n_href;
! 23174:
! 23175: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 23176: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 23177: for (n_href = 0;n_href < gen_nb_const_xmlChar_ptr;n_href++) {
! 23178: mem_base = xmlMemBlocks();
! 23179: doc = gen_xmlDocPtr(n_doc, 0);
! 23180: node = gen_xmlNodePtr(n_node, 1);
! 23181: href = gen_const_xmlChar_ptr(n_href, 2);
! 23182:
! 23183: ret_val = xmlSearchNsByHref(doc, node, (const xmlChar *)href);
! 23184: desret_xmlNsPtr(ret_val);
! 23185: call_tests++;
! 23186: des_xmlDocPtr(n_doc, doc, 0);
! 23187: des_xmlNodePtr(n_node, node, 1);
! 23188: des_const_xmlChar_ptr(n_href, (const xmlChar *)href, 2);
! 23189: xmlResetLastError();
! 23190: if (mem_base != xmlMemBlocks()) {
! 23191: printf("Leak of %d blocks found in xmlSearchNsByHref",
! 23192: xmlMemBlocks() - mem_base);
! 23193: test_ret++;
! 23194: printf(" %d", n_doc);
! 23195: printf(" %d", n_node);
! 23196: printf(" %d", n_href);
! 23197: printf("\n");
! 23198: }
! 23199: }
! 23200: }
! 23201: }
! 23202: function_tests++;
! 23203:
! 23204: return(test_ret);
! 23205: }
! 23206:
! 23207:
! 23208: static int
! 23209: test_xmlSetBufferAllocationScheme(void) {
! 23210: int test_ret = 0;
! 23211:
! 23212: int mem_base;
! 23213: xmlBufferAllocationScheme scheme; /* allocation method to use */
! 23214: int n_scheme;
! 23215:
! 23216: for (n_scheme = 0;n_scheme < gen_nb_xmlBufferAllocationScheme;n_scheme++) {
! 23217: mem_base = xmlMemBlocks();
! 23218: scheme = gen_xmlBufferAllocationScheme(n_scheme, 0);
! 23219:
! 23220: xmlSetBufferAllocationScheme(scheme);
! 23221: call_tests++;
! 23222: des_xmlBufferAllocationScheme(n_scheme, scheme, 0);
! 23223: xmlResetLastError();
! 23224: if (mem_base != xmlMemBlocks()) {
! 23225: printf("Leak of %d blocks found in xmlSetBufferAllocationScheme",
! 23226: xmlMemBlocks() - mem_base);
! 23227: test_ret++;
! 23228: printf(" %d", n_scheme);
! 23229: printf("\n");
! 23230: }
! 23231: }
! 23232: function_tests++;
! 23233:
! 23234: return(test_ret);
! 23235: }
! 23236:
! 23237:
! 23238: static int
! 23239: test_xmlSetCompressMode(void) {
! 23240: int test_ret = 0;
! 23241:
! 23242: int mem_base;
! 23243: int mode; /* the compression ratio */
! 23244: int n_mode;
! 23245:
! 23246: for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
! 23247: mem_base = xmlMemBlocks();
! 23248: mode = gen_int(n_mode, 0);
! 23249:
! 23250: xmlSetCompressMode(mode);
! 23251: call_tests++;
! 23252: des_int(n_mode, mode, 0);
! 23253: xmlResetLastError();
! 23254: if (mem_base != xmlMemBlocks()) {
! 23255: printf("Leak of %d blocks found in xmlSetCompressMode",
! 23256: xmlMemBlocks() - mem_base);
! 23257: test_ret++;
! 23258: printf(" %d", n_mode);
! 23259: printf("\n");
! 23260: }
! 23261: }
! 23262: function_tests++;
! 23263:
! 23264: return(test_ret);
! 23265: }
! 23266:
! 23267:
! 23268: static int
! 23269: test_xmlSetDocCompressMode(void) {
! 23270: int test_ret = 0;
! 23271:
! 23272: int mem_base;
! 23273: xmlDocPtr doc; /* the document */
! 23274: int n_doc;
! 23275: int mode; /* the compression ratio */
! 23276: int n_mode;
! 23277:
! 23278: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 23279: for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
! 23280: mem_base = xmlMemBlocks();
! 23281: doc = gen_xmlDocPtr(n_doc, 0);
! 23282: mode = gen_int(n_mode, 1);
! 23283:
! 23284: xmlSetDocCompressMode(doc, mode);
! 23285: call_tests++;
! 23286: des_xmlDocPtr(n_doc, doc, 0);
! 23287: des_int(n_mode, mode, 1);
! 23288: xmlResetLastError();
! 23289: if (mem_base != xmlMemBlocks()) {
! 23290: printf("Leak of %d blocks found in xmlSetDocCompressMode",
! 23291: xmlMemBlocks() - mem_base);
! 23292: test_ret++;
! 23293: printf(" %d", n_doc);
! 23294: printf(" %d", n_mode);
! 23295: printf("\n");
! 23296: }
! 23297: }
! 23298: }
! 23299: function_tests++;
! 23300:
! 23301: return(test_ret);
! 23302: }
! 23303:
! 23304:
! 23305: static int
! 23306: test_xmlSetNs(void) {
! 23307: int test_ret = 0;
! 23308:
! 23309: int mem_base;
! 23310: xmlNodePtr node; /* a node in the document */
! 23311: int n_node;
! 23312: xmlNsPtr ns; /* a namespace pointer */
! 23313: int n_ns;
! 23314:
! 23315: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 23316: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
! 23317: mem_base = xmlMemBlocks();
! 23318: node = gen_xmlNodePtr(n_node, 0);
! 23319: ns = gen_xmlNsPtr(n_ns, 1);
! 23320:
! 23321: xmlSetNs(node, ns);
! 23322: call_tests++;
! 23323: des_xmlNodePtr(n_node, node, 0);
! 23324: des_xmlNsPtr(n_ns, ns, 1);
! 23325: xmlResetLastError();
! 23326: if (mem_base != xmlMemBlocks()) {
! 23327: printf("Leak of %d blocks found in xmlSetNs",
! 23328: xmlMemBlocks() - mem_base);
! 23329: test_ret++;
! 23330: printf(" %d", n_node);
! 23331: printf(" %d", n_ns);
! 23332: printf("\n");
! 23333: }
! 23334: }
! 23335: }
! 23336: function_tests++;
! 23337:
! 23338: return(test_ret);
! 23339: }
! 23340:
! 23341:
! 23342: static int
! 23343: test_xmlSetNsProp(void) {
! 23344: int test_ret = 0;
! 23345:
! 23346: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
! 23347: int mem_base;
! 23348: xmlAttrPtr ret_val;
! 23349: xmlNodePtr node; /* the node */
! 23350: int n_node;
! 23351: xmlNsPtr ns; /* the namespace definition */
! 23352: int n_ns;
! 23353: xmlChar * name; /* the attribute name */
! 23354: int n_name;
! 23355: xmlChar * value; /* the attribute value */
! 23356: int n_value;
! 23357:
! 23358: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 23359: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
! 23360: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 23361: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 23362: mem_base = xmlMemBlocks();
! 23363: node = gen_xmlNodePtr(n_node, 0);
! 23364: ns = gen_xmlNsPtr(n_ns, 1);
! 23365: name = gen_const_xmlChar_ptr(n_name, 2);
! 23366: value = gen_const_xmlChar_ptr(n_value, 3);
! 23367:
! 23368: ret_val = xmlSetNsProp(node, ns, (const xmlChar *)name, (const xmlChar *)value);
! 23369: desret_xmlAttrPtr(ret_val);
! 23370: call_tests++;
! 23371: des_xmlNodePtr(n_node, node, 0);
! 23372: des_xmlNsPtr(n_ns, ns, 1);
! 23373: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 23374: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
! 23375: xmlResetLastError();
! 23376: if (mem_base != xmlMemBlocks()) {
! 23377: printf("Leak of %d blocks found in xmlSetNsProp",
! 23378: xmlMemBlocks() - mem_base);
! 23379: test_ret++;
! 23380: printf(" %d", n_node);
! 23381: printf(" %d", n_ns);
! 23382: printf(" %d", n_name);
! 23383: printf(" %d", n_value);
! 23384: printf("\n");
! 23385: }
! 23386: }
! 23387: }
! 23388: }
! 23389: }
! 23390: function_tests++;
! 23391: #endif
! 23392:
! 23393: return(test_ret);
! 23394: }
! 23395:
! 23396:
! 23397: static int
! 23398: test_xmlSetProp(void) {
! 23399: int test_ret = 0;
! 23400:
! 23401: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
! 23402: int mem_base;
! 23403: xmlAttrPtr ret_val;
! 23404: xmlNodePtr node; /* the node */
! 23405: int n_node;
! 23406: xmlChar * name; /* the attribute name (a QName) */
! 23407: int n_name;
! 23408: xmlChar * value; /* the attribute value */
! 23409: int n_value;
! 23410:
! 23411: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 23412: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 23413: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 23414: mem_base = xmlMemBlocks();
! 23415: node = gen_xmlNodePtr(n_node, 0);
! 23416: name = gen_const_xmlChar_ptr(n_name, 1);
! 23417: value = gen_const_xmlChar_ptr(n_value, 2);
! 23418:
! 23419: ret_val = xmlSetProp(node, (const xmlChar *)name, (const xmlChar *)value);
! 23420: desret_xmlAttrPtr(ret_val);
! 23421: call_tests++;
! 23422: des_xmlNodePtr(n_node, node, 0);
! 23423: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 23424: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
! 23425: xmlResetLastError();
! 23426: if (mem_base != xmlMemBlocks()) {
! 23427: printf("Leak of %d blocks found in xmlSetProp",
! 23428: xmlMemBlocks() - mem_base);
! 23429: test_ret++;
! 23430: printf(" %d", n_node);
! 23431: printf(" %d", n_name);
! 23432: printf(" %d", n_value);
! 23433: printf("\n");
! 23434: }
! 23435: }
! 23436: }
! 23437: }
! 23438: function_tests++;
! 23439: #endif
! 23440:
! 23441: return(test_ret);
! 23442: }
! 23443:
! 23444:
! 23445: static int
! 23446: test_xmlSplitQName2(void) {
! 23447: int test_ret = 0;
! 23448:
! 23449: int mem_base;
! 23450: xmlChar * ret_val;
! 23451: xmlChar * name; /* the full QName */
! 23452: int n_name;
! 23453: xmlChar ** prefix; /* a xmlChar ** */
! 23454: int n_prefix;
! 23455:
! 23456: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 23457: for (n_prefix = 0;n_prefix < gen_nb_xmlChar_ptr_ptr;n_prefix++) {
! 23458: mem_base = xmlMemBlocks();
! 23459: name = gen_const_xmlChar_ptr(n_name, 0);
! 23460: prefix = gen_xmlChar_ptr_ptr(n_prefix, 1);
! 23461:
! 23462: ret_val = xmlSplitQName2((const xmlChar *)name, prefix);
! 23463: desret_xmlChar_ptr(ret_val);
! 23464: call_tests++;
! 23465: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
! 23466: des_xmlChar_ptr_ptr(n_prefix, prefix, 1);
! 23467: xmlResetLastError();
! 23468: if (mem_base != xmlMemBlocks()) {
! 23469: printf("Leak of %d blocks found in xmlSplitQName2",
! 23470: xmlMemBlocks() - mem_base);
! 23471: test_ret++;
! 23472: printf(" %d", n_name);
! 23473: printf(" %d", n_prefix);
! 23474: printf("\n");
! 23475: }
! 23476: }
! 23477: }
! 23478: function_tests++;
! 23479:
! 23480: return(test_ret);
! 23481: }
! 23482:
! 23483:
! 23484: static int
! 23485: test_xmlSplitQName3(void) {
! 23486: int test_ret = 0;
! 23487:
! 23488: int mem_base;
! 23489: const xmlChar * ret_val;
! 23490: xmlChar * name; /* the full QName */
! 23491: int n_name;
! 23492: int * len; /* an int * */
! 23493: int n_len;
! 23494:
! 23495: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 23496: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
! 23497: mem_base = xmlMemBlocks();
! 23498: name = gen_const_xmlChar_ptr(n_name, 0);
! 23499: len = gen_int_ptr(n_len, 1);
! 23500:
! 23501: ret_val = xmlSplitQName3((const xmlChar *)name, len);
! 23502: desret_const_xmlChar_ptr(ret_val);
! 23503: call_tests++;
! 23504: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
! 23505: des_int_ptr(n_len, len, 1);
! 23506: xmlResetLastError();
! 23507: if (mem_base != xmlMemBlocks()) {
! 23508: printf("Leak of %d blocks found in xmlSplitQName3",
! 23509: xmlMemBlocks() - mem_base);
! 23510: test_ret++;
! 23511: printf(" %d", n_name);
! 23512: printf(" %d", n_len);
! 23513: printf("\n");
! 23514: }
! 23515: }
! 23516: }
! 23517: function_tests++;
! 23518:
! 23519: return(test_ret);
! 23520: }
! 23521:
! 23522:
! 23523: static int
! 23524: test_xmlStringGetNodeList(void) {
! 23525: int test_ret = 0;
! 23526:
! 23527: int mem_base;
! 23528: xmlNodePtr ret_val;
! 23529: xmlDocPtr doc; /* the document */
! 23530: int n_doc;
! 23531: xmlChar * value; /* the value of the attribute */
! 23532: int n_value;
! 23533:
! 23534: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 23535: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 23536: mem_base = xmlMemBlocks();
! 23537: doc = gen_xmlDocPtr(n_doc, 0);
! 23538: value = gen_const_xmlChar_ptr(n_value, 1);
! 23539:
! 23540: ret_val = xmlStringGetNodeList(doc, (const xmlChar *)value);
! 23541: desret_xmlNodePtr(ret_val);
! 23542: call_tests++;
! 23543: des_xmlDocPtr(n_doc, doc, 0);
! 23544: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
! 23545: xmlResetLastError();
! 23546: if (mem_base != xmlMemBlocks()) {
! 23547: printf("Leak of %d blocks found in xmlStringGetNodeList",
! 23548: xmlMemBlocks() - mem_base);
! 23549: test_ret++;
! 23550: printf(" %d", n_doc);
! 23551: printf(" %d", n_value);
! 23552: printf("\n");
! 23553: }
! 23554: }
! 23555: }
! 23556: function_tests++;
! 23557:
! 23558: return(test_ret);
! 23559: }
! 23560:
! 23561:
! 23562: static int
! 23563: test_xmlStringLenGetNodeList(void) {
! 23564: int test_ret = 0;
! 23565:
! 23566: int mem_base;
! 23567: xmlNodePtr ret_val;
! 23568: xmlDocPtr doc; /* the document */
! 23569: int n_doc;
! 23570: xmlChar * value; /* the value of the text */
! 23571: int n_value;
! 23572: int len; /* the length of the string value */
! 23573: int n_len;
! 23574:
! 23575: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 23576: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 23577: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 23578: mem_base = xmlMemBlocks();
! 23579: doc = gen_xmlDocPtr(n_doc, 0);
! 23580: value = gen_const_xmlChar_ptr(n_value, 1);
! 23581: len = gen_int(n_len, 2);
! 23582:
! 23583: ret_val = xmlStringLenGetNodeList(doc, (const xmlChar *)value, len);
! 23584: desret_xmlNodePtr(ret_val);
! 23585: call_tests++;
! 23586: des_xmlDocPtr(n_doc, doc, 0);
! 23587: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
! 23588: des_int(n_len, len, 2);
! 23589: xmlResetLastError();
! 23590: if (mem_base != xmlMemBlocks()) {
! 23591: printf("Leak of %d blocks found in xmlStringLenGetNodeList",
! 23592: xmlMemBlocks() - mem_base);
! 23593: test_ret++;
! 23594: printf(" %d", n_doc);
! 23595: printf(" %d", n_value);
! 23596: printf(" %d", n_len);
! 23597: printf("\n");
! 23598: }
! 23599: }
! 23600: }
! 23601: }
! 23602: function_tests++;
! 23603:
! 23604: return(test_ret);
! 23605: }
! 23606:
! 23607:
! 23608: static int
! 23609: test_xmlTextConcat(void) {
! 23610: int test_ret = 0;
! 23611:
! 23612: int mem_base;
! 23613: int ret_val;
! 23614: xmlNodePtr node; /* the node */
! 23615: int n_node;
! 23616: xmlChar * content; /* the content */
! 23617: int n_content;
! 23618: int len; /* @content length */
! 23619: int n_len;
! 23620:
! 23621: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 23622: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 23623: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 23624: mem_base = xmlMemBlocks();
! 23625: node = gen_xmlNodePtr(n_node, 0);
! 23626: content = gen_const_xmlChar_ptr(n_content, 1);
! 23627: len = gen_int(n_len, 2);
! 23628:
! 23629: ret_val = xmlTextConcat(node, (const xmlChar *)content, len);
! 23630: desret_int(ret_val);
! 23631: call_tests++;
! 23632: des_xmlNodePtr(n_node, node, 0);
! 23633: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
! 23634: des_int(n_len, len, 2);
! 23635: xmlResetLastError();
! 23636: if (mem_base != xmlMemBlocks()) {
! 23637: printf("Leak of %d blocks found in xmlTextConcat",
! 23638: xmlMemBlocks() - mem_base);
! 23639: test_ret++;
! 23640: printf(" %d", n_node);
! 23641: printf(" %d", n_content);
! 23642: printf(" %d", n_len);
! 23643: printf("\n");
! 23644: }
! 23645: }
! 23646: }
! 23647: }
! 23648: function_tests++;
! 23649:
! 23650: return(test_ret);
! 23651: }
! 23652:
! 23653:
! 23654: static int
! 23655: test_xmlTextMerge(void) {
! 23656: int test_ret = 0;
! 23657:
! 23658: int mem_base;
! 23659: xmlNodePtr ret_val;
! 23660: xmlNodePtr first; /* the first text node */
! 23661: int n_first;
! 23662: xmlNodePtr second; /* the second text node being merged */
! 23663: int n_second;
! 23664:
! 23665: for (n_first = 0;n_first < gen_nb_xmlNodePtr_in;n_first++) {
! 23666: for (n_second = 0;n_second < gen_nb_xmlNodePtr_in;n_second++) {
! 23667: mem_base = xmlMemBlocks();
! 23668: first = gen_xmlNodePtr_in(n_first, 0);
! 23669: second = gen_xmlNodePtr_in(n_second, 1);
! 23670:
! 23671: ret_val = xmlTextMerge(first, second);
! 23672: if ((first != NULL) && (first->type != XML_TEXT_NODE)) {
! 23673: xmlUnlinkNode(second);
! 23674: xmlFreeNode(second) ; second = NULL ; }
! 23675: desret_xmlNodePtr(ret_val);
! 23676: call_tests++;
! 23677: des_xmlNodePtr_in(n_first, first, 0);
! 23678: des_xmlNodePtr_in(n_second, second, 1);
! 23679: xmlResetLastError();
! 23680: if (mem_base != xmlMemBlocks()) {
! 23681: printf("Leak of %d blocks found in xmlTextMerge",
! 23682: xmlMemBlocks() - mem_base);
! 23683: test_ret++;
! 23684: printf(" %d", n_first);
! 23685: printf(" %d", n_second);
! 23686: printf("\n");
! 23687: }
! 23688: }
! 23689: }
! 23690: function_tests++;
! 23691:
! 23692: return(test_ret);
! 23693: }
! 23694:
! 23695:
! 23696: static int
! 23697: test_xmlUnsetNsProp(void) {
! 23698: int test_ret = 0;
! 23699:
! 23700: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 23701: int mem_base;
! 23702: int ret_val;
! 23703: xmlNodePtr node; /* the node */
! 23704: int n_node;
! 23705: xmlNsPtr ns; /* the namespace definition */
! 23706: int n_ns;
! 23707: xmlChar * name; /* the attribute name */
! 23708: int n_name;
! 23709:
! 23710: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 23711: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
! 23712: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 23713: mem_base = xmlMemBlocks();
! 23714: node = gen_xmlNodePtr(n_node, 0);
! 23715: ns = gen_xmlNsPtr(n_ns, 1);
! 23716: name = gen_const_xmlChar_ptr(n_name, 2);
! 23717:
! 23718: ret_val = xmlUnsetNsProp(node, ns, (const xmlChar *)name);
! 23719: desret_int(ret_val);
! 23720: call_tests++;
! 23721: des_xmlNodePtr(n_node, node, 0);
! 23722: des_xmlNsPtr(n_ns, ns, 1);
! 23723: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 23724: xmlResetLastError();
! 23725: if (mem_base != xmlMemBlocks()) {
! 23726: printf("Leak of %d blocks found in xmlUnsetNsProp",
! 23727: xmlMemBlocks() - mem_base);
! 23728: test_ret++;
! 23729: printf(" %d", n_node);
! 23730: printf(" %d", n_ns);
! 23731: printf(" %d", n_name);
! 23732: printf("\n");
! 23733: }
! 23734: }
! 23735: }
! 23736: }
! 23737: function_tests++;
! 23738: #endif
! 23739:
! 23740: return(test_ret);
! 23741: }
! 23742:
! 23743:
! 23744: static int
! 23745: test_xmlUnsetProp(void) {
! 23746: int test_ret = 0;
! 23747:
! 23748: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 23749: int mem_base;
! 23750: int ret_val;
! 23751: xmlNodePtr node; /* the node */
! 23752: int n_node;
! 23753: xmlChar * name; /* the attribute name */
! 23754: int n_name;
! 23755:
! 23756: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 23757: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 23758: mem_base = xmlMemBlocks();
! 23759: node = gen_xmlNodePtr(n_node, 0);
! 23760: name = gen_const_xmlChar_ptr(n_name, 1);
! 23761:
! 23762: ret_val = xmlUnsetProp(node, (const xmlChar *)name);
! 23763: desret_int(ret_val);
! 23764: call_tests++;
! 23765: des_xmlNodePtr(n_node, node, 0);
! 23766: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 23767: xmlResetLastError();
! 23768: if (mem_base != xmlMemBlocks()) {
! 23769: printf("Leak of %d blocks found in xmlUnsetProp",
! 23770: xmlMemBlocks() - mem_base);
! 23771: test_ret++;
! 23772: printf(" %d", n_node);
! 23773: printf(" %d", n_name);
! 23774: printf("\n");
! 23775: }
! 23776: }
! 23777: }
! 23778: function_tests++;
! 23779: #endif
! 23780:
! 23781: return(test_ret);
! 23782: }
! 23783:
! 23784:
! 23785: static int
! 23786: test_xmlValidateNCName(void) {
! 23787: int test_ret = 0;
! 23788:
! 23789: #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)
! 23790: #ifdef LIBXML_TREE_ENABLED
! 23791: int mem_base;
! 23792: int ret_val;
! 23793: xmlChar * value; /* the value to check */
! 23794: int n_value;
! 23795: int space; /* allow spaces in front and end of the string */
! 23796: int n_space;
! 23797:
! 23798: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 23799: for (n_space = 0;n_space < gen_nb_int;n_space++) {
! 23800: mem_base = xmlMemBlocks();
! 23801: value = gen_const_xmlChar_ptr(n_value, 0);
! 23802: space = gen_int(n_space, 1);
! 23803:
! 23804: ret_val = xmlValidateNCName((const xmlChar *)value, space);
! 23805: desret_int(ret_val);
! 23806: call_tests++;
! 23807: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
! 23808: des_int(n_space, space, 1);
! 23809: xmlResetLastError();
! 23810: if (mem_base != xmlMemBlocks()) {
! 23811: printf("Leak of %d blocks found in xmlValidateNCName",
! 23812: xmlMemBlocks() - mem_base);
! 23813: test_ret++;
! 23814: printf(" %d", n_value);
! 23815: printf(" %d", n_space);
! 23816: printf("\n");
! 23817: }
! 23818: }
! 23819: }
! 23820: function_tests++;
! 23821: #endif
! 23822: #endif
! 23823:
! 23824: return(test_ret);
! 23825: }
! 23826:
! 23827:
! 23828: static int
! 23829: test_xmlValidateNMToken(void) {
! 23830: int test_ret = 0;
! 23831:
! 23832: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 23833: #ifdef LIBXML_TREE_ENABLED
! 23834: int mem_base;
! 23835: int ret_val;
! 23836: xmlChar * value; /* the value to check */
! 23837: int n_value;
! 23838: int space; /* allow spaces in front and end of the string */
! 23839: int n_space;
! 23840:
! 23841: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 23842: for (n_space = 0;n_space < gen_nb_int;n_space++) {
! 23843: mem_base = xmlMemBlocks();
! 23844: value = gen_const_xmlChar_ptr(n_value, 0);
! 23845: space = gen_int(n_space, 1);
! 23846:
! 23847: ret_val = xmlValidateNMToken((const xmlChar *)value, space);
! 23848: desret_int(ret_val);
! 23849: call_tests++;
! 23850: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
! 23851: des_int(n_space, space, 1);
! 23852: xmlResetLastError();
! 23853: if (mem_base != xmlMemBlocks()) {
! 23854: printf("Leak of %d blocks found in xmlValidateNMToken",
! 23855: xmlMemBlocks() - mem_base);
! 23856: test_ret++;
! 23857: printf(" %d", n_value);
! 23858: printf(" %d", n_space);
! 23859: printf("\n");
! 23860: }
! 23861: }
! 23862: }
! 23863: function_tests++;
! 23864: #endif
! 23865: #endif
! 23866:
! 23867: return(test_ret);
! 23868: }
! 23869:
! 23870:
! 23871: static int
! 23872: test_xmlValidateName(void) {
! 23873: int test_ret = 0;
! 23874:
! 23875: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 23876: #ifdef LIBXML_TREE_ENABLED
! 23877: int mem_base;
! 23878: int ret_val;
! 23879: xmlChar * value; /* the value to check */
! 23880: int n_value;
! 23881: int space; /* allow spaces in front and end of the string */
! 23882: int n_space;
! 23883:
! 23884: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 23885: for (n_space = 0;n_space < gen_nb_int;n_space++) {
! 23886: mem_base = xmlMemBlocks();
! 23887: value = gen_const_xmlChar_ptr(n_value, 0);
! 23888: space = gen_int(n_space, 1);
! 23889:
! 23890: ret_val = xmlValidateName((const xmlChar *)value, space);
! 23891: desret_int(ret_val);
! 23892: call_tests++;
! 23893: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
! 23894: des_int(n_space, space, 1);
! 23895: xmlResetLastError();
! 23896: if (mem_base != xmlMemBlocks()) {
! 23897: printf("Leak of %d blocks found in xmlValidateName",
! 23898: xmlMemBlocks() - mem_base);
! 23899: test_ret++;
! 23900: printf(" %d", n_value);
! 23901: printf(" %d", n_space);
! 23902: printf("\n");
! 23903: }
! 23904: }
! 23905: }
! 23906: function_tests++;
! 23907: #endif
! 23908: #endif
! 23909:
! 23910: return(test_ret);
! 23911: }
! 23912:
! 23913:
! 23914: static int
! 23915: test_xmlValidateQName(void) {
! 23916: int test_ret = 0;
! 23917:
! 23918: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 23919: #ifdef LIBXML_TREE_ENABLED
! 23920: int mem_base;
! 23921: int ret_val;
! 23922: xmlChar * value; /* the value to check */
! 23923: int n_value;
! 23924: int space; /* allow spaces in front and end of the string */
! 23925: int n_space;
! 23926:
! 23927: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 23928: for (n_space = 0;n_space < gen_nb_int;n_space++) {
! 23929: mem_base = xmlMemBlocks();
! 23930: value = gen_const_xmlChar_ptr(n_value, 0);
! 23931: space = gen_int(n_space, 1);
! 23932:
! 23933: ret_val = xmlValidateQName((const xmlChar *)value, space);
! 23934: desret_int(ret_val);
! 23935: call_tests++;
! 23936: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
! 23937: des_int(n_space, space, 1);
! 23938: xmlResetLastError();
! 23939: if (mem_base != xmlMemBlocks()) {
! 23940: printf("Leak of %d blocks found in xmlValidateQName",
! 23941: xmlMemBlocks() - mem_base);
! 23942: test_ret++;
! 23943: printf(" %d", n_value);
! 23944: printf(" %d", n_space);
! 23945: printf("\n");
! 23946: }
! 23947: }
! 23948: }
! 23949: function_tests++;
! 23950: #endif
! 23951: #endif
! 23952:
! 23953: return(test_ret);
! 23954: }
! 23955:
! 23956: static int
! 23957: test_tree(void) {
! 23958: int test_ret = 0;
! 23959:
! 23960: if (quiet == 0) printf("Testing tree : 138 of 157 functions ...\n");
! 23961: test_ret += test_xmlAddChild();
! 23962: test_ret += test_xmlAddChildList();
! 23963: test_ret += test_xmlAddNextSibling();
! 23964: test_ret += test_xmlAddPrevSibling();
! 23965: test_ret += test_xmlAddSibling();
! 23966: test_ret += test_xmlAttrSerializeTxtContent();
! 23967: test_ret += test_xmlBufferAdd();
! 23968: test_ret += test_xmlBufferAddHead();
! 23969: test_ret += test_xmlBufferCCat();
! 23970: test_ret += test_xmlBufferCat();
! 23971: test_ret += test_xmlBufferContent();
! 23972: test_ret += test_xmlBufferCreate();
! 23973: test_ret += test_xmlBufferCreateSize();
! 23974: test_ret += test_xmlBufferCreateStatic();
! 23975: test_ret += test_xmlBufferEmpty();
! 23976: test_ret += test_xmlBufferGrow();
! 23977: test_ret += test_xmlBufferLength();
! 23978: test_ret += test_xmlBufferResize();
! 23979: test_ret += test_xmlBufferSetAllocationScheme();
! 23980: test_ret += test_xmlBufferShrink();
! 23981: test_ret += test_xmlBufferWriteCHAR();
! 23982: test_ret += test_xmlBufferWriteChar();
! 23983: test_ret += test_xmlBufferWriteQuotedString();
! 23984: test_ret += test_xmlBuildQName();
! 23985: test_ret += test_xmlChildElementCount();
! 23986: test_ret += test_xmlCopyDoc();
! 23987: test_ret += test_xmlCopyDtd();
! 23988: test_ret += test_xmlCopyNamespace();
! 23989: test_ret += test_xmlCopyNamespaceList();
! 23990: test_ret += test_xmlCopyNode();
! 23991: test_ret += test_xmlCopyNodeList();
! 23992: test_ret += test_xmlCopyProp();
! 23993: test_ret += test_xmlCopyPropList();
! 23994: test_ret += test_xmlCreateIntSubset();
! 23995: test_ret += test_xmlDOMWrapAdoptNode();
! 23996: test_ret += test_xmlDOMWrapCloneNode();
! 23997: test_ret += test_xmlDOMWrapNewCtxt();
! 23998: test_ret += test_xmlDOMWrapReconcileNamespaces();
! 23999: test_ret += test_xmlDOMWrapRemoveNode();
! 24000: test_ret += test_xmlDocCopyNode();
! 24001: test_ret += test_xmlDocCopyNodeList();
! 24002: test_ret += test_xmlDocDump();
! 24003: test_ret += test_xmlDocDumpFormatMemory();
! 24004: test_ret += test_xmlDocDumpFormatMemoryEnc();
! 24005: test_ret += test_xmlDocDumpMemory();
! 24006: test_ret += test_xmlDocDumpMemoryEnc();
! 24007: test_ret += test_xmlDocFormatDump();
! 24008: test_ret += test_xmlDocGetRootElement();
! 24009: test_ret += test_xmlDocSetRootElement();
! 24010: test_ret += test_xmlElemDump();
! 24011: test_ret += test_xmlFirstElementChild();
! 24012: test_ret += test_xmlGetBufferAllocationScheme();
! 24013: test_ret += test_xmlGetCompressMode();
! 24014: test_ret += test_xmlGetDocCompressMode();
! 24015: test_ret += test_xmlGetIntSubset();
! 24016: test_ret += test_xmlGetLastChild();
! 24017: test_ret += test_xmlGetLineNo();
! 24018: test_ret += test_xmlGetNoNsProp();
! 24019: test_ret += test_xmlGetNodePath();
! 24020: test_ret += test_xmlGetNsList();
! 24021: test_ret += test_xmlGetNsProp();
! 24022: test_ret += test_xmlGetProp();
! 24023: test_ret += test_xmlHasNsProp();
! 24024: test_ret += test_xmlHasProp();
! 24025: test_ret += test_xmlIsBlankNode();
! 24026: test_ret += test_xmlIsXHTML();
! 24027: test_ret += test_xmlLastElementChild();
! 24028: test_ret += test_xmlNewCDataBlock();
! 24029: test_ret += test_xmlNewCharRef();
! 24030: test_ret += test_xmlNewChild();
! 24031: test_ret += test_xmlNewComment();
! 24032: test_ret += test_xmlNewDoc();
! 24033: test_ret += test_xmlNewDocComment();
! 24034: test_ret += test_xmlNewDocFragment();
! 24035: test_ret += test_xmlNewDocNode();
! 24036: test_ret += test_xmlNewDocNodeEatName();
! 24037: test_ret += test_xmlNewDocPI();
! 24038: test_ret += test_xmlNewDocProp();
! 24039: test_ret += test_xmlNewDocRawNode();
! 24040: test_ret += test_xmlNewDocText();
! 24041: test_ret += test_xmlNewDocTextLen();
! 24042: test_ret += test_xmlNewDtd();
! 24043: test_ret += test_xmlNewNode();
! 24044: test_ret += test_xmlNewNodeEatName();
! 24045: test_ret += test_xmlNewNs();
! 24046: test_ret += test_xmlNewNsProp();
! 24047: test_ret += test_xmlNewNsPropEatName();
! 24048: test_ret += test_xmlNewPI();
! 24049: test_ret += test_xmlNewProp();
! 24050: test_ret += test_xmlNewReference();
! 24051: test_ret += test_xmlNewText();
! 24052: test_ret += test_xmlNewTextChild();
! 24053: test_ret += test_xmlNewTextLen();
! 24054: test_ret += test_xmlNextElementSibling();
! 24055: test_ret += test_xmlNodeAddContent();
! 24056: test_ret += test_xmlNodeAddContentLen();
! 24057: test_ret += test_xmlNodeBufGetContent();
! 24058: test_ret += test_xmlNodeDump();
! 24059: test_ret += test_xmlNodeDumpOutput();
! 24060: test_ret += test_xmlNodeGetBase();
! 24061: test_ret += test_xmlNodeGetContent();
! 24062: test_ret += test_xmlNodeGetLang();
! 24063: test_ret += test_xmlNodeGetSpacePreserve();
! 24064: test_ret += test_xmlNodeIsText();
! 24065: test_ret += test_xmlNodeListGetRawString();
! 24066: test_ret += test_xmlNodeListGetString();
! 24067: test_ret += test_xmlNodeSetBase();
! 24068: test_ret += test_xmlNodeSetContent();
! 24069: test_ret += test_xmlNodeSetContentLen();
! 24070: test_ret += test_xmlNodeSetLang();
! 24071: test_ret += test_xmlNodeSetName();
! 24072: test_ret += test_xmlNodeSetSpacePreserve();
! 24073: test_ret += test_xmlPreviousElementSibling();
! 24074: test_ret += test_xmlReconciliateNs();
! 24075: test_ret += test_xmlRemoveProp();
! 24076: test_ret += test_xmlReplaceNode();
! 24077: test_ret += test_xmlSaveFile();
! 24078: test_ret += test_xmlSaveFileEnc();
! 24079: test_ret += test_xmlSaveFileTo();
! 24080: test_ret += test_xmlSaveFormatFile();
! 24081: test_ret += test_xmlSaveFormatFileEnc();
! 24082: test_ret += test_xmlSaveFormatFileTo();
! 24083: test_ret += test_xmlSearchNs();
! 24084: test_ret += test_xmlSearchNsByHref();
! 24085: test_ret += test_xmlSetBufferAllocationScheme();
! 24086: test_ret += test_xmlSetCompressMode();
! 24087: test_ret += test_xmlSetDocCompressMode();
! 24088: test_ret += test_xmlSetNs();
! 24089: test_ret += test_xmlSetNsProp();
! 24090: test_ret += test_xmlSetProp();
! 24091: test_ret += test_xmlSplitQName2();
! 24092: test_ret += test_xmlSplitQName3();
! 24093: test_ret += test_xmlStringGetNodeList();
! 24094: test_ret += test_xmlStringLenGetNodeList();
! 24095: test_ret += test_xmlTextConcat();
! 24096: test_ret += test_xmlTextMerge();
! 24097: test_ret += test_xmlUnsetNsProp();
! 24098: test_ret += test_xmlUnsetProp();
! 24099: test_ret += test_xmlValidateNCName();
! 24100: test_ret += test_xmlValidateNMToken();
! 24101: test_ret += test_xmlValidateName();
! 24102: test_ret += test_xmlValidateQName();
! 24103:
! 24104: if (test_ret != 0)
! 24105: printf("Module tree: %d errors\n", test_ret);
! 24106: return(test_ret);
! 24107: }
! 24108:
! 24109: static int
! 24110: test_xmlBuildRelativeURI(void) {
! 24111: int test_ret = 0;
! 24112:
! 24113: int mem_base;
! 24114: xmlChar * ret_val;
! 24115: xmlChar * URI; /* the URI reference under consideration */
! 24116: int n_URI;
! 24117: xmlChar * base; /* the base value */
! 24118: int n_base;
! 24119:
! 24120: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
! 24121: for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) {
! 24122: mem_base = xmlMemBlocks();
! 24123: URI = gen_const_xmlChar_ptr(n_URI, 0);
! 24124: base = gen_const_xmlChar_ptr(n_base, 1);
! 24125:
! 24126: ret_val = xmlBuildRelativeURI((const xmlChar *)URI, (const xmlChar *)base);
! 24127: desret_xmlChar_ptr(ret_val);
! 24128: call_tests++;
! 24129: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
! 24130: des_const_xmlChar_ptr(n_base, (const xmlChar *)base, 1);
! 24131: xmlResetLastError();
! 24132: if (mem_base != xmlMemBlocks()) {
! 24133: printf("Leak of %d blocks found in xmlBuildRelativeURI",
! 24134: xmlMemBlocks() - mem_base);
! 24135: test_ret++;
! 24136: printf(" %d", n_URI);
! 24137: printf(" %d", n_base);
! 24138: printf("\n");
! 24139: }
! 24140: }
! 24141: }
! 24142: function_tests++;
! 24143:
! 24144: return(test_ret);
! 24145: }
! 24146:
! 24147:
! 24148: static int
! 24149: test_xmlBuildURI(void) {
! 24150: int test_ret = 0;
! 24151:
! 24152: int mem_base;
! 24153: xmlChar * ret_val;
! 24154: xmlChar * URI; /* the URI instance found in the document */
! 24155: int n_URI;
! 24156: xmlChar * base; /* the base value */
! 24157: int n_base;
! 24158:
! 24159: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
! 24160: for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) {
! 24161: mem_base = xmlMemBlocks();
! 24162: URI = gen_const_xmlChar_ptr(n_URI, 0);
! 24163: base = gen_const_xmlChar_ptr(n_base, 1);
! 24164:
! 24165: ret_val = xmlBuildURI((const xmlChar *)URI, (const xmlChar *)base);
! 24166: desret_xmlChar_ptr(ret_val);
! 24167: call_tests++;
! 24168: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
! 24169: des_const_xmlChar_ptr(n_base, (const xmlChar *)base, 1);
! 24170: xmlResetLastError();
! 24171: if (mem_base != xmlMemBlocks()) {
! 24172: printf("Leak of %d blocks found in xmlBuildURI",
! 24173: xmlMemBlocks() - mem_base);
! 24174: test_ret++;
! 24175: printf(" %d", n_URI);
! 24176: printf(" %d", n_base);
! 24177: printf("\n");
! 24178: }
! 24179: }
! 24180: }
! 24181: function_tests++;
! 24182:
! 24183: return(test_ret);
! 24184: }
! 24185:
! 24186:
! 24187: static int
! 24188: test_xmlCanonicPath(void) {
! 24189: int test_ret = 0;
! 24190:
! 24191: int mem_base;
! 24192: xmlChar * ret_val;
! 24193: xmlChar * path; /* the resource locator in a filesystem notation */
! 24194: int n_path;
! 24195:
! 24196: for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) {
! 24197: mem_base = xmlMemBlocks();
! 24198: path = gen_const_xmlChar_ptr(n_path, 0);
! 24199:
! 24200: ret_val = xmlCanonicPath((const xmlChar *)path);
! 24201: desret_xmlChar_ptr(ret_val);
! 24202: call_tests++;
! 24203: des_const_xmlChar_ptr(n_path, (const xmlChar *)path, 0);
! 24204: xmlResetLastError();
! 24205: if (mem_base != xmlMemBlocks()) {
! 24206: printf("Leak of %d blocks found in xmlCanonicPath",
! 24207: xmlMemBlocks() - mem_base);
! 24208: test_ret++;
! 24209: printf(" %d", n_path);
! 24210: printf("\n");
! 24211: }
! 24212: }
! 24213: function_tests++;
! 24214:
! 24215: return(test_ret);
! 24216: }
! 24217:
! 24218:
! 24219: static int
! 24220: test_xmlCreateURI(void) {
! 24221: int test_ret = 0;
! 24222:
! 24223:
! 24224: /* missing type support */
! 24225: return(test_ret);
! 24226: }
! 24227:
! 24228:
! 24229: static int
! 24230: test_xmlNormalizeURIPath(void) {
! 24231: int test_ret = 0;
! 24232:
! 24233: int mem_base;
! 24234: int ret_val;
! 24235: char * path; /* pointer to the path string */
! 24236: int n_path;
! 24237:
! 24238: for (n_path = 0;n_path < gen_nb_char_ptr;n_path++) {
! 24239: mem_base = xmlMemBlocks();
! 24240: path = gen_char_ptr(n_path, 0);
! 24241:
! 24242: ret_val = xmlNormalizeURIPath(path);
! 24243: desret_int(ret_val);
! 24244: call_tests++;
! 24245: des_char_ptr(n_path, path, 0);
! 24246: xmlResetLastError();
! 24247: if (mem_base != xmlMemBlocks()) {
! 24248: printf("Leak of %d blocks found in xmlNormalizeURIPath",
! 24249: xmlMemBlocks() - mem_base);
! 24250: test_ret++;
! 24251: printf(" %d", n_path);
! 24252: printf("\n");
! 24253: }
! 24254: }
! 24255: function_tests++;
! 24256:
! 24257: return(test_ret);
! 24258: }
! 24259:
! 24260:
! 24261: static int
! 24262: test_xmlParseURI(void) {
! 24263: int test_ret = 0;
! 24264:
! 24265:
! 24266: /* missing type support */
! 24267: return(test_ret);
! 24268: }
! 24269:
! 24270:
! 24271: static int
! 24272: test_xmlParseURIRaw(void) {
! 24273: int test_ret = 0;
! 24274:
! 24275:
! 24276: /* missing type support */
! 24277: return(test_ret);
! 24278: }
! 24279:
! 24280:
! 24281: #define gen_nb_xmlURIPtr 1
! 24282: static xmlURIPtr gen_xmlURIPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 24283: return(NULL);
! 24284: }
! 24285: static void des_xmlURIPtr(int no ATTRIBUTE_UNUSED, xmlURIPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 24286: }
! 24287:
! 24288: static int
! 24289: test_xmlParseURIReference(void) {
! 24290: int test_ret = 0;
! 24291:
! 24292: int mem_base;
! 24293: int ret_val;
! 24294: xmlURIPtr uri; /* pointer to an URI structure */
! 24295: int n_uri;
! 24296: char * str; /* the string to analyze */
! 24297: int n_str;
! 24298:
! 24299: for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) {
! 24300: for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) {
! 24301: mem_base = xmlMemBlocks();
! 24302: uri = gen_xmlURIPtr(n_uri, 0);
! 24303: str = gen_const_char_ptr(n_str, 1);
! 24304:
! 24305: ret_val = xmlParseURIReference(uri, (const char *)str);
! 24306: desret_int(ret_val);
! 24307: call_tests++;
! 24308: des_xmlURIPtr(n_uri, uri, 0);
! 24309: des_const_char_ptr(n_str, (const char *)str, 1);
! 24310: xmlResetLastError();
! 24311: if (mem_base != xmlMemBlocks()) {
! 24312: printf("Leak of %d blocks found in xmlParseURIReference",
! 24313: xmlMemBlocks() - mem_base);
! 24314: test_ret++;
! 24315: printf(" %d", n_uri);
! 24316: printf(" %d", n_str);
! 24317: printf("\n");
! 24318: }
! 24319: }
! 24320: }
! 24321: function_tests++;
! 24322:
! 24323: return(test_ret);
! 24324: }
! 24325:
! 24326:
! 24327: static int
! 24328: test_xmlPathToURI(void) {
! 24329: int test_ret = 0;
! 24330:
! 24331: int mem_base;
! 24332: xmlChar * ret_val;
! 24333: xmlChar * path; /* the resource locator in a filesystem notation */
! 24334: int n_path;
! 24335:
! 24336: for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) {
! 24337: mem_base = xmlMemBlocks();
! 24338: path = gen_const_xmlChar_ptr(n_path, 0);
! 24339:
! 24340: ret_val = xmlPathToURI((const xmlChar *)path);
! 24341: desret_xmlChar_ptr(ret_val);
! 24342: call_tests++;
! 24343: des_const_xmlChar_ptr(n_path, (const xmlChar *)path, 0);
! 24344: xmlResetLastError();
! 24345: if (mem_base != xmlMemBlocks()) {
! 24346: printf("Leak of %d blocks found in xmlPathToURI",
! 24347: xmlMemBlocks() - mem_base);
! 24348: test_ret++;
! 24349: printf(" %d", n_path);
! 24350: printf("\n");
! 24351: }
! 24352: }
! 24353: function_tests++;
! 24354:
! 24355: return(test_ret);
! 24356: }
! 24357:
! 24358:
! 24359: static int
! 24360: test_xmlPrintURI(void) {
! 24361: int test_ret = 0;
! 24362:
! 24363: int mem_base;
! 24364: FILE * stream; /* a FILE* for the output */
! 24365: int n_stream;
! 24366: xmlURIPtr uri; /* pointer to an xmlURI */
! 24367: int n_uri;
! 24368:
! 24369: for (n_stream = 0;n_stream < gen_nb_FILE_ptr;n_stream++) {
! 24370: for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) {
! 24371: mem_base = xmlMemBlocks();
! 24372: stream = gen_FILE_ptr(n_stream, 0);
! 24373: uri = gen_xmlURIPtr(n_uri, 1);
! 24374:
! 24375: xmlPrintURI(stream, uri);
! 24376: call_tests++;
! 24377: des_FILE_ptr(n_stream, stream, 0);
! 24378: des_xmlURIPtr(n_uri, uri, 1);
! 24379: xmlResetLastError();
! 24380: if (mem_base != xmlMemBlocks()) {
! 24381: printf("Leak of %d blocks found in xmlPrintURI",
! 24382: xmlMemBlocks() - mem_base);
! 24383: test_ret++;
! 24384: printf(" %d", n_stream);
! 24385: printf(" %d", n_uri);
! 24386: printf("\n");
! 24387: }
! 24388: }
! 24389: }
! 24390: function_tests++;
! 24391:
! 24392: return(test_ret);
! 24393: }
! 24394:
! 24395:
! 24396: static int
! 24397: test_xmlSaveUri(void) {
! 24398: int test_ret = 0;
! 24399:
! 24400: int mem_base;
! 24401: xmlChar * ret_val;
! 24402: xmlURIPtr uri; /* pointer to an xmlURI */
! 24403: int n_uri;
! 24404:
! 24405: for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) {
! 24406: mem_base = xmlMemBlocks();
! 24407: uri = gen_xmlURIPtr(n_uri, 0);
! 24408:
! 24409: ret_val = xmlSaveUri(uri);
! 24410: desret_xmlChar_ptr(ret_val);
! 24411: call_tests++;
! 24412: des_xmlURIPtr(n_uri, uri, 0);
! 24413: xmlResetLastError();
! 24414: if (mem_base != xmlMemBlocks()) {
! 24415: printf("Leak of %d blocks found in xmlSaveUri",
! 24416: xmlMemBlocks() - mem_base);
! 24417: test_ret++;
! 24418: printf(" %d", n_uri);
! 24419: printf("\n");
! 24420: }
! 24421: }
! 24422: function_tests++;
! 24423:
! 24424: return(test_ret);
! 24425: }
! 24426:
! 24427:
! 24428: static int
! 24429: test_xmlURIEscape(void) {
! 24430: int test_ret = 0;
! 24431:
! 24432: int mem_base;
! 24433: xmlChar * ret_val;
! 24434: xmlChar * str; /* the string of the URI to escape */
! 24435: int n_str;
! 24436:
! 24437: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 24438: mem_base = xmlMemBlocks();
! 24439: str = gen_const_xmlChar_ptr(n_str, 0);
! 24440:
! 24441: ret_val = xmlURIEscape((const xmlChar *)str);
! 24442: desret_xmlChar_ptr(ret_val);
! 24443: call_tests++;
! 24444: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
! 24445: xmlResetLastError();
! 24446: if (mem_base != xmlMemBlocks()) {
! 24447: printf("Leak of %d blocks found in xmlURIEscape",
! 24448: xmlMemBlocks() - mem_base);
! 24449: test_ret++;
! 24450: printf(" %d", n_str);
! 24451: printf("\n");
! 24452: }
! 24453: }
! 24454: function_tests++;
! 24455:
! 24456: return(test_ret);
! 24457: }
! 24458:
! 24459:
! 24460: static int
! 24461: test_xmlURIEscapeStr(void) {
! 24462: int test_ret = 0;
! 24463:
! 24464: int mem_base;
! 24465: xmlChar * ret_val;
! 24466: xmlChar * str; /* string to escape */
! 24467: int n_str;
! 24468: xmlChar * list; /* exception list string of chars not to escape */
! 24469: int n_list;
! 24470:
! 24471: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 24472: for (n_list = 0;n_list < gen_nb_const_xmlChar_ptr;n_list++) {
! 24473: mem_base = xmlMemBlocks();
! 24474: str = gen_const_xmlChar_ptr(n_str, 0);
! 24475: list = gen_const_xmlChar_ptr(n_list, 1);
! 24476:
! 24477: ret_val = xmlURIEscapeStr((const xmlChar *)str, (const xmlChar *)list);
! 24478: desret_xmlChar_ptr(ret_val);
! 24479: call_tests++;
! 24480: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
! 24481: des_const_xmlChar_ptr(n_list, (const xmlChar *)list, 1);
! 24482: xmlResetLastError();
! 24483: if (mem_base != xmlMemBlocks()) {
! 24484: printf("Leak of %d blocks found in xmlURIEscapeStr",
! 24485: xmlMemBlocks() - mem_base);
! 24486: test_ret++;
! 24487: printf(" %d", n_str);
! 24488: printf(" %d", n_list);
! 24489: printf("\n");
! 24490: }
! 24491: }
! 24492: }
! 24493: function_tests++;
! 24494:
! 24495: return(test_ret);
! 24496: }
! 24497:
! 24498:
! 24499: static int
! 24500: test_xmlURIUnescapeString(void) {
! 24501: int test_ret = 0;
! 24502:
! 24503:
! 24504: /* missing type support */
! 24505: return(test_ret);
! 24506: }
! 24507:
! 24508: static int
! 24509: test_uri(void) {
! 24510: int test_ret = 0;
! 24511:
! 24512: if (quiet == 0) printf("Testing uri : 10 of 15 functions ...\n");
! 24513: test_ret += test_xmlBuildRelativeURI();
! 24514: test_ret += test_xmlBuildURI();
! 24515: test_ret += test_xmlCanonicPath();
! 24516: test_ret += test_xmlCreateURI();
! 24517: test_ret += test_xmlNormalizeURIPath();
! 24518: test_ret += test_xmlParseURI();
! 24519: test_ret += test_xmlParseURIRaw();
! 24520: test_ret += test_xmlParseURIReference();
! 24521: test_ret += test_xmlPathToURI();
! 24522: test_ret += test_xmlPrintURI();
! 24523: test_ret += test_xmlSaveUri();
! 24524: test_ret += test_xmlURIEscape();
! 24525: test_ret += test_xmlURIEscapeStr();
! 24526: test_ret += test_xmlURIUnescapeString();
! 24527:
! 24528: if (test_ret != 0)
! 24529: printf("Module uri: %d errors\n", test_ret);
! 24530: return(test_ret);
! 24531: }
! 24532:
! 24533: static int
! 24534: test_xmlAddAttributeDecl(void) {
! 24535: int test_ret = 0;
! 24536:
! 24537: int mem_base;
! 24538: xmlAttributePtr ret_val;
! 24539: xmlValidCtxtPtr ctxt; /* the validation context */
! 24540: int n_ctxt;
! 24541: xmlDtdPtr dtd; /* pointer to the DTD */
! 24542: int n_dtd;
! 24543: xmlChar * elem; /* the element name */
! 24544: int n_elem;
! 24545: xmlChar * name; /* the attribute name */
! 24546: int n_name;
! 24547: xmlChar * ns; /* the attribute namespace prefix */
! 24548: int n_ns;
! 24549: xmlAttributeType type; /* the attribute type */
! 24550: int n_type;
! 24551: xmlAttributeDefault def; /* the attribute default type */
! 24552: int n_def;
! 24553: xmlChar * defaultValue; /* the attribute default value */
! 24554: int n_defaultValue;
! 24555: xmlEnumerationPtr tree; /* if it's an enumeration, the associated list */
! 24556: int n_tree;
! 24557:
! 24558: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
! 24559: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
! 24560: for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
! 24561: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 24562: for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
! 24563: for (n_type = 0;n_type < gen_nb_xmlAttributeType;n_type++) {
! 24564: for (n_def = 0;n_def < gen_nb_xmlAttributeDefault;n_def++) {
! 24565: for (n_defaultValue = 0;n_defaultValue < gen_nb_const_xmlChar_ptr;n_defaultValue++) {
! 24566: for (n_tree = 0;n_tree < gen_nb_xmlEnumerationPtr;n_tree++) {
! 24567: mem_base = xmlMemBlocks();
! 24568: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
! 24569: dtd = gen_xmlDtdPtr(n_dtd, 1);
! 24570: elem = gen_const_xmlChar_ptr(n_elem, 2);
! 24571: name = gen_const_xmlChar_ptr(n_name, 3);
! 24572: ns = gen_const_xmlChar_ptr(n_ns, 4);
! 24573: type = gen_xmlAttributeType(n_type, 5);
! 24574: def = gen_xmlAttributeDefault(n_def, 6);
! 24575: defaultValue = gen_const_xmlChar_ptr(n_defaultValue, 7);
! 24576: tree = gen_xmlEnumerationPtr(n_tree, 8);
! 24577:
! 24578: ret_val = xmlAddAttributeDecl(ctxt, dtd, (const xmlChar *)elem, (const xmlChar *)name, (const xmlChar *)ns, type, def, (const xmlChar *)defaultValue, tree);
! 24579: desret_xmlAttributePtr(ret_val);
! 24580: call_tests++;
! 24581: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
! 24582: des_xmlDtdPtr(n_dtd, dtd, 1);
! 24583: des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 2);
! 24584: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 3);
! 24585: des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 4);
! 24586: des_xmlAttributeType(n_type, type, 5);
! 24587: des_xmlAttributeDefault(n_def, def, 6);
! 24588: des_const_xmlChar_ptr(n_defaultValue, (const xmlChar *)defaultValue, 7);
! 24589: des_xmlEnumerationPtr(n_tree, tree, 8);
! 24590: xmlResetLastError();
! 24591: if (mem_base != xmlMemBlocks()) {
! 24592: printf("Leak of %d blocks found in xmlAddAttributeDecl",
! 24593: xmlMemBlocks() - mem_base);
! 24594: test_ret++;
! 24595: printf(" %d", n_ctxt);
! 24596: printf(" %d", n_dtd);
! 24597: printf(" %d", n_elem);
! 24598: printf(" %d", n_name);
! 24599: printf(" %d", n_ns);
! 24600: printf(" %d", n_type);
! 24601: printf(" %d", n_def);
! 24602: printf(" %d", n_defaultValue);
! 24603: printf(" %d", n_tree);
! 24604: printf("\n");
! 24605: }
! 24606: }
! 24607: }
! 24608: }
! 24609: }
! 24610: }
! 24611: }
! 24612: }
! 24613: }
! 24614: }
! 24615: function_tests++;
! 24616:
! 24617: return(test_ret);
! 24618: }
! 24619:
! 24620:
! 24621: static int
! 24622: test_xmlAddElementDecl(void) {
! 24623: int test_ret = 0;
! 24624:
! 24625: int mem_base;
! 24626: xmlElementPtr ret_val;
! 24627: xmlValidCtxtPtr ctxt; /* the validation context */
! 24628: int n_ctxt;
! 24629: xmlDtdPtr dtd; /* pointer to the DTD */
! 24630: int n_dtd;
! 24631: xmlChar * name; /* the entity name */
! 24632: int n_name;
! 24633: xmlElementTypeVal type; /* the element type */
! 24634: int n_type;
! 24635: xmlElementContentPtr content; /* the element content tree or NULL */
! 24636: int n_content;
! 24637:
! 24638: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
! 24639: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
! 24640: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 24641: for (n_type = 0;n_type < gen_nb_xmlElementTypeVal;n_type++) {
! 24642: for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
! 24643: mem_base = xmlMemBlocks();
! 24644: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
! 24645: dtd = gen_xmlDtdPtr(n_dtd, 1);
! 24646: name = gen_const_xmlChar_ptr(n_name, 2);
! 24647: type = gen_xmlElementTypeVal(n_type, 3);
! 24648: content = gen_xmlElementContentPtr(n_content, 4);
! 24649:
! 24650: ret_val = xmlAddElementDecl(ctxt, dtd, (const xmlChar *)name, type, content);
! 24651: desret_xmlElementPtr(ret_val);
! 24652: call_tests++;
! 24653: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
! 24654: des_xmlDtdPtr(n_dtd, dtd, 1);
! 24655: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 24656: des_xmlElementTypeVal(n_type, type, 3);
! 24657: des_xmlElementContentPtr(n_content, content, 4);
! 24658: xmlResetLastError();
! 24659: if (mem_base != xmlMemBlocks()) {
! 24660: printf("Leak of %d blocks found in xmlAddElementDecl",
! 24661: xmlMemBlocks() - mem_base);
! 24662: test_ret++;
! 24663: printf(" %d", n_ctxt);
! 24664: printf(" %d", n_dtd);
! 24665: printf(" %d", n_name);
! 24666: printf(" %d", n_type);
! 24667: printf(" %d", n_content);
! 24668: printf("\n");
! 24669: }
! 24670: }
! 24671: }
! 24672: }
! 24673: }
! 24674: }
! 24675: function_tests++;
! 24676:
! 24677: return(test_ret);
! 24678: }
! 24679:
! 24680:
! 24681: static int
! 24682: test_xmlAddID(void) {
! 24683: int test_ret = 0;
! 24684:
! 24685:
! 24686: /* missing type support */
! 24687: return(test_ret);
! 24688: }
! 24689:
! 24690:
! 24691: static int
! 24692: test_xmlAddNotationDecl(void) {
! 24693: int test_ret = 0;
! 24694:
! 24695:
! 24696: /* missing type support */
! 24697: return(test_ret);
! 24698: }
! 24699:
! 24700:
! 24701: static int
! 24702: test_xmlAddRef(void) {
! 24703: int test_ret = 0;
! 24704:
! 24705:
! 24706: /* missing type support */
! 24707: return(test_ret);
! 24708: }
! 24709:
! 24710:
! 24711: #define gen_nb_xmlAttributeTablePtr 1
! 24712: static xmlAttributeTablePtr gen_xmlAttributeTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 24713: return(NULL);
! 24714: }
! 24715: static void des_xmlAttributeTablePtr(int no ATTRIBUTE_UNUSED, xmlAttributeTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 24716: }
! 24717:
! 24718: static int
! 24719: test_xmlCopyAttributeTable(void) {
! 24720: int test_ret = 0;
! 24721:
! 24722:
! 24723: /* missing type support */
! 24724: return(test_ret);
! 24725: }
! 24726:
! 24727:
! 24728: static int
! 24729: test_xmlCopyDocElementContent(void) {
! 24730: int test_ret = 0;
! 24731:
! 24732: int mem_base;
! 24733: xmlElementContentPtr ret_val;
! 24734: xmlDocPtr doc; /* the document owning the element declaration */
! 24735: int n_doc;
! 24736: xmlElementContentPtr cur; /* An element content pointer. */
! 24737: int n_cur;
! 24738:
! 24739: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 24740: for (n_cur = 0;n_cur < gen_nb_xmlElementContentPtr;n_cur++) {
! 24741: mem_base = xmlMemBlocks();
! 24742: doc = gen_xmlDocPtr(n_doc, 0);
! 24743: cur = gen_xmlElementContentPtr(n_cur, 1);
! 24744:
! 24745: ret_val = xmlCopyDocElementContent(doc, cur);
! 24746: desret_xmlElementContentPtr(ret_val);
! 24747: call_tests++;
! 24748: des_xmlDocPtr(n_doc, doc, 0);
! 24749: des_xmlElementContentPtr(n_cur, cur, 1);
! 24750: xmlResetLastError();
! 24751: if (mem_base != xmlMemBlocks()) {
! 24752: printf("Leak of %d blocks found in xmlCopyDocElementContent",
! 24753: xmlMemBlocks() - mem_base);
! 24754: test_ret++;
! 24755: printf(" %d", n_doc);
! 24756: printf(" %d", n_cur);
! 24757: printf("\n");
! 24758: }
! 24759: }
! 24760: }
! 24761: function_tests++;
! 24762:
! 24763: return(test_ret);
! 24764: }
! 24765:
! 24766:
! 24767: static int
! 24768: test_xmlCopyElementContent(void) {
! 24769: int test_ret = 0;
! 24770:
! 24771: int mem_base;
! 24772: xmlElementContentPtr ret_val;
! 24773: xmlElementContentPtr cur; /* An element content pointer. */
! 24774: int n_cur;
! 24775:
! 24776: for (n_cur = 0;n_cur < gen_nb_xmlElementContentPtr;n_cur++) {
! 24777: mem_base = xmlMemBlocks();
! 24778: cur = gen_xmlElementContentPtr(n_cur, 0);
! 24779:
! 24780: ret_val = xmlCopyElementContent(cur);
! 24781: desret_xmlElementContentPtr(ret_val);
! 24782: call_tests++;
! 24783: des_xmlElementContentPtr(n_cur, cur, 0);
! 24784: xmlResetLastError();
! 24785: if (mem_base != xmlMemBlocks()) {
! 24786: printf("Leak of %d blocks found in xmlCopyElementContent",
! 24787: xmlMemBlocks() - mem_base);
! 24788: test_ret++;
! 24789: printf(" %d", n_cur);
! 24790: printf("\n");
! 24791: }
! 24792: }
! 24793: function_tests++;
! 24794:
! 24795: return(test_ret);
! 24796: }
! 24797:
! 24798:
! 24799: #define gen_nb_xmlElementTablePtr 1
! 24800: static xmlElementTablePtr gen_xmlElementTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 24801: return(NULL);
! 24802: }
! 24803: static void des_xmlElementTablePtr(int no ATTRIBUTE_UNUSED, xmlElementTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 24804: }
! 24805:
! 24806: static int
! 24807: test_xmlCopyElementTable(void) {
! 24808: int test_ret = 0;
! 24809:
! 24810:
! 24811: /* missing type support */
! 24812: return(test_ret);
! 24813: }
! 24814:
! 24815:
! 24816: static int
! 24817: test_xmlCopyEnumeration(void) {
! 24818: int test_ret = 0;
! 24819:
! 24820:
! 24821: /* missing type support */
! 24822: return(test_ret);
! 24823: }
! 24824:
! 24825:
! 24826: #define gen_nb_xmlNotationTablePtr 1
! 24827: static xmlNotationTablePtr gen_xmlNotationTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 24828: return(NULL);
! 24829: }
! 24830: static void des_xmlNotationTablePtr(int no ATTRIBUTE_UNUSED, xmlNotationTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 24831: }
! 24832:
! 24833: static int
! 24834: test_xmlCopyNotationTable(void) {
! 24835: int test_ret = 0;
! 24836:
! 24837:
! 24838: /* missing type support */
! 24839: return(test_ret);
! 24840: }
! 24841:
! 24842:
! 24843: static int
! 24844: test_xmlCreateEnumeration(void) {
! 24845: int test_ret = 0;
! 24846:
! 24847:
! 24848: /* missing type support */
! 24849: return(test_ret);
! 24850: }
! 24851:
! 24852:
! 24853: #define gen_nb_xmlAttributePtr 1
! 24854: static xmlAttributePtr gen_xmlAttributePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 24855: return(NULL);
! 24856: }
! 24857: static void des_xmlAttributePtr(int no ATTRIBUTE_UNUSED, xmlAttributePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 24858: }
! 24859:
! 24860: static int
! 24861: test_xmlDumpAttributeDecl(void) {
! 24862: int test_ret = 0;
! 24863:
! 24864: #if defined(LIBXML_OUTPUT_ENABLED)
! 24865: int mem_base;
! 24866: xmlBufferPtr buf; /* the XML buffer output */
! 24867: int n_buf;
! 24868: xmlAttributePtr attr; /* An attribute declaration */
! 24869: int n_attr;
! 24870:
! 24871: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 24872: for (n_attr = 0;n_attr < gen_nb_xmlAttributePtr;n_attr++) {
! 24873: mem_base = xmlMemBlocks();
! 24874: buf = gen_xmlBufferPtr(n_buf, 0);
! 24875: attr = gen_xmlAttributePtr(n_attr, 1);
! 24876:
! 24877: xmlDumpAttributeDecl(buf, attr);
! 24878: call_tests++;
! 24879: des_xmlBufferPtr(n_buf, buf, 0);
! 24880: des_xmlAttributePtr(n_attr, attr, 1);
! 24881: xmlResetLastError();
! 24882: if (mem_base != xmlMemBlocks()) {
! 24883: printf("Leak of %d blocks found in xmlDumpAttributeDecl",
! 24884: xmlMemBlocks() - mem_base);
! 24885: test_ret++;
! 24886: printf(" %d", n_buf);
! 24887: printf(" %d", n_attr);
! 24888: printf("\n");
! 24889: }
! 24890: }
! 24891: }
! 24892: function_tests++;
! 24893: #endif
! 24894:
! 24895: return(test_ret);
! 24896: }
! 24897:
! 24898:
! 24899: static int
! 24900: test_xmlDumpAttributeTable(void) {
! 24901: int test_ret = 0;
! 24902:
! 24903: #if defined(LIBXML_OUTPUT_ENABLED)
! 24904: int mem_base;
! 24905: xmlBufferPtr buf; /* the XML buffer output */
! 24906: int n_buf;
! 24907: xmlAttributeTablePtr table; /* An attribute table */
! 24908: int n_table;
! 24909:
! 24910: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 24911: for (n_table = 0;n_table < gen_nb_xmlAttributeTablePtr;n_table++) {
! 24912: mem_base = xmlMemBlocks();
! 24913: buf = gen_xmlBufferPtr(n_buf, 0);
! 24914: table = gen_xmlAttributeTablePtr(n_table, 1);
! 24915:
! 24916: xmlDumpAttributeTable(buf, table);
! 24917: call_tests++;
! 24918: des_xmlBufferPtr(n_buf, buf, 0);
! 24919: des_xmlAttributeTablePtr(n_table, table, 1);
! 24920: xmlResetLastError();
! 24921: if (mem_base != xmlMemBlocks()) {
! 24922: printf("Leak of %d blocks found in xmlDumpAttributeTable",
! 24923: xmlMemBlocks() - mem_base);
! 24924: test_ret++;
! 24925: printf(" %d", n_buf);
! 24926: printf(" %d", n_table);
! 24927: printf("\n");
! 24928: }
! 24929: }
! 24930: }
! 24931: function_tests++;
! 24932: #endif
! 24933:
! 24934: return(test_ret);
! 24935: }
! 24936:
! 24937:
! 24938: #define gen_nb_xmlElementPtr 1
! 24939: static xmlElementPtr gen_xmlElementPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 24940: return(NULL);
! 24941: }
! 24942: static void des_xmlElementPtr(int no ATTRIBUTE_UNUSED, xmlElementPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 24943: }
! 24944:
! 24945: static int
! 24946: test_xmlDumpElementDecl(void) {
! 24947: int test_ret = 0;
! 24948:
! 24949: #if defined(LIBXML_OUTPUT_ENABLED)
! 24950: int mem_base;
! 24951: xmlBufferPtr buf; /* the XML buffer output */
! 24952: int n_buf;
! 24953: xmlElementPtr elem; /* An element table */
! 24954: int n_elem;
! 24955:
! 24956: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 24957: for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) {
! 24958: mem_base = xmlMemBlocks();
! 24959: buf = gen_xmlBufferPtr(n_buf, 0);
! 24960: elem = gen_xmlElementPtr(n_elem, 1);
! 24961:
! 24962: xmlDumpElementDecl(buf, elem);
! 24963: call_tests++;
! 24964: des_xmlBufferPtr(n_buf, buf, 0);
! 24965: des_xmlElementPtr(n_elem, elem, 1);
! 24966: xmlResetLastError();
! 24967: if (mem_base != xmlMemBlocks()) {
! 24968: printf("Leak of %d blocks found in xmlDumpElementDecl",
! 24969: xmlMemBlocks() - mem_base);
! 24970: test_ret++;
! 24971: printf(" %d", n_buf);
! 24972: printf(" %d", n_elem);
! 24973: printf("\n");
! 24974: }
! 24975: }
! 24976: }
! 24977: function_tests++;
! 24978: #endif
! 24979:
! 24980: return(test_ret);
! 24981: }
! 24982:
! 24983:
! 24984: static int
! 24985: test_xmlDumpElementTable(void) {
! 24986: int test_ret = 0;
! 24987:
! 24988: #if defined(LIBXML_OUTPUT_ENABLED)
! 24989: int mem_base;
! 24990: xmlBufferPtr buf; /* the XML buffer output */
! 24991: int n_buf;
! 24992: xmlElementTablePtr table; /* An element table */
! 24993: int n_table;
! 24994:
! 24995: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 24996: for (n_table = 0;n_table < gen_nb_xmlElementTablePtr;n_table++) {
! 24997: mem_base = xmlMemBlocks();
! 24998: buf = gen_xmlBufferPtr(n_buf, 0);
! 24999: table = gen_xmlElementTablePtr(n_table, 1);
! 25000:
! 25001: xmlDumpElementTable(buf, table);
! 25002: call_tests++;
! 25003: des_xmlBufferPtr(n_buf, buf, 0);
! 25004: des_xmlElementTablePtr(n_table, table, 1);
! 25005: xmlResetLastError();
! 25006: if (mem_base != xmlMemBlocks()) {
! 25007: printf("Leak of %d blocks found in xmlDumpElementTable",
! 25008: xmlMemBlocks() - mem_base);
! 25009: test_ret++;
! 25010: printf(" %d", n_buf);
! 25011: printf(" %d", n_table);
! 25012: printf("\n");
! 25013: }
! 25014: }
! 25015: }
! 25016: function_tests++;
! 25017: #endif
! 25018:
! 25019: return(test_ret);
! 25020: }
! 25021:
! 25022:
! 25023: #define gen_nb_xmlNotationPtr 1
! 25024: static xmlNotationPtr gen_xmlNotationPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 25025: return(NULL);
! 25026: }
! 25027: static void des_xmlNotationPtr(int no ATTRIBUTE_UNUSED, xmlNotationPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 25028: }
! 25029:
! 25030: static int
! 25031: test_xmlDumpNotationDecl(void) {
! 25032: int test_ret = 0;
! 25033:
! 25034: #if defined(LIBXML_OUTPUT_ENABLED)
! 25035: int mem_base;
! 25036: xmlBufferPtr buf; /* the XML buffer output */
! 25037: int n_buf;
! 25038: xmlNotationPtr nota; /* A notation declaration */
! 25039: int n_nota;
! 25040:
! 25041: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 25042: for (n_nota = 0;n_nota < gen_nb_xmlNotationPtr;n_nota++) {
! 25043: mem_base = xmlMemBlocks();
! 25044: buf = gen_xmlBufferPtr(n_buf, 0);
! 25045: nota = gen_xmlNotationPtr(n_nota, 1);
! 25046:
! 25047: xmlDumpNotationDecl(buf, nota);
! 25048: call_tests++;
! 25049: des_xmlBufferPtr(n_buf, buf, 0);
! 25050: des_xmlNotationPtr(n_nota, nota, 1);
! 25051: xmlResetLastError();
! 25052: if (mem_base != xmlMemBlocks()) {
! 25053: printf("Leak of %d blocks found in xmlDumpNotationDecl",
! 25054: xmlMemBlocks() - mem_base);
! 25055: test_ret++;
! 25056: printf(" %d", n_buf);
! 25057: printf(" %d", n_nota);
! 25058: printf("\n");
! 25059: }
! 25060: }
! 25061: }
! 25062: function_tests++;
! 25063: #endif
! 25064:
! 25065: return(test_ret);
! 25066: }
! 25067:
! 25068:
! 25069: static int
! 25070: test_xmlDumpNotationTable(void) {
! 25071: int test_ret = 0;
! 25072:
! 25073: #if defined(LIBXML_OUTPUT_ENABLED)
! 25074: int mem_base;
! 25075: xmlBufferPtr buf; /* the XML buffer output */
! 25076: int n_buf;
! 25077: xmlNotationTablePtr table; /* A notation table */
! 25078: int n_table;
! 25079:
! 25080: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 25081: for (n_table = 0;n_table < gen_nb_xmlNotationTablePtr;n_table++) {
! 25082: mem_base = xmlMemBlocks();
! 25083: buf = gen_xmlBufferPtr(n_buf, 0);
! 25084: table = gen_xmlNotationTablePtr(n_table, 1);
! 25085:
! 25086: xmlDumpNotationTable(buf, table);
! 25087: call_tests++;
! 25088: des_xmlBufferPtr(n_buf, buf, 0);
! 25089: des_xmlNotationTablePtr(n_table, table, 1);
! 25090: xmlResetLastError();
! 25091: if (mem_base != xmlMemBlocks()) {
! 25092: printf("Leak of %d blocks found in xmlDumpNotationTable",
! 25093: xmlMemBlocks() - mem_base);
! 25094: test_ret++;
! 25095: printf(" %d", n_buf);
! 25096: printf(" %d", n_table);
! 25097: printf("\n");
! 25098: }
! 25099: }
! 25100: }
! 25101: function_tests++;
! 25102: #endif
! 25103:
! 25104: return(test_ret);
! 25105: }
! 25106:
! 25107:
! 25108: static int
! 25109: test_xmlGetDtdAttrDesc(void) {
! 25110: int test_ret = 0;
! 25111:
! 25112: int mem_base;
! 25113: xmlAttributePtr ret_val;
! 25114: xmlDtdPtr dtd; /* a pointer to the DtD to search */
! 25115: int n_dtd;
! 25116: xmlChar * elem; /* the element name */
! 25117: int n_elem;
! 25118: xmlChar * name; /* the attribute name */
! 25119: int n_name;
! 25120:
! 25121: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
! 25122: for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
! 25123: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 25124: mem_base = xmlMemBlocks();
! 25125: dtd = gen_xmlDtdPtr(n_dtd, 0);
! 25126: elem = gen_const_xmlChar_ptr(n_elem, 1);
! 25127: name = gen_const_xmlChar_ptr(n_name, 2);
! 25128:
! 25129: ret_val = xmlGetDtdAttrDesc(dtd, (const xmlChar *)elem, (const xmlChar *)name);
! 25130: desret_xmlAttributePtr(ret_val);
! 25131: call_tests++;
! 25132: des_xmlDtdPtr(n_dtd, dtd, 0);
! 25133: des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 1);
! 25134: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 25135: xmlResetLastError();
! 25136: if (mem_base != xmlMemBlocks()) {
! 25137: printf("Leak of %d blocks found in xmlGetDtdAttrDesc",
! 25138: xmlMemBlocks() - mem_base);
! 25139: test_ret++;
! 25140: printf(" %d", n_dtd);
! 25141: printf(" %d", n_elem);
! 25142: printf(" %d", n_name);
! 25143: printf("\n");
! 25144: }
! 25145: }
! 25146: }
! 25147: }
! 25148: function_tests++;
! 25149:
! 25150: return(test_ret);
! 25151: }
! 25152:
! 25153:
! 25154: static int
! 25155: test_xmlGetDtdElementDesc(void) {
! 25156: int test_ret = 0;
! 25157:
! 25158: int mem_base;
! 25159: xmlElementPtr ret_val;
! 25160: xmlDtdPtr dtd; /* a pointer to the DtD to search */
! 25161: int n_dtd;
! 25162: xmlChar * name; /* the element name */
! 25163: int n_name;
! 25164:
! 25165: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
! 25166: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 25167: mem_base = xmlMemBlocks();
! 25168: dtd = gen_xmlDtdPtr(n_dtd, 0);
! 25169: name = gen_const_xmlChar_ptr(n_name, 1);
! 25170:
! 25171: ret_val = xmlGetDtdElementDesc(dtd, (const xmlChar *)name);
! 25172: desret_xmlElementPtr(ret_val);
! 25173: call_tests++;
! 25174: des_xmlDtdPtr(n_dtd, dtd, 0);
! 25175: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 25176: xmlResetLastError();
! 25177: if (mem_base != xmlMemBlocks()) {
! 25178: printf("Leak of %d blocks found in xmlGetDtdElementDesc",
! 25179: xmlMemBlocks() - mem_base);
! 25180: test_ret++;
! 25181: printf(" %d", n_dtd);
! 25182: printf(" %d", n_name);
! 25183: printf("\n");
! 25184: }
! 25185: }
! 25186: }
! 25187: function_tests++;
! 25188:
! 25189: return(test_ret);
! 25190: }
! 25191:
! 25192:
! 25193: static int
! 25194: test_xmlGetDtdNotationDesc(void) {
! 25195: int test_ret = 0;
! 25196:
! 25197:
! 25198: /* missing type support */
! 25199: return(test_ret);
! 25200: }
! 25201:
! 25202:
! 25203: static int
! 25204: test_xmlGetDtdQAttrDesc(void) {
! 25205: int test_ret = 0;
! 25206:
! 25207: int mem_base;
! 25208: xmlAttributePtr ret_val;
! 25209: xmlDtdPtr dtd; /* a pointer to the DtD to search */
! 25210: int n_dtd;
! 25211: xmlChar * elem; /* the element name */
! 25212: int n_elem;
! 25213: xmlChar * name; /* the attribute name */
! 25214: int n_name;
! 25215: xmlChar * prefix; /* the attribute namespace prefix */
! 25216: int n_prefix;
! 25217:
! 25218: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
! 25219: for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
! 25220: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 25221: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
! 25222: mem_base = xmlMemBlocks();
! 25223: dtd = gen_xmlDtdPtr(n_dtd, 0);
! 25224: elem = gen_const_xmlChar_ptr(n_elem, 1);
! 25225: name = gen_const_xmlChar_ptr(n_name, 2);
! 25226: prefix = gen_const_xmlChar_ptr(n_prefix, 3);
! 25227:
! 25228: ret_val = xmlGetDtdQAttrDesc(dtd, (const xmlChar *)elem, (const xmlChar *)name, (const xmlChar *)prefix);
! 25229: desret_xmlAttributePtr(ret_val);
! 25230: call_tests++;
! 25231: des_xmlDtdPtr(n_dtd, dtd, 0);
! 25232: des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 1);
! 25233: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 25234: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 3);
! 25235: xmlResetLastError();
! 25236: if (mem_base != xmlMemBlocks()) {
! 25237: printf("Leak of %d blocks found in xmlGetDtdQAttrDesc",
! 25238: xmlMemBlocks() - mem_base);
! 25239: test_ret++;
! 25240: printf(" %d", n_dtd);
! 25241: printf(" %d", n_elem);
! 25242: printf(" %d", n_name);
! 25243: printf(" %d", n_prefix);
! 25244: printf("\n");
! 25245: }
! 25246: }
! 25247: }
! 25248: }
! 25249: }
! 25250: function_tests++;
! 25251:
! 25252: return(test_ret);
! 25253: }
! 25254:
! 25255:
! 25256: static int
! 25257: test_xmlGetDtdQElementDesc(void) {
! 25258: int test_ret = 0;
! 25259:
! 25260: int mem_base;
! 25261: xmlElementPtr ret_val;
! 25262: xmlDtdPtr dtd; /* a pointer to the DtD to search */
! 25263: int n_dtd;
! 25264: xmlChar * name; /* the element name */
! 25265: int n_name;
! 25266: xmlChar * prefix; /* the element namespace prefix */
! 25267: int n_prefix;
! 25268:
! 25269: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
! 25270: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 25271: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
! 25272: mem_base = xmlMemBlocks();
! 25273: dtd = gen_xmlDtdPtr(n_dtd, 0);
! 25274: name = gen_const_xmlChar_ptr(n_name, 1);
! 25275: prefix = gen_const_xmlChar_ptr(n_prefix, 2);
! 25276:
! 25277: ret_val = xmlGetDtdQElementDesc(dtd, (const xmlChar *)name, (const xmlChar *)prefix);
! 25278: desret_xmlElementPtr(ret_val);
! 25279: call_tests++;
! 25280: des_xmlDtdPtr(n_dtd, dtd, 0);
! 25281: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 25282: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2);
! 25283: xmlResetLastError();
! 25284: if (mem_base != xmlMemBlocks()) {
! 25285: printf("Leak of %d blocks found in xmlGetDtdQElementDesc",
! 25286: xmlMemBlocks() - mem_base);
! 25287: test_ret++;
! 25288: printf(" %d", n_dtd);
! 25289: printf(" %d", n_name);
! 25290: printf(" %d", n_prefix);
! 25291: printf("\n");
! 25292: }
! 25293: }
! 25294: }
! 25295: }
! 25296: function_tests++;
! 25297:
! 25298: return(test_ret);
! 25299: }
! 25300:
! 25301:
! 25302: static int
! 25303: test_xmlGetID(void) {
! 25304: int test_ret = 0;
! 25305:
! 25306: int mem_base;
! 25307: xmlAttrPtr ret_val;
! 25308: xmlDocPtr doc; /* pointer to the document */
! 25309: int n_doc;
! 25310: xmlChar * ID; /* the ID value */
! 25311: int n_ID;
! 25312:
! 25313: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 25314: for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
! 25315: mem_base = xmlMemBlocks();
! 25316: doc = gen_xmlDocPtr(n_doc, 0);
! 25317: ID = gen_const_xmlChar_ptr(n_ID, 1);
! 25318:
! 25319: ret_val = xmlGetID(doc, (const xmlChar *)ID);
! 25320: desret_xmlAttrPtr(ret_val);
! 25321: call_tests++;
! 25322: des_xmlDocPtr(n_doc, doc, 0);
! 25323: des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 1);
! 25324: xmlResetLastError();
! 25325: if (mem_base != xmlMemBlocks()) {
! 25326: printf("Leak of %d blocks found in xmlGetID",
! 25327: xmlMemBlocks() - mem_base);
! 25328: test_ret++;
! 25329: printf(" %d", n_doc);
! 25330: printf(" %d", n_ID);
! 25331: printf("\n");
! 25332: }
! 25333: }
! 25334: }
! 25335: function_tests++;
! 25336:
! 25337: return(test_ret);
! 25338: }
! 25339:
! 25340:
! 25341: static int
! 25342: test_xmlGetRefs(void) {
! 25343: int test_ret = 0;
! 25344:
! 25345:
! 25346: /* missing type support */
! 25347: return(test_ret);
! 25348: }
! 25349:
! 25350:
! 25351: static int
! 25352: test_xmlIsID(void) {
! 25353: int test_ret = 0;
! 25354:
! 25355: int mem_base;
! 25356: int ret_val;
! 25357: xmlDocPtr doc; /* the document */
! 25358: int n_doc;
! 25359: xmlNodePtr elem; /* the element carrying the attribute */
! 25360: int n_elem;
! 25361: xmlAttrPtr attr; /* the attribute */
! 25362: int n_attr;
! 25363:
! 25364: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 25365: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
! 25366: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
! 25367: mem_base = xmlMemBlocks();
! 25368: doc = gen_xmlDocPtr(n_doc, 0);
! 25369: elem = gen_xmlNodePtr(n_elem, 1);
! 25370: attr = gen_xmlAttrPtr(n_attr, 2);
! 25371:
! 25372: ret_val = xmlIsID(doc, elem, attr);
! 25373: desret_int(ret_val);
! 25374: call_tests++;
! 25375: des_xmlDocPtr(n_doc, doc, 0);
! 25376: des_xmlNodePtr(n_elem, elem, 1);
! 25377: des_xmlAttrPtr(n_attr, attr, 2);
! 25378: xmlResetLastError();
! 25379: if (mem_base != xmlMemBlocks()) {
! 25380: printf("Leak of %d blocks found in xmlIsID",
! 25381: xmlMemBlocks() - mem_base);
! 25382: test_ret++;
! 25383: printf(" %d", n_doc);
! 25384: printf(" %d", n_elem);
! 25385: printf(" %d", n_attr);
! 25386: printf("\n");
! 25387: }
! 25388: }
! 25389: }
! 25390: }
! 25391: function_tests++;
! 25392:
! 25393: return(test_ret);
! 25394: }
! 25395:
! 25396:
! 25397: static int
! 25398: test_xmlIsMixedElement(void) {
! 25399: int test_ret = 0;
! 25400:
! 25401: int mem_base;
! 25402: int ret_val;
! 25403: xmlDocPtr doc; /* the document */
! 25404: int n_doc;
! 25405: xmlChar * name; /* the element name */
! 25406: int n_name;
! 25407:
! 25408: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 25409: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 25410: mem_base = xmlMemBlocks();
! 25411: doc = gen_xmlDocPtr(n_doc, 0);
! 25412: name = gen_const_xmlChar_ptr(n_name, 1);
! 25413:
! 25414: ret_val = xmlIsMixedElement(doc, (const xmlChar *)name);
! 25415: desret_int(ret_val);
! 25416: call_tests++;
! 25417: des_xmlDocPtr(n_doc, doc, 0);
! 25418: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 25419: xmlResetLastError();
! 25420: if (mem_base != xmlMemBlocks()) {
! 25421: printf("Leak of %d blocks found in xmlIsMixedElement",
! 25422: xmlMemBlocks() - mem_base);
! 25423: test_ret++;
! 25424: printf(" %d", n_doc);
! 25425: printf(" %d", n_name);
! 25426: printf("\n");
! 25427: }
! 25428: }
! 25429: }
! 25430: function_tests++;
! 25431:
! 25432: return(test_ret);
! 25433: }
! 25434:
! 25435:
! 25436: static int
! 25437: test_xmlIsRef(void) {
! 25438: int test_ret = 0;
! 25439:
! 25440: int mem_base;
! 25441: int ret_val;
! 25442: xmlDocPtr doc; /* the document */
! 25443: int n_doc;
! 25444: xmlNodePtr elem; /* the element carrying the attribute */
! 25445: int n_elem;
! 25446: xmlAttrPtr attr; /* the attribute */
! 25447: int n_attr;
! 25448:
! 25449: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 25450: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
! 25451: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
! 25452: mem_base = xmlMemBlocks();
! 25453: doc = gen_xmlDocPtr(n_doc, 0);
! 25454: elem = gen_xmlNodePtr(n_elem, 1);
! 25455: attr = gen_xmlAttrPtr(n_attr, 2);
! 25456:
! 25457: ret_val = xmlIsRef(doc, elem, attr);
! 25458: desret_int(ret_val);
! 25459: call_tests++;
! 25460: des_xmlDocPtr(n_doc, doc, 0);
! 25461: des_xmlNodePtr(n_elem, elem, 1);
! 25462: des_xmlAttrPtr(n_attr, attr, 2);
! 25463: xmlResetLastError();
! 25464: if (mem_base != xmlMemBlocks()) {
! 25465: printf("Leak of %d blocks found in xmlIsRef",
! 25466: xmlMemBlocks() - mem_base);
! 25467: test_ret++;
! 25468: printf(" %d", n_doc);
! 25469: printf(" %d", n_elem);
! 25470: printf(" %d", n_attr);
! 25471: printf("\n");
! 25472: }
! 25473: }
! 25474: }
! 25475: }
! 25476: function_tests++;
! 25477:
! 25478: return(test_ret);
! 25479: }
! 25480:
! 25481:
! 25482: static int
! 25483: test_xmlNewDocElementContent(void) {
! 25484: int test_ret = 0;
! 25485:
! 25486: int mem_base;
! 25487: xmlElementContentPtr ret_val;
! 25488: xmlDocPtr doc; /* the document */
! 25489: int n_doc;
! 25490: xmlChar * name; /* the subelement name or NULL */
! 25491: int n_name;
! 25492: xmlElementContentType type; /* the type of element content decl */
! 25493: int n_type;
! 25494:
! 25495: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 25496: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 25497: for (n_type = 0;n_type < gen_nb_xmlElementContentType;n_type++) {
! 25498: mem_base = xmlMemBlocks();
! 25499: doc = gen_xmlDocPtr(n_doc, 0);
! 25500: name = gen_const_xmlChar_ptr(n_name, 1);
! 25501: type = gen_xmlElementContentType(n_type, 2);
! 25502:
! 25503: ret_val = xmlNewDocElementContent(doc, (const xmlChar *)name, type);
! 25504: xmlFreeDocElementContent(doc, ret_val); ret_val = NULL;
! 25505: desret_xmlElementContentPtr(ret_val);
! 25506: call_tests++;
! 25507: des_xmlDocPtr(n_doc, doc, 0);
! 25508: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 25509: des_xmlElementContentType(n_type, type, 2);
! 25510: xmlResetLastError();
! 25511: if (mem_base != xmlMemBlocks()) {
! 25512: printf("Leak of %d blocks found in xmlNewDocElementContent",
! 25513: xmlMemBlocks() - mem_base);
! 25514: test_ret++;
! 25515: printf(" %d", n_doc);
! 25516: printf(" %d", n_name);
! 25517: printf(" %d", n_type);
! 25518: printf("\n");
! 25519: }
! 25520: }
! 25521: }
! 25522: }
! 25523: function_tests++;
! 25524:
! 25525: return(test_ret);
! 25526: }
! 25527:
! 25528:
! 25529: static int
! 25530: test_xmlNewElementContent(void) {
! 25531: int test_ret = 0;
! 25532:
! 25533: int mem_base;
! 25534: xmlElementContentPtr ret_val;
! 25535: xmlChar * name; /* the subelement name or NULL */
! 25536: int n_name;
! 25537: xmlElementContentType type; /* the type of element content decl */
! 25538: int n_type;
! 25539:
! 25540: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 25541: for (n_type = 0;n_type < gen_nb_xmlElementContentType;n_type++) {
! 25542: mem_base = xmlMemBlocks();
! 25543: name = gen_const_xmlChar_ptr(n_name, 0);
! 25544: type = gen_xmlElementContentType(n_type, 1);
! 25545:
! 25546: ret_val = xmlNewElementContent((const xmlChar *)name, type);
! 25547: desret_xmlElementContentPtr(ret_val);
! 25548: call_tests++;
! 25549: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
! 25550: des_xmlElementContentType(n_type, type, 1);
! 25551: xmlResetLastError();
! 25552: if (mem_base != xmlMemBlocks()) {
! 25553: printf("Leak of %d blocks found in xmlNewElementContent",
! 25554: xmlMemBlocks() - mem_base);
! 25555: test_ret++;
! 25556: printf(" %d", n_name);
! 25557: printf(" %d", n_type);
! 25558: printf("\n");
! 25559: }
! 25560: }
! 25561: }
! 25562: function_tests++;
! 25563:
! 25564: return(test_ret);
! 25565: }
! 25566:
! 25567:
! 25568: static int
! 25569: test_xmlNewValidCtxt(void) {
! 25570: int test_ret = 0;
! 25571:
! 25572:
! 25573: /* missing type support */
! 25574: return(test_ret);
! 25575: }
! 25576:
! 25577:
! 25578: static int
! 25579: test_xmlRemoveID(void) {
! 25580: int test_ret = 0;
! 25581:
! 25582: int mem_base;
! 25583: int ret_val;
! 25584: xmlDocPtr doc; /* the document */
! 25585: int n_doc;
! 25586: xmlAttrPtr attr; /* the attribute */
! 25587: int n_attr;
! 25588:
! 25589: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 25590: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
! 25591: mem_base = xmlMemBlocks();
! 25592: doc = gen_xmlDocPtr(n_doc, 0);
! 25593: attr = gen_xmlAttrPtr(n_attr, 1);
! 25594:
! 25595: ret_val = xmlRemoveID(doc, attr);
! 25596: desret_int(ret_val);
! 25597: call_tests++;
! 25598: des_xmlDocPtr(n_doc, doc, 0);
! 25599: des_xmlAttrPtr(n_attr, attr, 1);
! 25600: xmlResetLastError();
! 25601: if (mem_base != xmlMemBlocks()) {
! 25602: printf("Leak of %d blocks found in xmlRemoveID",
! 25603: xmlMemBlocks() - mem_base);
! 25604: test_ret++;
! 25605: printf(" %d", n_doc);
! 25606: printf(" %d", n_attr);
! 25607: printf("\n");
! 25608: }
! 25609: }
! 25610: }
! 25611: function_tests++;
! 25612:
! 25613: return(test_ret);
! 25614: }
! 25615:
! 25616:
! 25617: static int
! 25618: test_xmlRemoveRef(void) {
! 25619: int test_ret = 0;
! 25620:
! 25621: int mem_base;
! 25622: int ret_val;
! 25623: xmlDocPtr doc; /* the document */
! 25624: int n_doc;
! 25625: xmlAttrPtr attr; /* the attribute */
! 25626: int n_attr;
! 25627:
! 25628: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 25629: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
! 25630: mem_base = xmlMemBlocks();
! 25631: doc = gen_xmlDocPtr(n_doc, 0);
! 25632: attr = gen_xmlAttrPtr(n_attr, 1);
! 25633:
! 25634: ret_val = xmlRemoveRef(doc, attr);
! 25635: desret_int(ret_val);
! 25636: call_tests++;
! 25637: des_xmlDocPtr(n_doc, doc, 0);
! 25638: des_xmlAttrPtr(n_attr, attr, 1);
! 25639: xmlResetLastError();
! 25640: if (mem_base != xmlMemBlocks()) {
! 25641: printf("Leak of %d blocks found in xmlRemoveRef",
! 25642: xmlMemBlocks() - mem_base);
! 25643: test_ret++;
! 25644: printf(" %d", n_doc);
! 25645: printf(" %d", n_attr);
! 25646: printf("\n");
! 25647: }
! 25648: }
! 25649: }
! 25650: function_tests++;
! 25651:
! 25652: return(test_ret);
! 25653: }
! 25654:
! 25655:
! 25656: static int
! 25657: test_xmlSnprintfElementContent(void) {
! 25658: int test_ret = 0;
! 25659:
! 25660: int mem_base;
! 25661: char * buf; /* an output buffer */
! 25662: int n_buf;
! 25663: int size; /* the buffer size */
! 25664: int n_size;
! 25665: xmlElementContentPtr content; /* An element table */
! 25666: int n_content;
! 25667: int englob; /* 1 if one must print the englobing parenthesis, 0 otherwise */
! 25668: int n_englob;
! 25669:
! 25670: for (n_buf = 0;n_buf < gen_nb_char_ptr;n_buf++) {
! 25671: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 25672: for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
! 25673: for (n_englob = 0;n_englob < gen_nb_int;n_englob++) {
! 25674: mem_base = xmlMemBlocks();
! 25675: buf = gen_char_ptr(n_buf, 0);
! 25676: size = gen_int(n_size, 1);
! 25677: content = gen_xmlElementContentPtr(n_content, 2);
! 25678: englob = gen_int(n_englob, 3);
! 25679:
! 25680: xmlSnprintfElementContent(buf, size, content, englob);
! 25681: call_tests++;
! 25682: des_char_ptr(n_buf, buf, 0);
! 25683: des_int(n_size, size, 1);
! 25684: des_xmlElementContentPtr(n_content, content, 2);
! 25685: des_int(n_englob, englob, 3);
! 25686: xmlResetLastError();
! 25687: if (mem_base != xmlMemBlocks()) {
! 25688: printf("Leak of %d blocks found in xmlSnprintfElementContent",
! 25689: xmlMemBlocks() - mem_base);
! 25690: test_ret++;
! 25691: printf(" %d", n_buf);
! 25692: printf(" %d", n_size);
! 25693: printf(" %d", n_content);
! 25694: printf(" %d", n_englob);
! 25695: printf("\n");
! 25696: }
! 25697: }
! 25698: }
! 25699: }
! 25700: }
! 25701: function_tests++;
! 25702:
! 25703: return(test_ret);
! 25704: }
! 25705:
! 25706:
! 25707: static int
! 25708: test_xmlSprintfElementContent(void) {
! 25709: int test_ret = 0;
! 25710:
! 25711: #if defined(LIBXML_OUTPUT_ENABLED)
! 25712: #ifdef LIBXML_OUTPUT_ENABLED
! 25713: int mem_base;
! 25714: char * buf; /* an output buffer */
! 25715: int n_buf;
! 25716: xmlElementContentPtr content; /* An element table */
! 25717: int n_content;
! 25718: int englob; /* 1 if one must print the englobing parenthesis, 0 otherwise */
! 25719: int n_englob;
! 25720:
! 25721: for (n_buf = 0;n_buf < gen_nb_char_ptr;n_buf++) {
! 25722: for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
! 25723: for (n_englob = 0;n_englob < gen_nb_int;n_englob++) {
! 25724: mem_base = xmlMemBlocks();
! 25725: buf = gen_char_ptr(n_buf, 0);
! 25726: content = gen_xmlElementContentPtr(n_content, 1);
! 25727: englob = gen_int(n_englob, 2);
! 25728:
! 25729: xmlSprintfElementContent(buf, content, englob);
! 25730: call_tests++;
! 25731: des_char_ptr(n_buf, buf, 0);
! 25732: des_xmlElementContentPtr(n_content, content, 1);
! 25733: des_int(n_englob, englob, 2);
! 25734: xmlResetLastError();
! 25735: if (mem_base != xmlMemBlocks()) {
! 25736: printf("Leak of %d blocks found in xmlSprintfElementContent",
! 25737: xmlMemBlocks() - mem_base);
! 25738: test_ret++;
! 25739: printf(" %d", n_buf);
! 25740: printf(" %d", n_content);
! 25741: printf(" %d", n_englob);
! 25742: printf("\n");
! 25743: }
! 25744: }
! 25745: }
! 25746: }
! 25747: function_tests++;
! 25748: #endif
! 25749: #endif
! 25750:
! 25751: return(test_ret);
! 25752: }
! 25753:
! 25754:
! 25755: static int
! 25756: test_xmlValidBuildContentModel(void) {
! 25757: int test_ret = 0;
! 25758:
! 25759: #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
! 25760: int mem_base;
! 25761: int ret_val;
! 25762: xmlValidCtxtPtr ctxt; /* a validation context */
! 25763: int n_ctxt;
! 25764: xmlElementPtr elem; /* an element declaration node */
! 25765: int n_elem;
! 25766:
! 25767: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
! 25768: for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) {
! 25769: mem_base = xmlMemBlocks();
! 25770: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
! 25771: elem = gen_xmlElementPtr(n_elem, 1);
! 25772:
! 25773: ret_val = xmlValidBuildContentModel(ctxt, elem);
! 25774: desret_int(ret_val);
! 25775: call_tests++;
! 25776: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
! 25777: des_xmlElementPtr(n_elem, elem, 1);
! 25778: xmlResetLastError();
! 25779: if (mem_base != xmlMemBlocks()) {
! 25780: printf("Leak of %d blocks found in xmlValidBuildContentModel",
! 25781: xmlMemBlocks() - mem_base);
! 25782: test_ret++;
! 25783: printf(" %d", n_ctxt);
! 25784: printf(" %d", n_elem);
! 25785: printf("\n");
! 25786: }
! 25787: }
! 25788: }
! 25789: function_tests++;
! 25790: #endif
! 25791:
! 25792: return(test_ret);
! 25793: }
! 25794:
! 25795:
! 25796: static int
! 25797: test_xmlValidCtxtNormalizeAttributeValue(void) {
! 25798: int test_ret = 0;
! 25799:
! 25800: #if defined(LIBXML_VALID_ENABLED)
! 25801: int mem_base;
! 25802: xmlChar * ret_val;
! 25803: xmlValidCtxtPtr ctxt; /* the validation context or NULL */
! 25804: int n_ctxt;
! 25805: xmlDocPtr doc; /* the document */
! 25806: int n_doc;
! 25807: xmlNodePtr elem; /* the parent */
! 25808: int n_elem;
! 25809: xmlChar * name; /* the attribute name */
! 25810: int n_name;
! 25811: xmlChar * value; /* the attribute value */
! 25812: int n_value;
! 25813:
! 25814: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
! 25815: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 25816: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
! 25817: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 25818: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 25819: mem_base = xmlMemBlocks();
! 25820: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
! 25821: doc = gen_xmlDocPtr(n_doc, 1);
! 25822: elem = gen_xmlNodePtr(n_elem, 2);
! 25823: name = gen_const_xmlChar_ptr(n_name, 3);
! 25824: value = gen_const_xmlChar_ptr(n_value, 4);
! 25825:
! 25826: ret_val = xmlValidCtxtNormalizeAttributeValue(ctxt, doc, elem, (const xmlChar *)name, (const xmlChar *)value);
! 25827: desret_xmlChar_ptr(ret_val);
! 25828: call_tests++;
! 25829: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
! 25830: des_xmlDocPtr(n_doc, doc, 1);
! 25831: des_xmlNodePtr(n_elem, elem, 2);
! 25832: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 3);
! 25833: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 4);
! 25834: xmlResetLastError();
! 25835: if (mem_base != xmlMemBlocks()) {
! 25836: printf("Leak of %d blocks found in xmlValidCtxtNormalizeAttributeValue",
! 25837: xmlMemBlocks() - mem_base);
! 25838: test_ret++;
! 25839: printf(" %d", n_ctxt);
! 25840: printf(" %d", n_doc);
! 25841: printf(" %d", n_elem);
! 25842: printf(" %d", n_name);
! 25843: printf(" %d", n_value);
! 25844: printf("\n");
! 25845: }
! 25846: }
! 25847: }
! 25848: }
! 25849: }
! 25850: }
! 25851: function_tests++;
! 25852: #endif
! 25853:
! 25854: return(test_ret);
! 25855: }
! 25856:
! 25857:
! 25858: #define gen_nb_xmlElementContent_ptr 1
! 25859: static xmlElementContent * gen_xmlElementContent_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 25860: return(NULL);
! 25861: }
! 25862: static void des_xmlElementContent_ptr(int no ATTRIBUTE_UNUSED, xmlElementContent * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 25863: }
! 25864:
! 25865: static int
! 25866: test_xmlValidGetPotentialChildren(void) {
! 25867: int test_ret = 0;
! 25868:
! 25869: #if defined(LIBXML_VALID_ENABLED)
! 25870: #ifdef LIBXML_VALID_ENABLED
! 25871: int mem_base;
! 25872: int ret_val;
! 25873: xmlElementContent * ctree; /* an element content tree */
! 25874: int n_ctree;
! 25875: xmlChar ** names; /* an array to store the list of child names */
! 25876: int n_names;
! 25877: int * len; /* a pointer to the number of element in the list */
! 25878: int n_len;
! 25879: int max; /* the size of the array */
! 25880: int n_max;
! 25881:
! 25882: for (n_ctree = 0;n_ctree < gen_nb_xmlElementContent_ptr;n_ctree++) {
! 25883: for (n_names = 0;n_names < gen_nb_const_xmlChar_ptr_ptr;n_names++) {
! 25884: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
! 25885: for (n_max = 0;n_max < gen_nb_int;n_max++) {
! 25886: mem_base = xmlMemBlocks();
! 25887: ctree = gen_xmlElementContent_ptr(n_ctree, 0);
! 25888: names = gen_const_xmlChar_ptr_ptr(n_names, 1);
! 25889: len = gen_int_ptr(n_len, 2);
! 25890: max = gen_int(n_max, 3);
! 25891:
! 25892: ret_val = xmlValidGetPotentialChildren(ctree, (const xmlChar **)names, len, max);
! 25893: desret_int(ret_val);
! 25894: call_tests++;
! 25895: des_xmlElementContent_ptr(n_ctree, ctree, 0);
! 25896: des_const_xmlChar_ptr_ptr(n_names, (const xmlChar **)names, 1);
! 25897: des_int_ptr(n_len, len, 2);
! 25898: des_int(n_max, max, 3);
! 25899: xmlResetLastError();
! 25900: if (mem_base != xmlMemBlocks()) {
! 25901: printf("Leak of %d blocks found in xmlValidGetPotentialChildren",
! 25902: xmlMemBlocks() - mem_base);
! 25903: test_ret++;
! 25904: printf(" %d", n_ctree);
! 25905: printf(" %d", n_names);
! 25906: printf(" %d", n_len);
! 25907: printf(" %d", n_max);
! 25908: printf("\n");
! 25909: }
! 25910: }
! 25911: }
! 25912: }
! 25913: }
! 25914: function_tests++;
! 25915: #endif
! 25916: #endif
! 25917:
! 25918: return(test_ret);
! 25919: }
! 25920:
! 25921:
! 25922: static int
! 25923: test_xmlValidGetValidElements(void) {
! 25924: int test_ret = 0;
! 25925:
! 25926: #if defined(LIBXML_VALID_ENABLED)
! 25927: #ifdef LIBXML_VALID_ENABLED
! 25928: int mem_base;
! 25929: int ret_val;
! 25930: xmlNode * prev; /* an element to insert after */
! 25931: int n_prev;
! 25932: xmlNode * next; /* an element to insert next */
! 25933: int n_next;
! 25934: xmlChar ** names; /* an array to store the list of child names */
! 25935: int n_names;
! 25936: int max; /* the size of the array */
! 25937: int n_max;
! 25938:
! 25939: for (n_prev = 0;n_prev < gen_nb_xmlNodePtr;n_prev++) {
! 25940: for (n_next = 0;n_next < gen_nb_xmlNodePtr;n_next++) {
! 25941: for (n_names = 0;n_names < gen_nb_const_xmlChar_ptr_ptr;n_names++) {
! 25942: for (n_max = 0;n_max < gen_nb_int;n_max++) {
! 25943: mem_base = xmlMemBlocks();
! 25944: prev = gen_xmlNodePtr(n_prev, 0);
! 25945: next = gen_xmlNodePtr(n_next, 1);
! 25946: names = gen_const_xmlChar_ptr_ptr(n_names, 2);
! 25947: max = gen_int(n_max, 3);
! 25948:
! 25949: ret_val = xmlValidGetValidElements(prev, next, (const xmlChar **)names, max);
! 25950: desret_int(ret_val);
! 25951: call_tests++;
! 25952: des_xmlNodePtr(n_prev, prev, 0);
! 25953: des_xmlNodePtr(n_next, next, 1);
! 25954: des_const_xmlChar_ptr_ptr(n_names, (const xmlChar **)names, 2);
! 25955: des_int(n_max, max, 3);
! 25956: xmlResetLastError();
! 25957: if (mem_base != xmlMemBlocks()) {
! 25958: printf("Leak of %d blocks found in xmlValidGetValidElements",
! 25959: xmlMemBlocks() - mem_base);
! 25960: test_ret++;
! 25961: printf(" %d", n_prev);
! 25962: printf(" %d", n_next);
! 25963: printf(" %d", n_names);
! 25964: printf(" %d", n_max);
! 25965: printf("\n");
! 25966: }
! 25967: }
! 25968: }
! 25969: }
! 25970: }
! 25971: function_tests++;
! 25972: #endif
! 25973: #endif
! 25974:
! 25975: return(test_ret);
! 25976: }
! 25977:
! 25978:
! 25979: static int
! 25980: test_xmlValidNormalizeAttributeValue(void) {
! 25981: int test_ret = 0;
! 25982:
! 25983: #if defined(LIBXML_VALID_ENABLED)
! 25984: int mem_base;
! 25985: xmlChar * ret_val;
! 25986: xmlDocPtr doc; /* the document */
! 25987: int n_doc;
! 25988: xmlNodePtr elem; /* the parent */
! 25989: int n_elem;
! 25990: xmlChar * name; /* the attribute name */
! 25991: int n_name;
! 25992: xmlChar * value; /* the attribute value */
! 25993: int n_value;
! 25994:
! 25995: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 25996: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
! 25997: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 25998: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 25999: mem_base = xmlMemBlocks();
! 26000: doc = gen_xmlDocPtr(n_doc, 0);
! 26001: elem = gen_xmlNodePtr(n_elem, 1);
! 26002: name = gen_const_xmlChar_ptr(n_name, 2);
! 26003: value = gen_const_xmlChar_ptr(n_value, 3);
! 26004:
! 26005: ret_val = xmlValidNormalizeAttributeValue(doc, elem, (const xmlChar *)name, (const xmlChar *)value);
! 26006: desret_xmlChar_ptr(ret_val);
! 26007: call_tests++;
! 26008: des_xmlDocPtr(n_doc, doc, 0);
! 26009: des_xmlNodePtr(n_elem, elem, 1);
! 26010: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 26011: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
! 26012: xmlResetLastError();
! 26013: if (mem_base != xmlMemBlocks()) {
! 26014: printf("Leak of %d blocks found in xmlValidNormalizeAttributeValue",
! 26015: xmlMemBlocks() - mem_base);
! 26016: test_ret++;
! 26017: printf(" %d", n_doc);
! 26018: printf(" %d", n_elem);
! 26019: printf(" %d", n_name);
! 26020: printf(" %d", n_value);
! 26021: printf("\n");
! 26022: }
! 26023: }
! 26024: }
! 26025: }
! 26026: }
! 26027: function_tests++;
! 26028: #endif
! 26029:
! 26030: return(test_ret);
! 26031: }
! 26032:
! 26033:
! 26034: static int
! 26035: test_xmlValidateAttributeDecl(void) {
! 26036: int test_ret = 0;
! 26037:
! 26038: #if defined(LIBXML_VALID_ENABLED)
! 26039: int mem_base;
! 26040: int ret_val;
! 26041: xmlValidCtxtPtr ctxt; /* the validation context */
! 26042: int n_ctxt;
! 26043: xmlDocPtr doc; /* a document instance */
! 26044: int n_doc;
! 26045: xmlAttributePtr attr; /* an attribute definition */
! 26046: int n_attr;
! 26047:
! 26048: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
! 26049: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 26050: for (n_attr = 0;n_attr < gen_nb_xmlAttributePtr;n_attr++) {
! 26051: mem_base = xmlMemBlocks();
! 26052: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
! 26053: doc = gen_xmlDocPtr(n_doc, 1);
! 26054: attr = gen_xmlAttributePtr(n_attr, 2);
! 26055:
! 26056: ret_val = xmlValidateAttributeDecl(ctxt, doc, attr);
! 26057: desret_int(ret_val);
! 26058: call_tests++;
! 26059: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
! 26060: des_xmlDocPtr(n_doc, doc, 1);
! 26061: des_xmlAttributePtr(n_attr, attr, 2);
! 26062: xmlResetLastError();
! 26063: if (mem_base != xmlMemBlocks()) {
! 26064: printf("Leak of %d blocks found in xmlValidateAttributeDecl",
! 26065: xmlMemBlocks() - mem_base);
! 26066: test_ret++;
! 26067: printf(" %d", n_ctxt);
! 26068: printf(" %d", n_doc);
! 26069: printf(" %d", n_attr);
! 26070: printf("\n");
! 26071: }
! 26072: }
! 26073: }
! 26074: }
! 26075: function_tests++;
! 26076: #endif
! 26077:
! 26078: return(test_ret);
! 26079: }
! 26080:
! 26081:
! 26082: static int
! 26083: test_xmlValidateAttributeValue(void) {
! 26084: int test_ret = 0;
! 26085:
! 26086: #if defined(LIBXML_VALID_ENABLED)
! 26087: int mem_base;
! 26088: int ret_val;
! 26089: xmlAttributeType type; /* an attribute type */
! 26090: int n_type;
! 26091: xmlChar * value; /* an attribute value */
! 26092: int n_value;
! 26093:
! 26094: for (n_type = 0;n_type < gen_nb_xmlAttributeType;n_type++) {
! 26095: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 26096: mem_base = xmlMemBlocks();
! 26097: type = gen_xmlAttributeType(n_type, 0);
! 26098: value = gen_const_xmlChar_ptr(n_value, 1);
! 26099:
! 26100: ret_val = xmlValidateAttributeValue(type, (const xmlChar *)value);
! 26101: desret_int(ret_val);
! 26102: call_tests++;
! 26103: des_xmlAttributeType(n_type, type, 0);
! 26104: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
! 26105: xmlResetLastError();
! 26106: if (mem_base != xmlMemBlocks()) {
! 26107: printf("Leak of %d blocks found in xmlValidateAttributeValue",
! 26108: xmlMemBlocks() - mem_base);
! 26109: test_ret++;
! 26110: printf(" %d", n_type);
! 26111: printf(" %d", n_value);
! 26112: printf("\n");
! 26113: }
! 26114: }
! 26115: }
! 26116: function_tests++;
! 26117: #endif
! 26118:
! 26119: return(test_ret);
! 26120: }
! 26121:
! 26122:
! 26123: static int
! 26124: test_xmlValidateDocument(void) {
! 26125: int test_ret = 0;
! 26126:
! 26127: #if defined(LIBXML_VALID_ENABLED)
! 26128: int mem_base;
! 26129: int ret_val;
! 26130: xmlValidCtxtPtr ctxt; /* the validation context */
! 26131: int n_ctxt;
! 26132: xmlDocPtr doc; /* a document instance */
! 26133: int n_doc;
! 26134:
! 26135: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
! 26136: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 26137: mem_base = xmlMemBlocks();
! 26138: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
! 26139: doc = gen_xmlDocPtr(n_doc, 1);
! 26140:
! 26141: ret_val = xmlValidateDocument(ctxt, doc);
! 26142: desret_int(ret_val);
! 26143: call_tests++;
! 26144: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
! 26145: des_xmlDocPtr(n_doc, doc, 1);
! 26146: xmlResetLastError();
! 26147: if (mem_base != xmlMemBlocks()) {
! 26148: printf("Leak of %d blocks found in xmlValidateDocument",
! 26149: xmlMemBlocks() - mem_base);
! 26150: test_ret++;
! 26151: printf(" %d", n_ctxt);
! 26152: printf(" %d", n_doc);
! 26153: printf("\n");
! 26154: }
! 26155: }
! 26156: }
! 26157: function_tests++;
! 26158: #endif
! 26159:
! 26160: return(test_ret);
! 26161: }
! 26162:
! 26163:
! 26164: static int
! 26165: test_xmlValidateDocumentFinal(void) {
! 26166: int test_ret = 0;
! 26167:
! 26168: #if defined(LIBXML_VALID_ENABLED)
! 26169: int mem_base;
! 26170: int ret_val;
! 26171: xmlValidCtxtPtr ctxt; /* the validation context */
! 26172: int n_ctxt;
! 26173: xmlDocPtr doc; /* a document instance */
! 26174: int n_doc;
! 26175:
! 26176: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
! 26177: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 26178: mem_base = xmlMemBlocks();
! 26179: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
! 26180: doc = gen_xmlDocPtr(n_doc, 1);
! 26181:
! 26182: ret_val = xmlValidateDocumentFinal(ctxt, doc);
! 26183: desret_int(ret_val);
! 26184: call_tests++;
! 26185: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
! 26186: des_xmlDocPtr(n_doc, doc, 1);
! 26187: xmlResetLastError();
! 26188: if (mem_base != xmlMemBlocks()) {
! 26189: printf("Leak of %d blocks found in xmlValidateDocumentFinal",
! 26190: xmlMemBlocks() - mem_base);
! 26191: test_ret++;
! 26192: printf(" %d", n_ctxt);
! 26193: printf(" %d", n_doc);
! 26194: printf("\n");
! 26195: }
! 26196: }
! 26197: }
! 26198: function_tests++;
! 26199: #endif
! 26200:
! 26201: return(test_ret);
! 26202: }
! 26203:
! 26204:
! 26205: static int
! 26206: test_xmlValidateDtd(void) {
! 26207: int test_ret = 0;
! 26208:
! 26209: #if defined(LIBXML_VALID_ENABLED)
! 26210: int mem_base;
! 26211: int ret_val;
! 26212: xmlValidCtxtPtr ctxt; /* the validation context */
! 26213: int n_ctxt;
! 26214: xmlDocPtr doc; /* a document instance */
! 26215: int n_doc;
! 26216: xmlDtdPtr dtd; /* a dtd instance */
! 26217: int n_dtd;
! 26218:
! 26219: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
! 26220: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 26221: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
! 26222: mem_base = xmlMemBlocks();
! 26223: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
! 26224: doc = gen_xmlDocPtr(n_doc, 1);
! 26225: dtd = gen_xmlDtdPtr(n_dtd, 2);
! 26226:
! 26227: ret_val = xmlValidateDtd(ctxt, doc, dtd);
! 26228: desret_int(ret_val);
! 26229: call_tests++;
! 26230: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
! 26231: des_xmlDocPtr(n_doc, doc, 1);
! 26232: des_xmlDtdPtr(n_dtd, dtd, 2);
! 26233: xmlResetLastError();
! 26234: if (mem_base != xmlMemBlocks()) {
! 26235: printf("Leak of %d blocks found in xmlValidateDtd",
! 26236: xmlMemBlocks() - mem_base);
! 26237: test_ret++;
! 26238: printf(" %d", n_ctxt);
! 26239: printf(" %d", n_doc);
! 26240: printf(" %d", n_dtd);
! 26241: printf("\n");
! 26242: }
! 26243: }
! 26244: }
! 26245: }
! 26246: function_tests++;
! 26247: #endif
! 26248:
! 26249: return(test_ret);
! 26250: }
! 26251:
! 26252:
! 26253: static int
! 26254: test_xmlValidateDtdFinal(void) {
! 26255: int test_ret = 0;
! 26256:
! 26257: #if defined(LIBXML_VALID_ENABLED)
! 26258: int mem_base;
! 26259: int ret_val;
! 26260: xmlValidCtxtPtr ctxt; /* the validation context */
! 26261: int n_ctxt;
! 26262: xmlDocPtr doc; /* a document instance */
! 26263: int n_doc;
! 26264:
! 26265: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
! 26266: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 26267: mem_base = xmlMemBlocks();
! 26268: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
! 26269: doc = gen_xmlDocPtr(n_doc, 1);
! 26270:
! 26271: ret_val = xmlValidateDtdFinal(ctxt, doc);
! 26272: desret_int(ret_val);
! 26273: call_tests++;
! 26274: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
! 26275: des_xmlDocPtr(n_doc, doc, 1);
! 26276: xmlResetLastError();
! 26277: if (mem_base != xmlMemBlocks()) {
! 26278: printf("Leak of %d blocks found in xmlValidateDtdFinal",
! 26279: xmlMemBlocks() - mem_base);
! 26280: test_ret++;
! 26281: printf(" %d", n_ctxt);
! 26282: printf(" %d", n_doc);
! 26283: printf("\n");
! 26284: }
! 26285: }
! 26286: }
! 26287: function_tests++;
! 26288: #endif
! 26289:
! 26290: return(test_ret);
! 26291: }
! 26292:
! 26293:
! 26294: static int
! 26295: test_xmlValidateElement(void) {
! 26296: int test_ret = 0;
! 26297:
! 26298: #if defined(LIBXML_VALID_ENABLED)
! 26299: int mem_base;
! 26300: int ret_val;
! 26301: xmlValidCtxtPtr ctxt; /* the validation context */
! 26302: int n_ctxt;
! 26303: xmlDocPtr doc; /* a document instance */
! 26304: int n_doc;
! 26305: xmlNodePtr elem; /* an element instance */
! 26306: int n_elem;
! 26307:
! 26308: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
! 26309: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 26310: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
! 26311: mem_base = xmlMemBlocks();
! 26312: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
! 26313: doc = gen_xmlDocPtr(n_doc, 1);
! 26314: elem = gen_xmlNodePtr(n_elem, 2);
! 26315:
! 26316: ret_val = xmlValidateElement(ctxt, doc, elem);
! 26317: desret_int(ret_val);
! 26318: call_tests++;
! 26319: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
! 26320: des_xmlDocPtr(n_doc, doc, 1);
! 26321: des_xmlNodePtr(n_elem, elem, 2);
! 26322: xmlResetLastError();
! 26323: if (mem_base != xmlMemBlocks()) {
! 26324: printf("Leak of %d blocks found in xmlValidateElement",
! 26325: xmlMemBlocks() - mem_base);
! 26326: test_ret++;
! 26327: printf(" %d", n_ctxt);
! 26328: printf(" %d", n_doc);
! 26329: printf(" %d", n_elem);
! 26330: printf("\n");
! 26331: }
! 26332: }
! 26333: }
! 26334: }
! 26335: function_tests++;
! 26336: #endif
! 26337:
! 26338: return(test_ret);
! 26339: }
! 26340:
! 26341:
! 26342: static int
! 26343: test_xmlValidateElementDecl(void) {
! 26344: int test_ret = 0;
! 26345:
! 26346: #if defined(LIBXML_VALID_ENABLED)
! 26347: int mem_base;
! 26348: int ret_val;
! 26349: xmlValidCtxtPtr ctxt; /* the validation context */
! 26350: int n_ctxt;
! 26351: xmlDocPtr doc; /* a document instance */
! 26352: int n_doc;
! 26353: xmlElementPtr elem; /* an element definition */
! 26354: int n_elem;
! 26355:
! 26356: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
! 26357: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 26358: for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) {
! 26359: mem_base = xmlMemBlocks();
! 26360: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
! 26361: doc = gen_xmlDocPtr(n_doc, 1);
! 26362: elem = gen_xmlElementPtr(n_elem, 2);
! 26363:
! 26364: ret_val = xmlValidateElementDecl(ctxt, doc, elem);
! 26365: desret_int(ret_val);
! 26366: call_tests++;
! 26367: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
! 26368: des_xmlDocPtr(n_doc, doc, 1);
! 26369: des_xmlElementPtr(n_elem, elem, 2);
! 26370: xmlResetLastError();
! 26371: if (mem_base != xmlMemBlocks()) {
! 26372: printf("Leak of %d blocks found in xmlValidateElementDecl",
! 26373: xmlMemBlocks() - mem_base);
! 26374: test_ret++;
! 26375: printf(" %d", n_ctxt);
! 26376: printf(" %d", n_doc);
! 26377: printf(" %d", n_elem);
! 26378: printf("\n");
! 26379: }
! 26380: }
! 26381: }
! 26382: }
! 26383: function_tests++;
! 26384: #endif
! 26385:
! 26386: return(test_ret);
! 26387: }
! 26388:
! 26389:
! 26390: static int
! 26391: test_xmlValidateNameValue(void) {
! 26392: int test_ret = 0;
! 26393:
! 26394: #if defined(LIBXML_VALID_ENABLED)
! 26395: int mem_base;
! 26396: int ret_val;
! 26397: xmlChar * value; /* an Name value */
! 26398: int n_value;
! 26399:
! 26400: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 26401: mem_base = xmlMemBlocks();
! 26402: value = gen_const_xmlChar_ptr(n_value, 0);
! 26403:
! 26404: ret_val = xmlValidateNameValue((const xmlChar *)value);
! 26405: desret_int(ret_val);
! 26406: call_tests++;
! 26407: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
! 26408: xmlResetLastError();
! 26409: if (mem_base != xmlMemBlocks()) {
! 26410: printf("Leak of %d blocks found in xmlValidateNameValue",
! 26411: xmlMemBlocks() - mem_base);
! 26412: test_ret++;
! 26413: printf(" %d", n_value);
! 26414: printf("\n");
! 26415: }
! 26416: }
! 26417: function_tests++;
! 26418: #endif
! 26419:
! 26420: return(test_ret);
! 26421: }
! 26422:
! 26423:
! 26424: static int
! 26425: test_xmlValidateNamesValue(void) {
! 26426: int test_ret = 0;
! 26427:
! 26428: #if defined(LIBXML_VALID_ENABLED)
! 26429: int mem_base;
! 26430: int ret_val;
! 26431: xmlChar * value; /* an Names value */
! 26432: int n_value;
! 26433:
! 26434: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 26435: mem_base = xmlMemBlocks();
! 26436: value = gen_const_xmlChar_ptr(n_value, 0);
! 26437:
! 26438: ret_val = xmlValidateNamesValue((const xmlChar *)value);
! 26439: desret_int(ret_val);
! 26440: call_tests++;
! 26441: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
! 26442: xmlResetLastError();
! 26443: if (mem_base != xmlMemBlocks()) {
! 26444: printf("Leak of %d blocks found in xmlValidateNamesValue",
! 26445: xmlMemBlocks() - mem_base);
! 26446: test_ret++;
! 26447: printf(" %d", n_value);
! 26448: printf("\n");
! 26449: }
! 26450: }
! 26451: function_tests++;
! 26452: #endif
! 26453:
! 26454: return(test_ret);
! 26455: }
! 26456:
! 26457:
! 26458: static int
! 26459: test_xmlValidateNmtokenValue(void) {
! 26460: int test_ret = 0;
! 26461:
! 26462: #if defined(LIBXML_VALID_ENABLED)
! 26463: int mem_base;
! 26464: int ret_val;
! 26465: xmlChar * value; /* an Nmtoken value */
! 26466: int n_value;
! 26467:
! 26468: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 26469: mem_base = xmlMemBlocks();
! 26470: value = gen_const_xmlChar_ptr(n_value, 0);
! 26471:
! 26472: ret_val = xmlValidateNmtokenValue((const xmlChar *)value);
! 26473: desret_int(ret_val);
! 26474: call_tests++;
! 26475: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
! 26476: xmlResetLastError();
! 26477: if (mem_base != xmlMemBlocks()) {
! 26478: printf("Leak of %d blocks found in xmlValidateNmtokenValue",
! 26479: xmlMemBlocks() - mem_base);
! 26480: test_ret++;
! 26481: printf(" %d", n_value);
! 26482: printf("\n");
! 26483: }
! 26484: }
! 26485: function_tests++;
! 26486: #endif
! 26487:
! 26488: return(test_ret);
! 26489: }
! 26490:
! 26491:
! 26492: static int
! 26493: test_xmlValidateNmtokensValue(void) {
! 26494: int test_ret = 0;
! 26495:
! 26496: #if defined(LIBXML_VALID_ENABLED)
! 26497: int mem_base;
! 26498: int ret_val;
! 26499: xmlChar * value; /* an Nmtokens value */
! 26500: int n_value;
! 26501:
! 26502: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 26503: mem_base = xmlMemBlocks();
! 26504: value = gen_const_xmlChar_ptr(n_value, 0);
! 26505:
! 26506: ret_val = xmlValidateNmtokensValue((const xmlChar *)value);
! 26507: desret_int(ret_val);
! 26508: call_tests++;
! 26509: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
! 26510: xmlResetLastError();
! 26511: if (mem_base != xmlMemBlocks()) {
! 26512: printf("Leak of %d blocks found in xmlValidateNmtokensValue",
! 26513: xmlMemBlocks() - mem_base);
! 26514: test_ret++;
! 26515: printf(" %d", n_value);
! 26516: printf("\n");
! 26517: }
! 26518: }
! 26519: function_tests++;
! 26520: #endif
! 26521:
! 26522: return(test_ret);
! 26523: }
! 26524:
! 26525:
! 26526: static int
! 26527: test_xmlValidateNotationDecl(void) {
! 26528: int test_ret = 0;
! 26529:
! 26530: #if defined(LIBXML_VALID_ENABLED)
! 26531: int mem_base;
! 26532: int ret_val;
! 26533: xmlValidCtxtPtr ctxt; /* the validation context */
! 26534: int n_ctxt;
! 26535: xmlDocPtr doc; /* a document instance */
! 26536: int n_doc;
! 26537: xmlNotationPtr nota; /* a notation definition */
! 26538: int n_nota;
! 26539:
! 26540: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
! 26541: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 26542: for (n_nota = 0;n_nota < gen_nb_xmlNotationPtr;n_nota++) {
! 26543: mem_base = xmlMemBlocks();
! 26544: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
! 26545: doc = gen_xmlDocPtr(n_doc, 1);
! 26546: nota = gen_xmlNotationPtr(n_nota, 2);
! 26547:
! 26548: ret_val = xmlValidateNotationDecl(ctxt, doc, nota);
! 26549: desret_int(ret_val);
! 26550: call_tests++;
! 26551: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
! 26552: des_xmlDocPtr(n_doc, doc, 1);
! 26553: des_xmlNotationPtr(n_nota, nota, 2);
! 26554: xmlResetLastError();
! 26555: if (mem_base != xmlMemBlocks()) {
! 26556: printf("Leak of %d blocks found in xmlValidateNotationDecl",
! 26557: xmlMemBlocks() - mem_base);
! 26558: test_ret++;
! 26559: printf(" %d", n_ctxt);
! 26560: printf(" %d", n_doc);
! 26561: printf(" %d", n_nota);
! 26562: printf("\n");
! 26563: }
! 26564: }
! 26565: }
! 26566: }
! 26567: function_tests++;
! 26568: #endif
! 26569:
! 26570: return(test_ret);
! 26571: }
! 26572:
! 26573:
! 26574: static int
! 26575: test_xmlValidateNotationUse(void) {
! 26576: int test_ret = 0;
! 26577:
! 26578: #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 26579: int mem_base;
! 26580: int ret_val;
! 26581: xmlValidCtxtPtr ctxt; /* the validation context */
! 26582: int n_ctxt;
! 26583: xmlDocPtr doc; /* the document */
! 26584: int n_doc;
! 26585: xmlChar * notationName; /* the notation name to check */
! 26586: int n_notationName;
! 26587:
! 26588: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
! 26589: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 26590: for (n_notationName = 0;n_notationName < gen_nb_const_xmlChar_ptr;n_notationName++) {
! 26591: mem_base = xmlMemBlocks();
! 26592: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
! 26593: doc = gen_xmlDocPtr(n_doc, 1);
! 26594: notationName = gen_const_xmlChar_ptr(n_notationName, 2);
! 26595:
! 26596: ret_val = xmlValidateNotationUse(ctxt, doc, (const xmlChar *)notationName);
! 26597: desret_int(ret_val);
! 26598: call_tests++;
! 26599: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
! 26600: des_xmlDocPtr(n_doc, doc, 1);
! 26601: des_const_xmlChar_ptr(n_notationName, (const xmlChar *)notationName, 2);
! 26602: xmlResetLastError();
! 26603: if (mem_base != xmlMemBlocks()) {
! 26604: printf("Leak of %d blocks found in xmlValidateNotationUse",
! 26605: xmlMemBlocks() - mem_base);
! 26606: test_ret++;
! 26607: printf(" %d", n_ctxt);
! 26608: printf(" %d", n_doc);
! 26609: printf(" %d", n_notationName);
! 26610: printf("\n");
! 26611: }
! 26612: }
! 26613: }
! 26614: }
! 26615: function_tests++;
! 26616: #endif
! 26617:
! 26618: return(test_ret);
! 26619: }
! 26620:
! 26621:
! 26622: static int
! 26623: test_xmlValidateOneAttribute(void) {
! 26624: int test_ret = 0;
! 26625:
! 26626: #if defined(LIBXML_VALID_ENABLED)
! 26627: int mem_base;
! 26628: int ret_val;
! 26629: xmlValidCtxtPtr ctxt; /* the validation context */
! 26630: int n_ctxt;
! 26631: xmlDocPtr doc; /* a document instance */
! 26632: int n_doc;
! 26633: xmlNodePtr elem; /* an element instance */
! 26634: int n_elem;
! 26635: xmlAttrPtr attr; /* an attribute instance */
! 26636: int n_attr;
! 26637: xmlChar * value; /* the attribute value (without entities processing) */
! 26638: int n_value;
! 26639:
! 26640: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
! 26641: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 26642: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
! 26643: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
! 26644: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 26645: mem_base = xmlMemBlocks();
! 26646: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
! 26647: doc = gen_xmlDocPtr(n_doc, 1);
! 26648: elem = gen_xmlNodePtr(n_elem, 2);
! 26649: attr = gen_xmlAttrPtr(n_attr, 3);
! 26650: value = gen_const_xmlChar_ptr(n_value, 4);
! 26651:
! 26652: ret_val = xmlValidateOneAttribute(ctxt, doc, elem, attr, (const xmlChar *)value);
! 26653: desret_int(ret_val);
! 26654: call_tests++;
! 26655: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
! 26656: des_xmlDocPtr(n_doc, doc, 1);
! 26657: des_xmlNodePtr(n_elem, elem, 2);
! 26658: des_xmlAttrPtr(n_attr, attr, 3);
! 26659: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 4);
! 26660: xmlResetLastError();
! 26661: if (mem_base != xmlMemBlocks()) {
! 26662: printf("Leak of %d blocks found in xmlValidateOneAttribute",
! 26663: xmlMemBlocks() - mem_base);
! 26664: test_ret++;
! 26665: printf(" %d", n_ctxt);
! 26666: printf(" %d", n_doc);
! 26667: printf(" %d", n_elem);
! 26668: printf(" %d", n_attr);
! 26669: printf(" %d", n_value);
! 26670: printf("\n");
! 26671: }
! 26672: }
! 26673: }
! 26674: }
! 26675: }
! 26676: }
! 26677: function_tests++;
! 26678: #endif
! 26679:
! 26680: return(test_ret);
! 26681: }
! 26682:
! 26683:
! 26684: static int
! 26685: test_xmlValidateOneElement(void) {
! 26686: int test_ret = 0;
! 26687:
! 26688: #if defined(LIBXML_VALID_ENABLED)
! 26689: int mem_base;
! 26690: int ret_val;
! 26691: xmlValidCtxtPtr ctxt; /* the validation context */
! 26692: int n_ctxt;
! 26693: xmlDocPtr doc; /* a document instance */
! 26694: int n_doc;
! 26695: xmlNodePtr elem; /* an element instance */
! 26696: int n_elem;
! 26697:
! 26698: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
! 26699: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 26700: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
! 26701: mem_base = xmlMemBlocks();
! 26702: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
! 26703: doc = gen_xmlDocPtr(n_doc, 1);
! 26704: elem = gen_xmlNodePtr(n_elem, 2);
! 26705:
! 26706: ret_val = xmlValidateOneElement(ctxt, doc, elem);
! 26707: desret_int(ret_val);
! 26708: call_tests++;
! 26709: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
! 26710: des_xmlDocPtr(n_doc, doc, 1);
! 26711: des_xmlNodePtr(n_elem, elem, 2);
! 26712: xmlResetLastError();
! 26713: if (mem_base != xmlMemBlocks()) {
! 26714: printf("Leak of %d blocks found in xmlValidateOneElement",
! 26715: xmlMemBlocks() - mem_base);
! 26716: test_ret++;
! 26717: printf(" %d", n_ctxt);
! 26718: printf(" %d", n_doc);
! 26719: printf(" %d", n_elem);
! 26720: printf("\n");
! 26721: }
! 26722: }
! 26723: }
! 26724: }
! 26725: function_tests++;
! 26726: #endif
! 26727:
! 26728: return(test_ret);
! 26729: }
! 26730:
! 26731:
! 26732: static int
! 26733: test_xmlValidateOneNamespace(void) {
! 26734: int test_ret = 0;
! 26735:
! 26736: #if defined(LIBXML_VALID_ENABLED)
! 26737: int mem_base;
! 26738: int ret_val;
! 26739: xmlValidCtxtPtr ctxt; /* the validation context */
! 26740: int n_ctxt;
! 26741: xmlDocPtr doc; /* a document instance */
! 26742: int n_doc;
! 26743: xmlNodePtr elem; /* an element instance */
! 26744: int n_elem;
! 26745: xmlChar * prefix; /* the namespace prefix */
! 26746: int n_prefix;
! 26747: xmlNsPtr ns; /* an namespace declaration instance */
! 26748: int n_ns;
! 26749: xmlChar * value; /* the attribute value (without entities processing) */
! 26750: int n_value;
! 26751:
! 26752: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
! 26753: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 26754: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
! 26755: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
! 26756: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
! 26757: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 26758: mem_base = xmlMemBlocks();
! 26759: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
! 26760: doc = gen_xmlDocPtr(n_doc, 1);
! 26761: elem = gen_xmlNodePtr(n_elem, 2);
! 26762: prefix = gen_const_xmlChar_ptr(n_prefix, 3);
! 26763: ns = gen_xmlNsPtr(n_ns, 4);
! 26764: value = gen_const_xmlChar_ptr(n_value, 5);
! 26765:
! 26766: ret_val = xmlValidateOneNamespace(ctxt, doc, elem, (const xmlChar *)prefix, ns, (const xmlChar *)value);
! 26767: desret_int(ret_val);
! 26768: call_tests++;
! 26769: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
! 26770: des_xmlDocPtr(n_doc, doc, 1);
! 26771: des_xmlNodePtr(n_elem, elem, 2);
! 26772: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 3);
! 26773: des_xmlNsPtr(n_ns, ns, 4);
! 26774: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 5);
! 26775: xmlResetLastError();
! 26776: if (mem_base != xmlMemBlocks()) {
! 26777: printf("Leak of %d blocks found in xmlValidateOneNamespace",
! 26778: xmlMemBlocks() - mem_base);
! 26779: test_ret++;
! 26780: printf(" %d", n_ctxt);
! 26781: printf(" %d", n_doc);
! 26782: printf(" %d", n_elem);
! 26783: printf(" %d", n_prefix);
! 26784: printf(" %d", n_ns);
! 26785: printf(" %d", n_value);
! 26786: printf("\n");
! 26787: }
! 26788: }
! 26789: }
! 26790: }
! 26791: }
! 26792: }
! 26793: }
! 26794: function_tests++;
! 26795: #endif
! 26796:
! 26797: return(test_ret);
! 26798: }
! 26799:
! 26800:
! 26801: static int
! 26802: test_xmlValidatePopElement(void) {
! 26803: int test_ret = 0;
! 26804:
! 26805: #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
! 26806: int mem_base;
! 26807: int ret_val;
! 26808: xmlValidCtxtPtr ctxt; /* the validation context */
! 26809: int n_ctxt;
! 26810: xmlDocPtr doc; /* a document instance */
! 26811: int n_doc;
! 26812: xmlNodePtr elem; /* an element instance */
! 26813: int n_elem;
! 26814: xmlChar * qname; /* the qualified name as appearing in the serialization */
! 26815: int n_qname;
! 26816:
! 26817: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
! 26818: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 26819: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
! 26820: for (n_qname = 0;n_qname < gen_nb_const_xmlChar_ptr;n_qname++) {
! 26821: mem_base = xmlMemBlocks();
! 26822: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
! 26823: doc = gen_xmlDocPtr(n_doc, 1);
! 26824: elem = gen_xmlNodePtr(n_elem, 2);
! 26825: qname = gen_const_xmlChar_ptr(n_qname, 3);
! 26826:
! 26827: ret_val = xmlValidatePopElement(ctxt, doc, elem, (const xmlChar *)qname);
! 26828: desret_int(ret_val);
! 26829: call_tests++;
! 26830: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
! 26831: des_xmlDocPtr(n_doc, doc, 1);
! 26832: des_xmlNodePtr(n_elem, elem, 2);
! 26833: des_const_xmlChar_ptr(n_qname, (const xmlChar *)qname, 3);
! 26834: xmlResetLastError();
! 26835: if (mem_base != xmlMemBlocks()) {
! 26836: printf("Leak of %d blocks found in xmlValidatePopElement",
! 26837: xmlMemBlocks() - mem_base);
! 26838: test_ret++;
! 26839: printf(" %d", n_ctxt);
! 26840: printf(" %d", n_doc);
! 26841: printf(" %d", n_elem);
! 26842: printf(" %d", n_qname);
! 26843: printf("\n");
! 26844: }
! 26845: }
! 26846: }
! 26847: }
! 26848: }
! 26849: function_tests++;
! 26850: #endif
! 26851:
! 26852: return(test_ret);
! 26853: }
! 26854:
! 26855:
! 26856: static int
! 26857: test_xmlValidatePushCData(void) {
! 26858: int test_ret = 0;
! 26859:
! 26860: #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
! 26861: int mem_base;
! 26862: int ret_val;
! 26863: xmlValidCtxtPtr ctxt; /* the validation context */
! 26864: int n_ctxt;
! 26865: xmlChar * data; /* some character data read */
! 26866: int n_data;
! 26867: int len; /* the lenght of the data */
! 26868: int n_len;
! 26869:
! 26870: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
! 26871: for (n_data = 0;n_data < gen_nb_const_xmlChar_ptr;n_data++) {
! 26872: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 26873: mem_base = xmlMemBlocks();
! 26874: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
! 26875: data = gen_const_xmlChar_ptr(n_data, 1);
! 26876: len = gen_int(n_len, 2);
! 26877:
! 26878: ret_val = xmlValidatePushCData(ctxt, (const xmlChar *)data, len);
! 26879: desret_int(ret_val);
! 26880: call_tests++;
! 26881: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
! 26882: des_const_xmlChar_ptr(n_data, (const xmlChar *)data, 1);
! 26883: des_int(n_len, len, 2);
! 26884: xmlResetLastError();
! 26885: if (mem_base != xmlMemBlocks()) {
! 26886: printf("Leak of %d blocks found in xmlValidatePushCData",
! 26887: xmlMemBlocks() - mem_base);
! 26888: test_ret++;
! 26889: printf(" %d", n_ctxt);
! 26890: printf(" %d", n_data);
! 26891: printf(" %d", n_len);
! 26892: printf("\n");
! 26893: }
! 26894: }
! 26895: }
! 26896: }
! 26897: function_tests++;
! 26898: #endif
! 26899:
! 26900: return(test_ret);
! 26901: }
! 26902:
! 26903:
! 26904: static int
! 26905: test_xmlValidatePushElement(void) {
! 26906: int test_ret = 0;
! 26907:
! 26908: #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
! 26909: int mem_base;
! 26910: int ret_val;
! 26911: xmlValidCtxtPtr ctxt; /* the validation context */
! 26912: int n_ctxt;
! 26913: xmlDocPtr doc; /* a document instance */
! 26914: int n_doc;
! 26915: xmlNodePtr elem; /* an element instance */
! 26916: int n_elem;
! 26917: xmlChar * qname; /* the qualified name as appearing in the serialization */
! 26918: int n_qname;
! 26919:
! 26920: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
! 26921: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 26922: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
! 26923: for (n_qname = 0;n_qname < gen_nb_const_xmlChar_ptr;n_qname++) {
! 26924: mem_base = xmlMemBlocks();
! 26925: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
! 26926: doc = gen_xmlDocPtr(n_doc, 1);
! 26927: elem = gen_xmlNodePtr(n_elem, 2);
! 26928: qname = gen_const_xmlChar_ptr(n_qname, 3);
! 26929:
! 26930: ret_val = xmlValidatePushElement(ctxt, doc, elem, (const xmlChar *)qname);
! 26931: desret_int(ret_val);
! 26932: call_tests++;
! 26933: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
! 26934: des_xmlDocPtr(n_doc, doc, 1);
! 26935: des_xmlNodePtr(n_elem, elem, 2);
! 26936: des_const_xmlChar_ptr(n_qname, (const xmlChar *)qname, 3);
! 26937: xmlResetLastError();
! 26938: if (mem_base != xmlMemBlocks()) {
! 26939: printf("Leak of %d blocks found in xmlValidatePushElement",
! 26940: xmlMemBlocks() - mem_base);
! 26941: test_ret++;
! 26942: printf(" %d", n_ctxt);
! 26943: printf(" %d", n_doc);
! 26944: printf(" %d", n_elem);
! 26945: printf(" %d", n_qname);
! 26946: printf("\n");
! 26947: }
! 26948: }
! 26949: }
! 26950: }
! 26951: }
! 26952: function_tests++;
! 26953: #endif
! 26954:
! 26955: return(test_ret);
! 26956: }
! 26957:
! 26958:
! 26959: static int
! 26960: test_xmlValidateRoot(void) {
! 26961: int test_ret = 0;
! 26962:
! 26963: #if defined(LIBXML_VALID_ENABLED)
! 26964: int mem_base;
! 26965: int ret_val;
! 26966: xmlValidCtxtPtr ctxt; /* the validation context */
! 26967: int n_ctxt;
! 26968: xmlDocPtr doc; /* a document instance */
! 26969: int n_doc;
! 26970:
! 26971: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
! 26972: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 26973: mem_base = xmlMemBlocks();
! 26974: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
! 26975: doc = gen_xmlDocPtr(n_doc, 1);
! 26976:
! 26977: ret_val = xmlValidateRoot(ctxt, doc);
! 26978: desret_int(ret_val);
! 26979: call_tests++;
! 26980: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
! 26981: des_xmlDocPtr(n_doc, doc, 1);
! 26982: xmlResetLastError();
! 26983: if (mem_base != xmlMemBlocks()) {
! 26984: printf("Leak of %d blocks found in xmlValidateRoot",
! 26985: xmlMemBlocks() - mem_base);
! 26986: test_ret++;
! 26987: printf(" %d", n_ctxt);
! 26988: printf(" %d", n_doc);
! 26989: printf("\n");
! 26990: }
! 26991: }
! 26992: }
! 26993: function_tests++;
! 26994: #endif
! 26995:
! 26996: return(test_ret);
! 26997: }
! 26998:
! 26999: static int
! 27000: test_valid(void) {
! 27001: int test_ret = 0;
! 27002:
! 27003: if (quiet == 0) printf("Testing valid : 50 of 70 functions ...\n");
! 27004: test_ret += test_xmlAddAttributeDecl();
! 27005: test_ret += test_xmlAddElementDecl();
! 27006: test_ret += test_xmlAddID();
! 27007: test_ret += test_xmlAddNotationDecl();
! 27008: test_ret += test_xmlAddRef();
! 27009: test_ret += test_xmlCopyAttributeTable();
! 27010: test_ret += test_xmlCopyDocElementContent();
! 27011: test_ret += test_xmlCopyElementContent();
! 27012: test_ret += test_xmlCopyElementTable();
! 27013: test_ret += test_xmlCopyEnumeration();
! 27014: test_ret += test_xmlCopyNotationTable();
! 27015: test_ret += test_xmlCreateEnumeration();
! 27016: test_ret += test_xmlDumpAttributeDecl();
! 27017: test_ret += test_xmlDumpAttributeTable();
! 27018: test_ret += test_xmlDumpElementDecl();
! 27019: test_ret += test_xmlDumpElementTable();
! 27020: test_ret += test_xmlDumpNotationDecl();
! 27021: test_ret += test_xmlDumpNotationTable();
! 27022: test_ret += test_xmlGetDtdAttrDesc();
! 27023: test_ret += test_xmlGetDtdElementDesc();
! 27024: test_ret += test_xmlGetDtdNotationDesc();
! 27025: test_ret += test_xmlGetDtdQAttrDesc();
! 27026: test_ret += test_xmlGetDtdQElementDesc();
! 27027: test_ret += test_xmlGetID();
! 27028: test_ret += test_xmlGetRefs();
! 27029: test_ret += test_xmlIsID();
! 27030: test_ret += test_xmlIsMixedElement();
! 27031: test_ret += test_xmlIsRef();
! 27032: test_ret += test_xmlNewDocElementContent();
! 27033: test_ret += test_xmlNewElementContent();
! 27034: test_ret += test_xmlNewValidCtxt();
! 27035: test_ret += test_xmlRemoveID();
! 27036: test_ret += test_xmlRemoveRef();
! 27037: test_ret += test_xmlSnprintfElementContent();
! 27038: test_ret += test_xmlSprintfElementContent();
! 27039: test_ret += test_xmlValidBuildContentModel();
! 27040: test_ret += test_xmlValidCtxtNormalizeAttributeValue();
! 27041: test_ret += test_xmlValidGetPotentialChildren();
! 27042: test_ret += test_xmlValidGetValidElements();
! 27043: test_ret += test_xmlValidNormalizeAttributeValue();
! 27044: test_ret += test_xmlValidateAttributeDecl();
! 27045: test_ret += test_xmlValidateAttributeValue();
! 27046: test_ret += test_xmlValidateDocument();
! 27047: test_ret += test_xmlValidateDocumentFinal();
! 27048: test_ret += test_xmlValidateDtd();
! 27049: test_ret += test_xmlValidateDtdFinal();
! 27050: test_ret += test_xmlValidateElement();
! 27051: test_ret += test_xmlValidateElementDecl();
! 27052: test_ret += test_xmlValidateNameValue();
! 27053: test_ret += test_xmlValidateNamesValue();
! 27054: test_ret += test_xmlValidateNmtokenValue();
! 27055: test_ret += test_xmlValidateNmtokensValue();
! 27056: test_ret += test_xmlValidateNotationDecl();
! 27057: test_ret += test_xmlValidateNotationUse();
! 27058: test_ret += test_xmlValidateOneAttribute();
! 27059: test_ret += test_xmlValidateOneElement();
! 27060: test_ret += test_xmlValidateOneNamespace();
! 27061: test_ret += test_xmlValidatePopElement();
! 27062: test_ret += test_xmlValidatePushCData();
! 27063: test_ret += test_xmlValidatePushElement();
! 27064: test_ret += test_xmlValidateRoot();
! 27065:
! 27066: if (test_ret != 0)
! 27067: printf("Module valid: %d errors\n", test_ret);
! 27068: return(test_ret);
! 27069: }
! 27070:
! 27071: static int
! 27072: test_xmlXIncludeNewContext(void) {
! 27073: int test_ret = 0;
! 27074:
! 27075:
! 27076: /* missing type support */
! 27077: return(test_ret);
! 27078: }
! 27079:
! 27080:
! 27081: static int
! 27082: test_xmlXIncludeProcess(void) {
! 27083: int test_ret = 0;
! 27084:
! 27085: #if defined(LIBXML_XINCLUDE_ENABLED)
! 27086: int mem_base;
! 27087: int ret_val;
! 27088: xmlDocPtr doc; /* an XML document */
! 27089: int n_doc;
! 27090:
! 27091: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 27092: mem_base = xmlMemBlocks();
! 27093: doc = gen_xmlDocPtr(n_doc, 0);
! 27094:
! 27095: ret_val = xmlXIncludeProcess(doc);
! 27096: desret_int(ret_val);
! 27097: call_tests++;
! 27098: des_xmlDocPtr(n_doc, doc, 0);
! 27099: xmlResetLastError();
! 27100: if (mem_base != xmlMemBlocks()) {
! 27101: printf("Leak of %d blocks found in xmlXIncludeProcess",
! 27102: xmlMemBlocks() - mem_base);
! 27103: test_ret++;
! 27104: printf(" %d", n_doc);
! 27105: printf("\n");
! 27106: }
! 27107: }
! 27108: function_tests++;
! 27109: #endif
! 27110:
! 27111: return(test_ret);
! 27112: }
! 27113:
! 27114:
! 27115: static int
! 27116: test_xmlXIncludeProcessFlags(void) {
! 27117: int test_ret = 0;
! 27118:
! 27119: #if defined(LIBXML_XINCLUDE_ENABLED)
! 27120: int mem_base;
! 27121: int ret_val;
! 27122: xmlDocPtr doc; /* an XML document */
! 27123: int n_doc;
! 27124: int flags; /* a set of xmlParserOption used for parsing XML includes */
! 27125: int n_flags;
! 27126:
! 27127: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 27128: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
! 27129: mem_base = xmlMemBlocks();
! 27130: doc = gen_xmlDocPtr(n_doc, 0);
! 27131: flags = gen_int(n_flags, 1);
! 27132:
! 27133: ret_val = xmlXIncludeProcessFlags(doc, flags);
! 27134: desret_int(ret_val);
! 27135: call_tests++;
! 27136: des_xmlDocPtr(n_doc, doc, 0);
! 27137: des_int(n_flags, flags, 1);
! 27138: xmlResetLastError();
! 27139: if (mem_base != xmlMemBlocks()) {
! 27140: printf("Leak of %d blocks found in xmlXIncludeProcessFlags",
! 27141: xmlMemBlocks() - mem_base);
! 27142: test_ret++;
! 27143: printf(" %d", n_doc);
! 27144: printf(" %d", n_flags);
! 27145: printf("\n");
! 27146: }
! 27147: }
! 27148: }
! 27149: function_tests++;
! 27150: #endif
! 27151:
! 27152: return(test_ret);
! 27153: }
! 27154:
! 27155:
! 27156: static int
! 27157: test_xmlXIncludeProcessFlagsData(void) {
! 27158: int test_ret = 0;
! 27159:
! 27160: #if defined(LIBXML_XINCLUDE_ENABLED)
! 27161: int mem_base;
! 27162: int ret_val;
! 27163: xmlDocPtr doc; /* an XML document */
! 27164: int n_doc;
! 27165: int flags; /* a set of xmlParserOption used for parsing XML includes */
! 27166: int n_flags;
! 27167: void * data; /* application data that will be passed to the parser context in the _private field of the parser context(s) */
! 27168: int n_data;
! 27169:
! 27170: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 27171: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
! 27172: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
! 27173: mem_base = xmlMemBlocks();
! 27174: doc = gen_xmlDocPtr(n_doc, 0);
! 27175: flags = gen_int(n_flags, 1);
! 27176: data = gen_userdata(n_data, 2);
! 27177:
! 27178: ret_val = xmlXIncludeProcessFlagsData(doc, flags, data);
! 27179: desret_int(ret_val);
! 27180: call_tests++;
! 27181: des_xmlDocPtr(n_doc, doc, 0);
! 27182: des_int(n_flags, flags, 1);
! 27183: des_userdata(n_data, data, 2);
! 27184: xmlResetLastError();
! 27185: if (mem_base != xmlMemBlocks()) {
! 27186: printf("Leak of %d blocks found in xmlXIncludeProcessFlagsData",
! 27187: xmlMemBlocks() - mem_base);
! 27188: test_ret++;
! 27189: printf(" %d", n_doc);
! 27190: printf(" %d", n_flags);
! 27191: printf(" %d", n_data);
! 27192: printf("\n");
! 27193: }
! 27194: }
! 27195: }
! 27196: }
! 27197: function_tests++;
! 27198: #endif
! 27199:
! 27200: return(test_ret);
! 27201: }
! 27202:
! 27203: #ifdef LIBXML_XINCLUDE_ENABLED
! 27204:
! 27205: #define gen_nb_xmlXIncludeCtxtPtr 1
! 27206: static xmlXIncludeCtxtPtr gen_xmlXIncludeCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 27207: return(NULL);
! 27208: }
! 27209: static void des_xmlXIncludeCtxtPtr(int no ATTRIBUTE_UNUSED, xmlXIncludeCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 27210: }
! 27211: #endif
! 27212:
! 27213:
! 27214: static int
! 27215: test_xmlXIncludeProcessNode(void) {
! 27216: int test_ret = 0;
! 27217:
! 27218: #if defined(LIBXML_XINCLUDE_ENABLED)
! 27219: int mem_base;
! 27220: int ret_val;
! 27221: xmlXIncludeCtxtPtr ctxt; /* an existing XInclude context */
! 27222: int n_ctxt;
! 27223: xmlNodePtr node; /* a node in an XML document */
! 27224: int n_node;
! 27225:
! 27226: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXIncludeCtxtPtr;n_ctxt++) {
! 27227: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 27228: mem_base = xmlMemBlocks();
! 27229: ctxt = gen_xmlXIncludeCtxtPtr(n_ctxt, 0);
! 27230: node = gen_xmlNodePtr(n_node, 1);
! 27231:
! 27232: ret_val = xmlXIncludeProcessNode(ctxt, node);
! 27233: desret_int(ret_val);
! 27234: call_tests++;
! 27235: des_xmlXIncludeCtxtPtr(n_ctxt, ctxt, 0);
! 27236: des_xmlNodePtr(n_node, node, 1);
! 27237: xmlResetLastError();
! 27238: if (mem_base != xmlMemBlocks()) {
! 27239: printf("Leak of %d blocks found in xmlXIncludeProcessNode",
! 27240: xmlMemBlocks() - mem_base);
! 27241: test_ret++;
! 27242: printf(" %d", n_ctxt);
! 27243: printf(" %d", n_node);
! 27244: printf("\n");
! 27245: }
! 27246: }
! 27247: }
! 27248: function_tests++;
! 27249: #endif
! 27250:
! 27251: return(test_ret);
! 27252: }
! 27253:
! 27254:
! 27255: static int
! 27256: test_xmlXIncludeProcessTree(void) {
! 27257: int test_ret = 0;
! 27258:
! 27259: #if defined(LIBXML_XINCLUDE_ENABLED)
! 27260: int mem_base;
! 27261: int ret_val;
! 27262: xmlNodePtr tree; /* a node in an XML document */
! 27263: int n_tree;
! 27264:
! 27265: for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
! 27266: mem_base = xmlMemBlocks();
! 27267: tree = gen_xmlNodePtr(n_tree, 0);
! 27268:
! 27269: ret_val = xmlXIncludeProcessTree(tree);
! 27270: desret_int(ret_val);
! 27271: call_tests++;
! 27272: des_xmlNodePtr(n_tree, tree, 0);
! 27273: xmlResetLastError();
! 27274: if (mem_base != xmlMemBlocks()) {
! 27275: printf("Leak of %d blocks found in xmlXIncludeProcessTree",
! 27276: xmlMemBlocks() - mem_base);
! 27277: test_ret++;
! 27278: printf(" %d", n_tree);
! 27279: printf("\n");
! 27280: }
! 27281: }
! 27282: function_tests++;
! 27283: #endif
! 27284:
! 27285: return(test_ret);
! 27286: }
! 27287:
! 27288:
! 27289: static int
! 27290: test_xmlXIncludeProcessTreeFlags(void) {
! 27291: int test_ret = 0;
! 27292:
! 27293: #if defined(LIBXML_XINCLUDE_ENABLED)
! 27294: int mem_base;
! 27295: int ret_val;
! 27296: xmlNodePtr tree; /* a node in an XML document */
! 27297: int n_tree;
! 27298: int flags; /* a set of xmlParserOption used for parsing XML includes */
! 27299: int n_flags;
! 27300:
! 27301: for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
! 27302: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
! 27303: mem_base = xmlMemBlocks();
! 27304: tree = gen_xmlNodePtr(n_tree, 0);
! 27305: flags = gen_int(n_flags, 1);
! 27306:
! 27307: ret_val = xmlXIncludeProcessTreeFlags(tree, flags);
! 27308: desret_int(ret_val);
! 27309: call_tests++;
! 27310: des_xmlNodePtr(n_tree, tree, 0);
! 27311: des_int(n_flags, flags, 1);
! 27312: xmlResetLastError();
! 27313: if (mem_base != xmlMemBlocks()) {
! 27314: printf("Leak of %d blocks found in xmlXIncludeProcessTreeFlags",
! 27315: xmlMemBlocks() - mem_base);
! 27316: test_ret++;
! 27317: printf(" %d", n_tree);
! 27318: printf(" %d", n_flags);
! 27319: printf("\n");
! 27320: }
! 27321: }
! 27322: }
! 27323: function_tests++;
! 27324: #endif
! 27325:
! 27326: return(test_ret);
! 27327: }
! 27328:
! 27329:
! 27330: static int
! 27331: test_xmlXIncludeProcessTreeFlagsData(void) {
! 27332: int test_ret = 0;
! 27333:
! 27334: #if defined(LIBXML_XINCLUDE_ENABLED)
! 27335: int mem_base;
! 27336: int ret_val;
! 27337: xmlNodePtr tree; /* an XML node */
! 27338: int n_tree;
! 27339: int flags; /* a set of xmlParserOption used for parsing XML includes */
! 27340: int n_flags;
! 27341: void * data; /* application data that will be passed to the parser context in the _private field of the parser context(s) */
! 27342: int n_data;
! 27343:
! 27344: for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
! 27345: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
! 27346: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
! 27347: mem_base = xmlMemBlocks();
! 27348: tree = gen_xmlNodePtr(n_tree, 0);
! 27349: flags = gen_int(n_flags, 1);
! 27350: data = gen_userdata(n_data, 2);
! 27351:
! 27352: ret_val = xmlXIncludeProcessTreeFlagsData(tree, flags, data);
! 27353: desret_int(ret_val);
! 27354: call_tests++;
! 27355: des_xmlNodePtr(n_tree, tree, 0);
! 27356: des_int(n_flags, flags, 1);
! 27357: des_userdata(n_data, data, 2);
! 27358: xmlResetLastError();
! 27359: if (mem_base != xmlMemBlocks()) {
! 27360: printf("Leak of %d blocks found in xmlXIncludeProcessTreeFlagsData",
! 27361: xmlMemBlocks() - mem_base);
! 27362: test_ret++;
! 27363: printf(" %d", n_tree);
! 27364: printf(" %d", n_flags);
! 27365: printf(" %d", n_data);
! 27366: printf("\n");
! 27367: }
! 27368: }
! 27369: }
! 27370: }
! 27371: function_tests++;
! 27372: #endif
! 27373:
! 27374: return(test_ret);
! 27375: }
! 27376:
! 27377:
! 27378: static int
! 27379: test_xmlXIncludeSetFlags(void) {
! 27380: int test_ret = 0;
! 27381:
! 27382: #if defined(LIBXML_XINCLUDE_ENABLED)
! 27383: int mem_base;
! 27384: int ret_val;
! 27385: xmlXIncludeCtxtPtr ctxt; /* an XInclude processing context */
! 27386: int n_ctxt;
! 27387: int flags; /* a set of xmlParserOption used for parsing XML includes */
! 27388: int n_flags;
! 27389:
! 27390: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXIncludeCtxtPtr;n_ctxt++) {
! 27391: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
! 27392: mem_base = xmlMemBlocks();
! 27393: ctxt = gen_xmlXIncludeCtxtPtr(n_ctxt, 0);
! 27394: flags = gen_int(n_flags, 1);
! 27395:
! 27396: ret_val = xmlXIncludeSetFlags(ctxt, flags);
! 27397: desret_int(ret_val);
! 27398: call_tests++;
! 27399: des_xmlXIncludeCtxtPtr(n_ctxt, ctxt, 0);
! 27400: des_int(n_flags, flags, 1);
! 27401: xmlResetLastError();
! 27402: if (mem_base != xmlMemBlocks()) {
! 27403: printf("Leak of %d blocks found in xmlXIncludeSetFlags",
! 27404: xmlMemBlocks() - mem_base);
! 27405: test_ret++;
! 27406: printf(" %d", n_ctxt);
! 27407: printf(" %d", n_flags);
! 27408: printf("\n");
! 27409: }
! 27410: }
! 27411: }
! 27412: function_tests++;
! 27413: #endif
! 27414:
! 27415: return(test_ret);
! 27416: }
! 27417:
! 27418: static int
! 27419: test_xinclude(void) {
! 27420: int test_ret = 0;
! 27421:
! 27422: if (quiet == 0) printf("Testing xinclude : 8 of 10 functions ...\n");
! 27423: test_ret += test_xmlXIncludeNewContext();
! 27424: test_ret += test_xmlXIncludeProcess();
! 27425: test_ret += test_xmlXIncludeProcessFlags();
! 27426: test_ret += test_xmlXIncludeProcessFlagsData();
! 27427: test_ret += test_xmlXIncludeProcessNode();
! 27428: test_ret += test_xmlXIncludeProcessTree();
! 27429: test_ret += test_xmlXIncludeProcessTreeFlags();
! 27430: test_ret += test_xmlXIncludeProcessTreeFlagsData();
! 27431: test_ret += test_xmlXIncludeSetFlags();
! 27432:
! 27433: if (test_ret != 0)
! 27434: printf("Module xinclude: %d errors\n", test_ret);
! 27435: return(test_ret);
! 27436: }
! 27437:
! 27438: static int
! 27439: test_xmlAllocOutputBuffer(void) {
! 27440: int test_ret = 0;
! 27441:
! 27442: #if defined(LIBXML_OUTPUT_ENABLED)
! 27443: int mem_base;
! 27444: xmlOutputBufferPtr ret_val;
! 27445: xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
! 27446: int n_encoder;
! 27447:
! 27448: for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
! 27449: mem_base = xmlMemBlocks();
! 27450: encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 0);
! 27451:
! 27452: ret_val = xmlAllocOutputBuffer(encoder);
! 27453: desret_xmlOutputBufferPtr(ret_val);
! 27454: call_tests++;
! 27455: des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 0);
! 27456: xmlResetLastError();
! 27457: if (mem_base != xmlMemBlocks()) {
! 27458: printf("Leak of %d blocks found in xmlAllocOutputBuffer",
! 27459: xmlMemBlocks() - mem_base);
! 27460: test_ret++;
! 27461: printf(" %d", n_encoder);
! 27462: printf("\n");
! 27463: }
! 27464: }
! 27465: function_tests++;
! 27466: #endif
! 27467:
! 27468: return(test_ret);
! 27469: }
! 27470:
! 27471:
! 27472: static int
! 27473: test_xmlAllocParserInputBuffer(void) {
! 27474: int test_ret = 0;
! 27475:
! 27476: int mem_base;
! 27477: xmlParserInputBufferPtr ret_val;
! 27478: xmlCharEncoding enc; /* the charset encoding if known */
! 27479: int n_enc;
! 27480:
! 27481: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
! 27482: mem_base = xmlMemBlocks();
! 27483: enc = gen_xmlCharEncoding(n_enc, 0);
! 27484:
! 27485: ret_val = xmlAllocParserInputBuffer(enc);
! 27486: desret_xmlParserInputBufferPtr(ret_val);
! 27487: call_tests++;
! 27488: des_xmlCharEncoding(n_enc, enc, 0);
! 27489: xmlResetLastError();
! 27490: if (mem_base != xmlMemBlocks()) {
! 27491: printf("Leak of %d blocks found in xmlAllocParserInputBuffer",
! 27492: xmlMemBlocks() - mem_base);
! 27493: test_ret++;
! 27494: printf(" %d", n_enc);
! 27495: printf("\n");
! 27496: }
! 27497: }
! 27498: function_tests++;
! 27499:
! 27500: return(test_ret);
! 27501: }
! 27502:
! 27503:
! 27504: static int
! 27505: test_xmlCheckFilename(void) {
! 27506: int test_ret = 0;
! 27507:
! 27508: int mem_base;
! 27509: int ret_val;
! 27510: char * path; /* the path to check */
! 27511: int n_path;
! 27512:
! 27513: for (n_path = 0;n_path < gen_nb_const_char_ptr;n_path++) {
! 27514: mem_base = xmlMemBlocks();
! 27515: path = gen_const_char_ptr(n_path, 0);
! 27516:
! 27517: ret_val = xmlCheckFilename((const char *)path);
! 27518: desret_int(ret_val);
! 27519: call_tests++;
! 27520: des_const_char_ptr(n_path, (const char *)path, 0);
! 27521: xmlResetLastError();
! 27522: if (mem_base != xmlMemBlocks()) {
! 27523: printf("Leak of %d blocks found in xmlCheckFilename",
! 27524: xmlMemBlocks() - mem_base);
! 27525: test_ret++;
! 27526: printf(" %d", n_path);
! 27527: printf("\n");
! 27528: }
! 27529: }
! 27530: function_tests++;
! 27531:
! 27532: return(test_ret);
! 27533: }
! 27534:
! 27535:
! 27536: static int
! 27537: test_xmlCheckHTTPInput(void) {
! 27538: int test_ret = 0;
! 27539:
! 27540: int mem_base;
! 27541: xmlParserInputPtr ret_val;
! 27542: xmlParserCtxtPtr ctxt; /* an XML parser context */
! 27543: int n_ctxt;
! 27544: xmlParserInputPtr ret; /* an XML parser input */
! 27545: int n_ret;
! 27546:
! 27547: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 27548: for (n_ret = 0;n_ret < gen_nb_xmlParserInputPtr;n_ret++) {
! 27549: mem_base = xmlMemBlocks();
! 27550: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 27551: ret = gen_xmlParserInputPtr(n_ret, 1);
! 27552:
! 27553: ret_val = xmlCheckHTTPInput(ctxt, ret);
! 27554: desret_xmlParserInputPtr(ret_val);
! 27555: call_tests++;
! 27556: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 27557: des_xmlParserInputPtr(n_ret, ret, 1);
! 27558: xmlResetLastError();
! 27559: if (mem_base != xmlMemBlocks()) {
! 27560: printf("Leak of %d blocks found in xmlCheckHTTPInput",
! 27561: xmlMemBlocks() - mem_base);
! 27562: test_ret++;
! 27563: printf(" %d", n_ctxt);
! 27564: printf(" %d", n_ret);
! 27565: printf("\n");
! 27566: }
! 27567: }
! 27568: }
! 27569: function_tests++;
! 27570:
! 27571: return(test_ret);
! 27572: }
! 27573:
! 27574:
! 27575: static int
! 27576: test_xmlCleanupInputCallbacks(void) {
! 27577: int test_ret = 0;
! 27578:
! 27579: int mem_base;
! 27580:
! 27581: mem_base = xmlMemBlocks();
! 27582:
! 27583: xmlCleanupInputCallbacks();
! 27584: call_tests++;
! 27585: xmlResetLastError();
! 27586: if (mem_base != xmlMemBlocks()) {
! 27587: printf("Leak of %d blocks found in xmlCleanupInputCallbacks",
! 27588: xmlMemBlocks() - mem_base);
! 27589: test_ret++;
! 27590: printf("\n");
! 27591: }
! 27592: function_tests++;
! 27593:
! 27594: return(test_ret);
! 27595: }
! 27596:
! 27597:
! 27598: static int
! 27599: test_xmlCleanupOutputCallbacks(void) {
! 27600: int test_ret = 0;
! 27601:
! 27602: #if defined(LIBXML_OUTPUT_ENABLED)
! 27603: int mem_base;
! 27604:
! 27605: mem_base = xmlMemBlocks();
! 27606:
! 27607: xmlCleanupOutputCallbacks();
! 27608: call_tests++;
! 27609: xmlResetLastError();
! 27610: if (mem_base != xmlMemBlocks()) {
! 27611: printf("Leak of %d blocks found in xmlCleanupOutputCallbacks",
! 27612: xmlMemBlocks() - mem_base);
! 27613: test_ret++;
! 27614: printf("\n");
! 27615: }
! 27616: function_tests++;
! 27617: #endif
! 27618:
! 27619: return(test_ret);
! 27620: }
! 27621:
! 27622:
! 27623: static int
! 27624: test_xmlFileClose(void) {
! 27625: int test_ret = 0;
! 27626:
! 27627: int mem_base;
! 27628: int ret_val;
! 27629: void * context; /* the I/O context */
! 27630: int n_context;
! 27631:
! 27632: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
! 27633: mem_base = xmlMemBlocks();
! 27634: context = gen_void_ptr(n_context, 0);
! 27635:
! 27636: ret_val = xmlFileClose(context);
! 27637: desret_int(ret_val);
! 27638: call_tests++;
! 27639: des_void_ptr(n_context, context, 0);
! 27640: xmlResetLastError();
! 27641: if (mem_base != xmlMemBlocks()) {
! 27642: printf("Leak of %d blocks found in xmlFileClose",
! 27643: xmlMemBlocks() - mem_base);
! 27644: test_ret++;
! 27645: printf(" %d", n_context);
! 27646: printf("\n");
! 27647: }
! 27648: }
! 27649: function_tests++;
! 27650:
! 27651: return(test_ret);
! 27652: }
! 27653:
! 27654:
! 27655: static int
! 27656: test_xmlFileMatch(void) {
! 27657: int test_ret = 0;
! 27658:
! 27659: int mem_base;
! 27660: int ret_val;
! 27661: const char * filename; /* the URI for matching */
! 27662: int n_filename;
! 27663:
! 27664: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 27665: mem_base = xmlMemBlocks();
! 27666: filename = gen_filepath(n_filename, 0);
! 27667:
! 27668: ret_val = xmlFileMatch(filename);
! 27669: desret_int(ret_val);
! 27670: call_tests++;
! 27671: des_filepath(n_filename, filename, 0);
! 27672: xmlResetLastError();
! 27673: if (mem_base != xmlMemBlocks()) {
! 27674: printf("Leak of %d blocks found in xmlFileMatch",
! 27675: xmlMemBlocks() - mem_base);
! 27676: test_ret++;
! 27677: printf(" %d", n_filename);
! 27678: printf("\n");
! 27679: }
! 27680: }
! 27681: function_tests++;
! 27682:
! 27683: return(test_ret);
! 27684: }
! 27685:
! 27686:
! 27687: static int
! 27688: test_xmlFileOpen(void) {
! 27689: int test_ret = 0;
! 27690:
! 27691: int mem_base;
! 27692: void * ret_val;
! 27693: const char * filename; /* the URI for matching */
! 27694: int n_filename;
! 27695:
! 27696: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 27697: mem_base = xmlMemBlocks();
! 27698: filename = gen_filepath(n_filename, 0);
! 27699:
! 27700: ret_val = xmlFileOpen(filename);
! 27701: desret_void_ptr(ret_val);
! 27702: call_tests++;
! 27703: des_filepath(n_filename, filename, 0);
! 27704: xmlResetLastError();
! 27705: if (mem_base != xmlMemBlocks()) {
! 27706: printf("Leak of %d blocks found in xmlFileOpen",
! 27707: xmlMemBlocks() - mem_base);
! 27708: test_ret++;
! 27709: printf(" %d", n_filename);
! 27710: printf("\n");
! 27711: }
! 27712: }
! 27713: function_tests++;
! 27714:
! 27715: return(test_ret);
! 27716: }
! 27717:
! 27718:
! 27719: static int
! 27720: test_xmlFileRead(void) {
! 27721: int test_ret = 0;
! 27722:
! 27723: int mem_base;
! 27724: int ret_val;
! 27725: void * context; /* the I/O context */
! 27726: int n_context;
! 27727: char * buffer; /* where to drop data */
! 27728: int n_buffer;
! 27729: int len; /* number of bytes to write */
! 27730: int n_len;
! 27731:
! 27732: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
! 27733: for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
! 27734: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 27735: mem_base = xmlMemBlocks();
! 27736: context = gen_void_ptr(n_context, 0);
! 27737: buffer = gen_char_ptr(n_buffer, 1);
! 27738: len = gen_int(n_len, 2);
! 27739:
! 27740: ret_val = xmlFileRead(context, buffer, len);
! 27741: desret_int(ret_val);
! 27742: call_tests++;
! 27743: des_void_ptr(n_context, context, 0);
! 27744: des_char_ptr(n_buffer, buffer, 1);
! 27745: des_int(n_len, len, 2);
! 27746: xmlResetLastError();
! 27747: if (mem_base != xmlMemBlocks()) {
! 27748: printf("Leak of %d blocks found in xmlFileRead",
! 27749: xmlMemBlocks() - mem_base);
! 27750: test_ret++;
! 27751: printf(" %d", n_context);
! 27752: printf(" %d", n_buffer);
! 27753: printf(" %d", n_len);
! 27754: printf("\n");
! 27755: }
! 27756: }
! 27757: }
! 27758: }
! 27759: function_tests++;
! 27760:
! 27761: return(test_ret);
! 27762: }
! 27763:
! 27764:
! 27765: static int
! 27766: test_xmlIOFTPClose(void) {
! 27767: int test_ret = 0;
! 27768:
! 27769: #if defined(LIBXML_FTP_ENABLED)
! 27770: int mem_base;
! 27771: int ret_val;
! 27772: void * context; /* the I/O context */
! 27773: int n_context;
! 27774:
! 27775: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
! 27776: mem_base = xmlMemBlocks();
! 27777: context = gen_void_ptr(n_context, 0);
! 27778:
! 27779: ret_val = xmlIOFTPClose(context);
! 27780: desret_int(ret_val);
! 27781: call_tests++;
! 27782: des_void_ptr(n_context, context, 0);
! 27783: xmlResetLastError();
! 27784: if (mem_base != xmlMemBlocks()) {
! 27785: printf("Leak of %d blocks found in xmlIOFTPClose",
! 27786: xmlMemBlocks() - mem_base);
! 27787: test_ret++;
! 27788: printf(" %d", n_context);
! 27789: printf("\n");
! 27790: }
! 27791: }
! 27792: function_tests++;
! 27793: #endif
! 27794:
! 27795: return(test_ret);
! 27796: }
! 27797:
! 27798:
! 27799: static int
! 27800: test_xmlIOFTPMatch(void) {
! 27801: int test_ret = 0;
! 27802:
! 27803: #if defined(LIBXML_FTP_ENABLED)
! 27804: int mem_base;
! 27805: int ret_val;
! 27806: const char * filename; /* the URI for matching */
! 27807: int n_filename;
! 27808:
! 27809: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 27810: mem_base = xmlMemBlocks();
! 27811: filename = gen_filepath(n_filename, 0);
! 27812:
! 27813: ret_val = xmlIOFTPMatch(filename);
! 27814: desret_int(ret_val);
! 27815: call_tests++;
! 27816: des_filepath(n_filename, filename, 0);
! 27817: xmlResetLastError();
! 27818: if (mem_base != xmlMemBlocks()) {
! 27819: printf("Leak of %d blocks found in xmlIOFTPMatch",
! 27820: xmlMemBlocks() - mem_base);
! 27821: test_ret++;
! 27822: printf(" %d", n_filename);
! 27823: printf("\n");
! 27824: }
! 27825: }
! 27826: function_tests++;
! 27827: #endif
! 27828:
! 27829: return(test_ret);
! 27830: }
! 27831:
! 27832:
! 27833: static int
! 27834: test_xmlIOFTPOpen(void) {
! 27835: int test_ret = 0;
! 27836:
! 27837: #if defined(LIBXML_FTP_ENABLED)
! 27838: int mem_base;
! 27839: void * ret_val;
! 27840: const char * filename; /* the URI for matching */
! 27841: int n_filename;
! 27842:
! 27843: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 27844: mem_base = xmlMemBlocks();
! 27845: filename = gen_filepath(n_filename, 0);
! 27846:
! 27847: ret_val = xmlIOFTPOpen(filename);
! 27848: desret_void_ptr(ret_val);
! 27849: call_tests++;
! 27850: des_filepath(n_filename, filename, 0);
! 27851: xmlResetLastError();
! 27852: if (mem_base != xmlMemBlocks()) {
! 27853: printf("Leak of %d blocks found in xmlIOFTPOpen",
! 27854: xmlMemBlocks() - mem_base);
! 27855: test_ret++;
! 27856: printf(" %d", n_filename);
! 27857: printf("\n");
! 27858: }
! 27859: }
! 27860: function_tests++;
! 27861: #endif
! 27862:
! 27863: return(test_ret);
! 27864: }
! 27865:
! 27866:
! 27867: static int
! 27868: test_xmlIOFTPRead(void) {
! 27869: int test_ret = 0;
! 27870:
! 27871: #if defined(LIBXML_FTP_ENABLED)
! 27872: int mem_base;
! 27873: int ret_val;
! 27874: void * context; /* the I/O context */
! 27875: int n_context;
! 27876: char * buffer; /* where to drop data */
! 27877: int n_buffer;
! 27878: int len; /* number of bytes to write */
! 27879: int n_len;
! 27880:
! 27881: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
! 27882: for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
! 27883: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 27884: mem_base = xmlMemBlocks();
! 27885: context = gen_void_ptr(n_context, 0);
! 27886: buffer = gen_char_ptr(n_buffer, 1);
! 27887: len = gen_int(n_len, 2);
! 27888:
! 27889: ret_val = xmlIOFTPRead(context, buffer, len);
! 27890: desret_int(ret_val);
! 27891: call_tests++;
! 27892: des_void_ptr(n_context, context, 0);
! 27893: des_char_ptr(n_buffer, buffer, 1);
! 27894: des_int(n_len, len, 2);
! 27895: xmlResetLastError();
! 27896: if (mem_base != xmlMemBlocks()) {
! 27897: printf("Leak of %d blocks found in xmlIOFTPRead",
! 27898: xmlMemBlocks() - mem_base);
! 27899: test_ret++;
! 27900: printf(" %d", n_context);
! 27901: printf(" %d", n_buffer);
! 27902: printf(" %d", n_len);
! 27903: printf("\n");
! 27904: }
! 27905: }
! 27906: }
! 27907: }
! 27908: function_tests++;
! 27909: #endif
! 27910:
! 27911: return(test_ret);
! 27912: }
! 27913:
! 27914:
! 27915: static int
! 27916: test_xmlIOHTTPClose(void) {
! 27917: int test_ret = 0;
! 27918:
! 27919: #if defined(LIBXML_HTTP_ENABLED)
! 27920: int mem_base;
! 27921: int ret_val;
! 27922: void * context; /* the I/O context */
! 27923: int n_context;
! 27924:
! 27925: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
! 27926: mem_base = xmlMemBlocks();
! 27927: context = gen_void_ptr(n_context, 0);
! 27928:
! 27929: ret_val = xmlIOHTTPClose(context);
! 27930: desret_int(ret_val);
! 27931: call_tests++;
! 27932: des_void_ptr(n_context, context, 0);
! 27933: xmlResetLastError();
! 27934: if (mem_base != xmlMemBlocks()) {
! 27935: printf("Leak of %d blocks found in xmlIOHTTPClose",
! 27936: xmlMemBlocks() - mem_base);
! 27937: test_ret++;
! 27938: printf(" %d", n_context);
! 27939: printf("\n");
! 27940: }
! 27941: }
! 27942: function_tests++;
! 27943: #endif
! 27944:
! 27945: return(test_ret);
! 27946: }
! 27947:
! 27948:
! 27949: static int
! 27950: test_xmlIOHTTPMatch(void) {
! 27951: int test_ret = 0;
! 27952:
! 27953: #if defined(LIBXML_HTTP_ENABLED)
! 27954: int mem_base;
! 27955: int ret_val;
! 27956: const char * filename; /* the URI for matching */
! 27957: int n_filename;
! 27958:
! 27959: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 27960: mem_base = xmlMemBlocks();
! 27961: filename = gen_filepath(n_filename, 0);
! 27962:
! 27963: ret_val = xmlIOHTTPMatch(filename);
! 27964: desret_int(ret_val);
! 27965: call_tests++;
! 27966: des_filepath(n_filename, filename, 0);
! 27967: xmlResetLastError();
! 27968: if (mem_base != xmlMemBlocks()) {
! 27969: printf("Leak of %d blocks found in xmlIOHTTPMatch",
! 27970: xmlMemBlocks() - mem_base);
! 27971: test_ret++;
! 27972: printf(" %d", n_filename);
! 27973: printf("\n");
! 27974: }
! 27975: }
! 27976: function_tests++;
! 27977: #endif
! 27978:
! 27979: return(test_ret);
! 27980: }
! 27981:
! 27982:
! 27983: static int
! 27984: test_xmlIOHTTPOpen(void) {
! 27985: int test_ret = 0;
! 27986:
! 27987: #if defined(LIBXML_HTTP_ENABLED)
! 27988: int mem_base;
! 27989: void * ret_val;
! 27990: const char * filename; /* the URI for matching */
! 27991: int n_filename;
! 27992:
! 27993: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 27994: mem_base = xmlMemBlocks();
! 27995: filename = gen_filepath(n_filename, 0);
! 27996:
! 27997: ret_val = xmlIOHTTPOpen(filename);
! 27998: desret_xmlNanoHTTPCtxtPtr(ret_val);
! 27999: call_tests++;
! 28000: des_filepath(n_filename, filename, 0);
! 28001: xmlResetLastError();
! 28002: if (mem_base != xmlMemBlocks()) {
! 28003: printf("Leak of %d blocks found in xmlIOHTTPOpen",
! 28004: xmlMemBlocks() - mem_base);
! 28005: test_ret++;
! 28006: printf(" %d", n_filename);
! 28007: printf("\n");
! 28008: }
! 28009: }
! 28010: function_tests++;
! 28011: #endif
! 28012:
! 28013: return(test_ret);
! 28014: }
! 28015:
! 28016:
! 28017: static int
! 28018: test_xmlIOHTTPRead(void) {
! 28019: int test_ret = 0;
! 28020:
! 28021: #if defined(LIBXML_HTTP_ENABLED)
! 28022: int mem_base;
! 28023: int ret_val;
! 28024: void * context; /* the I/O context */
! 28025: int n_context;
! 28026: char * buffer; /* where to drop data */
! 28027: int n_buffer;
! 28028: int len; /* number of bytes to write */
! 28029: int n_len;
! 28030:
! 28031: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
! 28032: for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
! 28033: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 28034: mem_base = xmlMemBlocks();
! 28035: context = gen_void_ptr(n_context, 0);
! 28036: buffer = gen_char_ptr(n_buffer, 1);
! 28037: len = gen_int(n_len, 2);
! 28038:
! 28039: ret_val = xmlIOHTTPRead(context, buffer, len);
! 28040: desret_int(ret_val);
! 28041: call_tests++;
! 28042: des_void_ptr(n_context, context, 0);
! 28043: des_char_ptr(n_buffer, buffer, 1);
! 28044: des_int(n_len, len, 2);
! 28045: xmlResetLastError();
! 28046: if (mem_base != xmlMemBlocks()) {
! 28047: printf("Leak of %d blocks found in xmlIOHTTPRead",
! 28048: xmlMemBlocks() - mem_base);
! 28049: test_ret++;
! 28050: printf(" %d", n_context);
! 28051: printf(" %d", n_buffer);
! 28052: printf(" %d", n_len);
! 28053: printf("\n");
! 28054: }
! 28055: }
! 28056: }
! 28057: }
! 28058: function_tests++;
! 28059: #endif
! 28060:
! 28061: return(test_ret);
! 28062: }
! 28063:
! 28064:
! 28065: static int
! 28066: test_xmlNoNetExternalEntityLoader(void) {
! 28067: int test_ret = 0;
! 28068:
! 28069: int mem_base;
! 28070: xmlParserInputPtr ret_val;
! 28071: const char * URL; /* the URL for the entity to load */
! 28072: int n_URL;
! 28073: char * ID; /* the System ID for the entity to load */
! 28074: int n_ID;
! 28075: xmlParserCtxtPtr ctxt; /* the context in which the entity is called or NULL */
! 28076: int n_ctxt;
! 28077:
! 28078: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 28079: for (n_ID = 0;n_ID < gen_nb_const_char_ptr;n_ID++) {
! 28080: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 28081: mem_base = xmlMemBlocks();
! 28082: URL = gen_filepath(n_URL, 0);
! 28083: ID = gen_const_char_ptr(n_ID, 1);
! 28084: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 2);
! 28085:
! 28086: ret_val = xmlNoNetExternalEntityLoader(URL, (const char *)ID, ctxt);
! 28087: desret_xmlParserInputPtr(ret_val);
! 28088: call_tests++;
! 28089: des_filepath(n_URL, URL, 0);
! 28090: des_const_char_ptr(n_ID, (const char *)ID, 1);
! 28091: des_xmlParserCtxtPtr(n_ctxt, ctxt, 2);
! 28092: xmlResetLastError();
! 28093: if (mem_base != xmlMemBlocks()) {
! 28094: printf("Leak of %d blocks found in xmlNoNetExternalEntityLoader",
! 28095: xmlMemBlocks() - mem_base);
! 28096: test_ret++;
! 28097: printf(" %d", n_URL);
! 28098: printf(" %d", n_ID);
! 28099: printf(" %d", n_ctxt);
! 28100: printf("\n");
! 28101: }
! 28102: }
! 28103: }
! 28104: }
! 28105: function_tests++;
! 28106:
! 28107: return(test_ret);
! 28108: }
! 28109:
! 28110:
! 28111: static int
! 28112: test_xmlNormalizeWindowsPath(void) {
! 28113: int test_ret = 0;
! 28114:
! 28115: int mem_base;
! 28116: xmlChar * ret_val;
! 28117: xmlChar * path; /* the input file path */
! 28118: int n_path;
! 28119:
! 28120: for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) {
! 28121: mem_base = xmlMemBlocks();
! 28122: path = gen_const_xmlChar_ptr(n_path, 0);
! 28123:
! 28124: ret_val = xmlNormalizeWindowsPath((const xmlChar *)path);
! 28125: desret_xmlChar_ptr(ret_val);
! 28126: call_tests++;
! 28127: des_const_xmlChar_ptr(n_path, (const xmlChar *)path, 0);
! 28128: xmlResetLastError();
! 28129: if (mem_base != xmlMemBlocks()) {
! 28130: printf("Leak of %d blocks found in xmlNormalizeWindowsPath",
! 28131: xmlMemBlocks() - mem_base);
! 28132: test_ret++;
! 28133: printf(" %d", n_path);
! 28134: printf("\n");
! 28135: }
! 28136: }
! 28137: function_tests++;
! 28138:
! 28139: return(test_ret);
! 28140: }
! 28141:
! 28142:
! 28143: static int
! 28144: test_xmlOutputBufferCreateBuffer(void) {
! 28145: int test_ret = 0;
! 28146:
! 28147: #if defined(LIBXML_OUTPUT_ENABLED)
! 28148: int mem_base;
! 28149: xmlOutputBufferPtr ret_val;
! 28150: xmlBufferPtr buffer; /* a xmlBufferPtr */
! 28151: int n_buffer;
! 28152: xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
! 28153: int n_encoder;
! 28154:
! 28155: for (n_buffer = 0;n_buffer < gen_nb_xmlBufferPtr;n_buffer++) {
! 28156: for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
! 28157: mem_base = xmlMemBlocks();
! 28158: buffer = gen_xmlBufferPtr(n_buffer, 0);
! 28159: encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
! 28160:
! 28161: ret_val = xmlOutputBufferCreateBuffer(buffer, encoder);
! 28162: desret_xmlOutputBufferPtr(ret_val);
! 28163: call_tests++;
! 28164: des_xmlBufferPtr(n_buffer, buffer, 0);
! 28165: des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
! 28166: xmlResetLastError();
! 28167: if (mem_base != xmlMemBlocks()) {
! 28168: printf("Leak of %d blocks found in xmlOutputBufferCreateBuffer",
! 28169: xmlMemBlocks() - mem_base);
! 28170: test_ret++;
! 28171: printf(" %d", n_buffer);
! 28172: printf(" %d", n_encoder);
! 28173: printf("\n");
! 28174: }
! 28175: }
! 28176: }
! 28177: function_tests++;
! 28178: #endif
! 28179:
! 28180: return(test_ret);
! 28181: }
! 28182:
! 28183:
! 28184: static int
! 28185: test_xmlOutputBufferCreateFd(void) {
! 28186: int test_ret = 0;
! 28187:
! 28188: #if defined(LIBXML_OUTPUT_ENABLED)
! 28189: int mem_base;
! 28190: xmlOutputBufferPtr ret_val;
! 28191: int fd; /* a file descriptor number */
! 28192: int n_fd;
! 28193: xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
! 28194: int n_encoder;
! 28195:
! 28196: for (n_fd = 0;n_fd < gen_nb_int;n_fd++) {
! 28197: for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
! 28198: mem_base = xmlMemBlocks();
! 28199: fd = gen_int(n_fd, 0);
! 28200: encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
! 28201:
! 28202: ret_val = xmlOutputBufferCreateFd(fd, encoder);
! 28203: desret_xmlOutputBufferPtr(ret_val);
! 28204: call_tests++;
! 28205: des_int(n_fd, fd, 0);
! 28206: des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
! 28207: xmlResetLastError();
! 28208: if (mem_base != xmlMemBlocks()) {
! 28209: printf("Leak of %d blocks found in xmlOutputBufferCreateFd",
! 28210: xmlMemBlocks() - mem_base);
! 28211: test_ret++;
! 28212: printf(" %d", n_fd);
! 28213: printf(" %d", n_encoder);
! 28214: printf("\n");
! 28215: }
! 28216: }
! 28217: }
! 28218: function_tests++;
! 28219: #endif
! 28220:
! 28221: return(test_ret);
! 28222: }
! 28223:
! 28224:
! 28225: static int
! 28226: test_xmlOutputBufferCreateFile(void) {
! 28227: int test_ret = 0;
! 28228:
! 28229: #if defined(LIBXML_OUTPUT_ENABLED)
! 28230: int mem_base;
! 28231: xmlOutputBufferPtr ret_val;
! 28232: FILE * file; /* a FILE* */
! 28233: int n_file;
! 28234: xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
! 28235: int n_encoder;
! 28236:
! 28237: for (n_file = 0;n_file < gen_nb_FILE_ptr;n_file++) {
! 28238: for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
! 28239: mem_base = xmlMemBlocks();
! 28240: file = gen_FILE_ptr(n_file, 0);
! 28241: encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
! 28242:
! 28243: ret_val = xmlOutputBufferCreateFile(file, encoder);
! 28244: desret_xmlOutputBufferPtr(ret_val);
! 28245: call_tests++;
! 28246: des_FILE_ptr(n_file, file, 0);
! 28247: des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
! 28248: xmlResetLastError();
! 28249: if (mem_base != xmlMemBlocks()) {
! 28250: printf("Leak of %d blocks found in xmlOutputBufferCreateFile",
! 28251: xmlMemBlocks() - mem_base);
! 28252: test_ret++;
! 28253: printf(" %d", n_file);
! 28254: printf(" %d", n_encoder);
! 28255: printf("\n");
! 28256: }
! 28257: }
! 28258: }
! 28259: function_tests++;
! 28260: #endif
! 28261:
! 28262: return(test_ret);
! 28263: }
! 28264:
! 28265:
! 28266: static int
! 28267: test_xmlOutputBufferCreateFilename(void) {
! 28268: int test_ret = 0;
! 28269:
! 28270: #if defined(LIBXML_OUTPUT_ENABLED)
! 28271: int mem_base;
! 28272: xmlOutputBufferPtr ret_val;
! 28273: const char * URI; /* a C string containing the URI or filename */
! 28274: int n_URI;
! 28275: xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
! 28276: int n_encoder;
! 28277: int compression; /* the compression ration (0 none, 9 max). */
! 28278: int n_compression;
! 28279:
! 28280: for (n_URI = 0;n_URI < gen_nb_fileoutput;n_URI++) {
! 28281: for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
! 28282: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
! 28283: mem_base = xmlMemBlocks();
! 28284: URI = gen_fileoutput(n_URI, 0);
! 28285: encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
! 28286: compression = gen_int(n_compression, 2);
! 28287:
! 28288: ret_val = xmlOutputBufferCreateFilename(URI, encoder, compression);
! 28289: desret_xmlOutputBufferPtr(ret_val);
! 28290: call_tests++;
! 28291: des_fileoutput(n_URI, URI, 0);
! 28292: des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
! 28293: des_int(n_compression, compression, 2);
! 28294: xmlResetLastError();
! 28295: if (mem_base != xmlMemBlocks()) {
! 28296: printf("Leak of %d blocks found in xmlOutputBufferCreateFilename",
! 28297: xmlMemBlocks() - mem_base);
! 28298: test_ret++;
! 28299: printf(" %d", n_URI);
! 28300: printf(" %d", n_encoder);
! 28301: printf(" %d", n_compression);
! 28302: printf("\n");
! 28303: }
! 28304: }
! 28305: }
! 28306: }
! 28307: function_tests++;
! 28308: #endif
! 28309:
! 28310: return(test_ret);
! 28311: }
! 28312:
! 28313:
! 28314: static int
! 28315: test_xmlOutputBufferFlush(void) {
! 28316: int test_ret = 0;
! 28317:
! 28318: #if defined(LIBXML_OUTPUT_ENABLED)
! 28319: int mem_base;
! 28320: int ret_val;
! 28321: xmlOutputBufferPtr out; /* a buffered output */
! 28322: int n_out;
! 28323:
! 28324: for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
! 28325: mem_base = xmlMemBlocks();
! 28326: out = gen_xmlOutputBufferPtr(n_out, 0);
! 28327:
! 28328: ret_val = xmlOutputBufferFlush(out);
! 28329: desret_int(ret_val);
! 28330: call_tests++;
! 28331: des_xmlOutputBufferPtr(n_out, out, 0);
! 28332: xmlResetLastError();
! 28333: if (mem_base != xmlMemBlocks()) {
! 28334: printf("Leak of %d blocks found in xmlOutputBufferFlush",
! 28335: xmlMemBlocks() - mem_base);
! 28336: test_ret++;
! 28337: printf(" %d", n_out);
! 28338: printf("\n");
! 28339: }
! 28340: }
! 28341: function_tests++;
! 28342: #endif
! 28343:
! 28344: return(test_ret);
! 28345: }
! 28346:
! 28347:
! 28348: static int
! 28349: test_xmlOutputBufferWrite(void) {
! 28350: int test_ret = 0;
! 28351:
! 28352: #if defined(LIBXML_OUTPUT_ENABLED)
! 28353: int mem_base;
! 28354: int ret_val;
! 28355: xmlOutputBufferPtr out; /* a buffered parser output */
! 28356: int n_out;
! 28357: int len; /* the size in bytes of the array. */
! 28358: int n_len;
! 28359: char * buf; /* an char array */
! 28360: int n_buf;
! 28361:
! 28362: for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
! 28363: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 28364: for (n_buf = 0;n_buf < gen_nb_const_char_ptr;n_buf++) {
! 28365: mem_base = xmlMemBlocks();
! 28366: out = gen_xmlOutputBufferPtr(n_out, 0);
! 28367: len = gen_int(n_len, 1);
! 28368: buf = gen_const_char_ptr(n_buf, 2);
! 28369:
! 28370: ret_val = xmlOutputBufferWrite(out, len, (const char *)buf);
! 28371: desret_int(ret_val);
! 28372: call_tests++;
! 28373: des_xmlOutputBufferPtr(n_out, out, 0);
! 28374: des_int(n_len, len, 1);
! 28375: des_const_char_ptr(n_buf, (const char *)buf, 2);
! 28376: xmlResetLastError();
! 28377: if (mem_base != xmlMemBlocks()) {
! 28378: printf("Leak of %d blocks found in xmlOutputBufferWrite",
! 28379: xmlMemBlocks() - mem_base);
! 28380: test_ret++;
! 28381: printf(" %d", n_out);
! 28382: printf(" %d", n_len);
! 28383: printf(" %d", n_buf);
! 28384: printf("\n");
! 28385: }
! 28386: }
! 28387: }
! 28388: }
! 28389: function_tests++;
! 28390: #endif
! 28391:
! 28392: return(test_ret);
! 28393: }
! 28394:
! 28395:
! 28396: static int
! 28397: test_xmlOutputBufferWriteEscape(void) {
! 28398: int test_ret = 0;
! 28399:
! 28400:
! 28401: /* missing type support */
! 28402: return(test_ret);
! 28403: }
! 28404:
! 28405:
! 28406: static int
! 28407: test_xmlOutputBufferWriteString(void) {
! 28408: int test_ret = 0;
! 28409:
! 28410: #if defined(LIBXML_OUTPUT_ENABLED)
! 28411: int mem_base;
! 28412: int ret_val;
! 28413: xmlOutputBufferPtr out; /* a buffered parser output */
! 28414: int n_out;
! 28415: char * str; /* a zero terminated C string */
! 28416: int n_str;
! 28417:
! 28418: for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
! 28419: for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) {
! 28420: mem_base = xmlMemBlocks();
! 28421: out = gen_xmlOutputBufferPtr(n_out, 0);
! 28422: str = gen_const_char_ptr(n_str, 1);
! 28423:
! 28424: ret_val = xmlOutputBufferWriteString(out, (const char *)str);
! 28425: desret_int(ret_val);
! 28426: call_tests++;
! 28427: des_xmlOutputBufferPtr(n_out, out, 0);
! 28428: des_const_char_ptr(n_str, (const char *)str, 1);
! 28429: xmlResetLastError();
! 28430: if (mem_base != xmlMemBlocks()) {
! 28431: printf("Leak of %d blocks found in xmlOutputBufferWriteString",
! 28432: xmlMemBlocks() - mem_base);
! 28433: test_ret++;
! 28434: printf(" %d", n_out);
! 28435: printf(" %d", n_str);
! 28436: printf("\n");
! 28437: }
! 28438: }
! 28439: }
! 28440: function_tests++;
! 28441: #endif
! 28442:
! 28443: return(test_ret);
! 28444: }
! 28445:
! 28446:
! 28447: static int
! 28448: test_xmlParserGetDirectory(void) {
! 28449: int test_ret = 0;
! 28450:
! 28451:
! 28452: /* missing type support */
! 28453: return(test_ret);
! 28454: }
! 28455:
! 28456:
! 28457: static int
! 28458: test_xmlParserInputBufferCreateFd(void) {
! 28459: int test_ret = 0;
! 28460:
! 28461: int mem_base;
! 28462: xmlParserInputBufferPtr ret_val;
! 28463: int fd; /* a file descriptor number */
! 28464: int n_fd;
! 28465: xmlCharEncoding enc; /* the charset encoding if known */
! 28466: int n_enc;
! 28467:
! 28468: for (n_fd = 0;n_fd < gen_nb_int;n_fd++) {
! 28469: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
! 28470: mem_base = xmlMemBlocks();
! 28471: fd = gen_int(n_fd, 0);
! 28472: enc = gen_xmlCharEncoding(n_enc, 1);
! 28473: if (fd >= 0) fd = -1;
! 28474:
! 28475: ret_val = xmlParserInputBufferCreateFd(fd, enc);
! 28476: desret_xmlParserInputBufferPtr(ret_val);
! 28477: call_tests++;
! 28478: des_int(n_fd, fd, 0);
! 28479: des_xmlCharEncoding(n_enc, enc, 1);
! 28480: xmlResetLastError();
! 28481: if (mem_base != xmlMemBlocks()) {
! 28482: printf("Leak of %d blocks found in xmlParserInputBufferCreateFd",
! 28483: xmlMemBlocks() - mem_base);
! 28484: test_ret++;
! 28485: printf(" %d", n_fd);
! 28486: printf(" %d", n_enc);
! 28487: printf("\n");
! 28488: }
! 28489: }
! 28490: }
! 28491: function_tests++;
! 28492:
! 28493: return(test_ret);
! 28494: }
! 28495:
! 28496:
! 28497: static int
! 28498: test_xmlParserInputBufferCreateFile(void) {
! 28499: int test_ret = 0;
! 28500:
! 28501: int mem_base;
! 28502: xmlParserInputBufferPtr ret_val;
! 28503: FILE * file; /* a FILE* */
! 28504: int n_file;
! 28505: xmlCharEncoding enc; /* the charset encoding if known */
! 28506: int n_enc;
! 28507:
! 28508: for (n_file = 0;n_file < gen_nb_FILE_ptr;n_file++) {
! 28509: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
! 28510: mem_base = xmlMemBlocks();
! 28511: file = gen_FILE_ptr(n_file, 0);
! 28512: enc = gen_xmlCharEncoding(n_enc, 1);
! 28513:
! 28514: ret_val = xmlParserInputBufferCreateFile(file, enc);
! 28515: desret_xmlParserInputBufferPtr(ret_val);
! 28516: call_tests++;
! 28517: des_FILE_ptr(n_file, file, 0);
! 28518: des_xmlCharEncoding(n_enc, enc, 1);
! 28519: xmlResetLastError();
! 28520: if (mem_base != xmlMemBlocks()) {
! 28521: printf("Leak of %d blocks found in xmlParserInputBufferCreateFile",
! 28522: xmlMemBlocks() - mem_base);
! 28523: test_ret++;
! 28524: printf(" %d", n_file);
! 28525: printf(" %d", n_enc);
! 28526: printf("\n");
! 28527: }
! 28528: }
! 28529: }
! 28530: function_tests++;
! 28531:
! 28532: return(test_ret);
! 28533: }
! 28534:
! 28535:
! 28536: static int
! 28537: test_xmlParserInputBufferCreateFilename(void) {
! 28538: int test_ret = 0;
! 28539:
! 28540: int mem_base;
! 28541: xmlParserInputBufferPtr ret_val;
! 28542: const char * URI; /* a C string containing the URI or filename */
! 28543: int n_URI;
! 28544: xmlCharEncoding enc; /* the charset encoding if known */
! 28545: int n_enc;
! 28546:
! 28547: for (n_URI = 0;n_URI < gen_nb_fileoutput;n_URI++) {
! 28548: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
! 28549: mem_base = xmlMemBlocks();
! 28550: URI = gen_fileoutput(n_URI, 0);
! 28551: enc = gen_xmlCharEncoding(n_enc, 1);
! 28552:
! 28553: ret_val = xmlParserInputBufferCreateFilename(URI, enc);
! 28554: desret_xmlParserInputBufferPtr(ret_val);
! 28555: call_tests++;
! 28556: des_fileoutput(n_URI, URI, 0);
! 28557: des_xmlCharEncoding(n_enc, enc, 1);
! 28558: xmlResetLastError();
! 28559: if (mem_base != xmlMemBlocks()) {
! 28560: printf("Leak of %d blocks found in xmlParserInputBufferCreateFilename",
! 28561: xmlMemBlocks() - mem_base);
! 28562: test_ret++;
! 28563: printf(" %d", n_URI);
! 28564: printf(" %d", n_enc);
! 28565: printf("\n");
! 28566: }
! 28567: }
! 28568: }
! 28569: function_tests++;
! 28570:
! 28571: return(test_ret);
! 28572: }
! 28573:
! 28574:
! 28575: static int
! 28576: test_xmlParserInputBufferCreateMem(void) {
! 28577: int test_ret = 0;
! 28578:
! 28579: int mem_base;
! 28580: xmlParserInputBufferPtr ret_val;
! 28581: char * mem; /* the memory input */
! 28582: int n_mem;
! 28583: int size; /* the length of the memory block */
! 28584: int n_size;
! 28585: xmlCharEncoding enc; /* the charset encoding if known */
! 28586: int n_enc;
! 28587:
! 28588: for (n_mem = 0;n_mem < gen_nb_const_char_ptr;n_mem++) {
! 28589: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 28590: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
! 28591: mem_base = xmlMemBlocks();
! 28592: mem = gen_const_char_ptr(n_mem, 0);
! 28593: size = gen_int(n_size, 1);
! 28594: enc = gen_xmlCharEncoding(n_enc, 2);
! 28595:
! 28596: ret_val = xmlParserInputBufferCreateMem((const char *)mem, size, enc);
! 28597: desret_xmlParserInputBufferPtr(ret_val);
! 28598: call_tests++;
! 28599: des_const_char_ptr(n_mem, (const char *)mem, 0);
! 28600: des_int(n_size, size, 1);
! 28601: des_xmlCharEncoding(n_enc, enc, 2);
! 28602: xmlResetLastError();
! 28603: if (mem_base != xmlMemBlocks()) {
! 28604: printf("Leak of %d blocks found in xmlParserInputBufferCreateMem",
! 28605: xmlMemBlocks() - mem_base);
! 28606: test_ret++;
! 28607: printf(" %d", n_mem);
! 28608: printf(" %d", n_size);
! 28609: printf(" %d", n_enc);
! 28610: printf("\n");
! 28611: }
! 28612: }
! 28613: }
! 28614: }
! 28615: function_tests++;
! 28616:
! 28617: return(test_ret);
! 28618: }
! 28619:
! 28620:
! 28621: static int
! 28622: test_xmlParserInputBufferCreateStatic(void) {
! 28623: int test_ret = 0;
! 28624:
! 28625: int mem_base;
! 28626: xmlParserInputBufferPtr ret_val;
! 28627: char * mem; /* the memory input */
! 28628: int n_mem;
! 28629: int size; /* the length of the memory block */
! 28630: int n_size;
! 28631: xmlCharEncoding enc; /* the charset encoding if known */
! 28632: int n_enc;
! 28633:
! 28634: for (n_mem = 0;n_mem < gen_nb_const_char_ptr;n_mem++) {
! 28635: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 28636: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
! 28637: mem_base = xmlMemBlocks();
! 28638: mem = gen_const_char_ptr(n_mem, 0);
! 28639: size = gen_int(n_size, 1);
! 28640: enc = gen_xmlCharEncoding(n_enc, 2);
! 28641:
! 28642: ret_val = xmlParserInputBufferCreateStatic((const char *)mem, size, enc);
! 28643: desret_xmlParserInputBufferPtr(ret_val);
! 28644: call_tests++;
! 28645: des_const_char_ptr(n_mem, (const char *)mem, 0);
! 28646: des_int(n_size, size, 1);
! 28647: des_xmlCharEncoding(n_enc, enc, 2);
! 28648: xmlResetLastError();
! 28649: if (mem_base != xmlMemBlocks()) {
! 28650: printf("Leak of %d blocks found in xmlParserInputBufferCreateStatic",
! 28651: xmlMemBlocks() - mem_base);
! 28652: test_ret++;
! 28653: printf(" %d", n_mem);
! 28654: printf(" %d", n_size);
! 28655: printf(" %d", n_enc);
! 28656: printf("\n");
! 28657: }
! 28658: }
! 28659: }
! 28660: }
! 28661: function_tests++;
! 28662:
! 28663: return(test_ret);
! 28664: }
! 28665:
! 28666:
! 28667: static int
! 28668: test_xmlParserInputBufferGrow(void) {
! 28669: int test_ret = 0;
! 28670:
! 28671: int mem_base;
! 28672: int ret_val;
! 28673: xmlParserInputBufferPtr in; /* a buffered parser input */
! 28674: int n_in;
! 28675: int len; /* indicative value of the amount of chars to read */
! 28676: int n_len;
! 28677:
! 28678: for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) {
! 28679: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 28680: mem_base = xmlMemBlocks();
! 28681: in = gen_xmlParserInputBufferPtr(n_in, 0);
! 28682: len = gen_int(n_len, 1);
! 28683:
! 28684: ret_val = xmlParserInputBufferGrow(in, len);
! 28685: desret_int(ret_val);
! 28686: call_tests++;
! 28687: des_xmlParserInputBufferPtr(n_in, in, 0);
! 28688: des_int(n_len, len, 1);
! 28689: xmlResetLastError();
! 28690: if (mem_base != xmlMemBlocks()) {
! 28691: printf("Leak of %d blocks found in xmlParserInputBufferGrow",
! 28692: xmlMemBlocks() - mem_base);
! 28693: test_ret++;
! 28694: printf(" %d", n_in);
! 28695: printf(" %d", n_len);
! 28696: printf("\n");
! 28697: }
! 28698: }
! 28699: }
! 28700: function_tests++;
! 28701:
! 28702: return(test_ret);
! 28703: }
! 28704:
! 28705:
! 28706: static int
! 28707: test_xmlParserInputBufferPush(void) {
! 28708: int test_ret = 0;
! 28709:
! 28710: int mem_base;
! 28711: int ret_val;
! 28712: xmlParserInputBufferPtr in; /* a buffered parser input */
! 28713: int n_in;
! 28714: int len; /* the size in bytes of the array. */
! 28715: int n_len;
! 28716: char * buf; /* an char array */
! 28717: int n_buf;
! 28718:
! 28719: for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) {
! 28720: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 28721: for (n_buf = 0;n_buf < gen_nb_const_char_ptr;n_buf++) {
! 28722: mem_base = xmlMemBlocks();
! 28723: in = gen_xmlParserInputBufferPtr(n_in, 0);
! 28724: len = gen_int(n_len, 1);
! 28725: buf = gen_const_char_ptr(n_buf, 2);
! 28726:
! 28727: ret_val = xmlParserInputBufferPush(in, len, (const char *)buf);
! 28728: desret_int(ret_val);
! 28729: call_tests++;
! 28730: des_xmlParserInputBufferPtr(n_in, in, 0);
! 28731: des_int(n_len, len, 1);
! 28732: des_const_char_ptr(n_buf, (const char *)buf, 2);
! 28733: xmlResetLastError();
! 28734: if (mem_base != xmlMemBlocks()) {
! 28735: printf("Leak of %d blocks found in xmlParserInputBufferPush",
! 28736: xmlMemBlocks() - mem_base);
! 28737: test_ret++;
! 28738: printf(" %d", n_in);
! 28739: printf(" %d", n_len);
! 28740: printf(" %d", n_buf);
! 28741: printf("\n");
! 28742: }
! 28743: }
! 28744: }
! 28745: }
! 28746: function_tests++;
! 28747:
! 28748: return(test_ret);
! 28749: }
! 28750:
! 28751:
! 28752: static int
! 28753: test_xmlParserInputBufferRead(void) {
! 28754: int test_ret = 0;
! 28755:
! 28756: int mem_base;
! 28757: int ret_val;
! 28758: xmlParserInputBufferPtr in; /* a buffered parser input */
! 28759: int n_in;
! 28760: int len; /* indicative value of the amount of chars to read */
! 28761: int n_len;
! 28762:
! 28763: for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) {
! 28764: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 28765: mem_base = xmlMemBlocks();
! 28766: in = gen_xmlParserInputBufferPtr(n_in, 0);
! 28767: len = gen_int(n_len, 1);
! 28768:
! 28769: ret_val = xmlParserInputBufferRead(in, len);
! 28770: desret_int(ret_val);
! 28771: call_tests++;
! 28772: des_xmlParserInputBufferPtr(n_in, in, 0);
! 28773: des_int(n_len, len, 1);
! 28774: xmlResetLastError();
! 28775: if (mem_base != xmlMemBlocks()) {
! 28776: printf("Leak of %d blocks found in xmlParserInputBufferRead",
! 28777: xmlMemBlocks() - mem_base);
! 28778: test_ret++;
! 28779: printf(" %d", n_in);
! 28780: printf(" %d", n_len);
! 28781: printf("\n");
! 28782: }
! 28783: }
! 28784: }
! 28785: function_tests++;
! 28786:
! 28787: return(test_ret);
! 28788: }
! 28789:
! 28790:
! 28791: static int
! 28792: test_xmlPopInputCallbacks(void) {
! 28793: int test_ret = 0;
! 28794:
! 28795: int mem_base;
! 28796: int ret_val;
! 28797:
! 28798: mem_base = xmlMemBlocks();
! 28799:
! 28800: ret_val = xmlPopInputCallbacks();
! 28801: desret_int(ret_val);
! 28802: call_tests++;
! 28803: xmlResetLastError();
! 28804: if (mem_base != xmlMemBlocks()) {
! 28805: printf("Leak of %d blocks found in xmlPopInputCallbacks",
! 28806: xmlMemBlocks() - mem_base);
! 28807: test_ret++;
! 28808: printf("\n");
! 28809: }
! 28810: function_tests++;
! 28811:
! 28812: return(test_ret);
! 28813: }
! 28814:
! 28815:
! 28816: static int
! 28817: test_xmlRegisterDefaultInputCallbacks(void) {
! 28818: int test_ret = 0;
! 28819:
! 28820: int mem_base;
! 28821:
! 28822: mem_base = xmlMemBlocks();
! 28823:
! 28824: xmlRegisterDefaultInputCallbacks();
! 28825: call_tests++;
! 28826: xmlResetLastError();
! 28827: if (mem_base != xmlMemBlocks()) {
! 28828: printf("Leak of %d blocks found in xmlRegisterDefaultInputCallbacks",
! 28829: xmlMemBlocks() - mem_base);
! 28830: test_ret++;
! 28831: printf("\n");
! 28832: }
! 28833: function_tests++;
! 28834:
! 28835: return(test_ret);
! 28836: }
! 28837:
! 28838:
! 28839: static int
! 28840: test_xmlRegisterDefaultOutputCallbacks(void) {
! 28841: int test_ret = 0;
! 28842:
! 28843: #if defined(LIBXML_OUTPUT_ENABLED)
! 28844: int mem_base;
! 28845:
! 28846: mem_base = xmlMemBlocks();
! 28847:
! 28848: xmlRegisterDefaultOutputCallbacks();
! 28849: call_tests++;
! 28850: xmlResetLastError();
! 28851: if (mem_base != xmlMemBlocks()) {
! 28852: printf("Leak of %d blocks found in xmlRegisterDefaultOutputCallbacks",
! 28853: xmlMemBlocks() - mem_base);
! 28854: test_ret++;
! 28855: printf("\n");
! 28856: }
! 28857: function_tests++;
! 28858: #endif
! 28859:
! 28860: return(test_ret);
! 28861: }
! 28862:
! 28863:
! 28864: static int
! 28865: test_xmlRegisterHTTPPostCallbacks(void) {
! 28866: int test_ret = 0;
! 28867:
! 28868: #if defined(LIBXML_OUTPUT_ENABLED) && defined(LIBXML_HTTP_ENABLED)
! 28869: int mem_base;
! 28870:
! 28871: mem_base = xmlMemBlocks();
! 28872:
! 28873: xmlRegisterHTTPPostCallbacks();
! 28874: call_tests++;
! 28875: xmlResetLastError();
! 28876: if (mem_base != xmlMemBlocks()) {
! 28877: printf("Leak of %d blocks found in xmlRegisterHTTPPostCallbacks",
! 28878: xmlMemBlocks() - mem_base);
! 28879: test_ret++;
! 28880: printf("\n");
! 28881: }
! 28882: function_tests++;
! 28883: #endif
! 28884:
! 28885: return(test_ret);
! 28886: }
! 28887:
! 28888: static int
! 28889: test_xmlIO(void) {
! 28890: int test_ret = 0;
! 28891:
! 28892: if (quiet == 0) printf("Testing xmlIO : 39 of 48 functions ...\n");
! 28893: test_ret += test_xmlAllocOutputBuffer();
! 28894: test_ret += test_xmlAllocParserInputBuffer();
! 28895: test_ret += test_xmlCheckFilename();
! 28896: test_ret += test_xmlCheckHTTPInput();
! 28897: test_ret += test_xmlCleanupInputCallbacks();
! 28898: test_ret += test_xmlCleanupOutputCallbacks();
! 28899: test_ret += test_xmlFileClose();
! 28900: test_ret += test_xmlFileMatch();
! 28901: test_ret += test_xmlFileOpen();
! 28902: test_ret += test_xmlFileRead();
! 28903: test_ret += test_xmlIOFTPClose();
! 28904: test_ret += test_xmlIOFTPMatch();
! 28905: test_ret += test_xmlIOFTPOpen();
! 28906: test_ret += test_xmlIOFTPRead();
! 28907: test_ret += test_xmlIOHTTPClose();
! 28908: test_ret += test_xmlIOHTTPMatch();
! 28909: test_ret += test_xmlIOHTTPOpen();
! 28910: test_ret += test_xmlIOHTTPRead();
! 28911: test_ret += test_xmlNoNetExternalEntityLoader();
! 28912: test_ret += test_xmlNormalizeWindowsPath();
! 28913: test_ret += test_xmlOutputBufferCreateBuffer();
! 28914: test_ret += test_xmlOutputBufferCreateFd();
! 28915: test_ret += test_xmlOutputBufferCreateFile();
! 28916: test_ret += test_xmlOutputBufferCreateFilename();
! 28917: test_ret += test_xmlOutputBufferFlush();
! 28918: test_ret += test_xmlOutputBufferWrite();
! 28919: test_ret += test_xmlOutputBufferWriteEscape();
! 28920: test_ret += test_xmlOutputBufferWriteString();
! 28921: test_ret += test_xmlParserGetDirectory();
! 28922: test_ret += test_xmlParserInputBufferCreateFd();
! 28923: test_ret += test_xmlParserInputBufferCreateFile();
! 28924: test_ret += test_xmlParserInputBufferCreateFilename();
! 28925: test_ret += test_xmlParserInputBufferCreateMem();
! 28926: test_ret += test_xmlParserInputBufferCreateStatic();
! 28927: test_ret += test_xmlParserInputBufferGrow();
! 28928: test_ret += test_xmlParserInputBufferPush();
! 28929: test_ret += test_xmlParserInputBufferRead();
! 28930: test_ret += test_xmlPopInputCallbacks();
! 28931: test_ret += test_xmlRegisterDefaultInputCallbacks();
! 28932: test_ret += test_xmlRegisterDefaultOutputCallbacks();
! 28933: test_ret += test_xmlRegisterHTTPPostCallbacks();
! 28934:
! 28935: if (test_ret != 0)
! 28936: printf("Module xmlIO: %d errors\n", test_ret);
! 28937: return(test_ret);
! 28938: }
! 28939: #ifdef LIBXML_AUTOMATA_ENABLED
! 28940:
! 28941: #define gen_nb_xmlAutomataPtr 1
! 28942: static xmlAutomataPtr gen_xmlAutomataPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 28943: return(NULL);
! 28944: }
! 28945: static void des_xmlAutomataPtr(int no ATTRIBUTE_UNUSED, xmlAutomataPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 28946: }
! 28947: #endif
! 28948:
! 28949:
! 28950: static int
! 28951: test_xmlAutomataCompile(void) {
! 28952: int test_ret = 0;
! 28953:
! 28954:
! 28955: /* missing type support */
! 28956: return(test_ret);
! 28957: }
! 28958:
! 28959:
! 28960: static int
! 28961: test_xmlAutomataGetInitState(void) {
! 28962: int test_ret = 0;
! 28963:
! 28964:
! 28965: /* missing type support */
! 28966: return(test_ret);
! 28967: }
! 28968:
! 28969:
! 28970: static int
! 28971: test_xmlAutomataIsDeterminist(void) {
! 28972: int test_ret = 0;
! 28973:
! 28974: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED)
! 28975: int mem_base;
! 28976: int ret_val;
! 28977: xmlAutomataPtr am; /* an automata */
! 28978: int n_am;
! 28979:
! 28980: for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) {
! 28981: mem_base = xmlMemBlocks();
! 28982: am = gen_xmlAutomataPtr(n_am, 0);
! 28983:
! 28984: ret_val = xmlAutomataIsDeterminist(am);
! 28985: desret_int(ret_val);
! 28986: call_tests++;
! 28987: des_xmlAutomataPtr(n_am, am, 0);
! 28988: xmlResetLastError();
! 28989: if (mem_base != xmlMemBlocks()) {
! 28990: printf("Leak of %d blocks found in xmlAutomataIsDeterminist",
! 28991: xmlMemBlocks() - mem_base);
! 28992: test_ret++;
! 28993: printf(" %d", n_am);
! 28994: printf("\n");
! 28995: }
! 28996: }
! 28997: function_tests++;
! 28998: #endif
! 28999:
! 29000: return(test_ret);
! 29001: }
! 29002:
! 29003: #ifdef LIBXML_AUTOMATA_ENABLED
! 29004:
! 29005: #define gen_nb_xmlAutomataStatePtr 1
! 29006: static xmlAutomataStatePtr gen_xmlAutomataStatePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 29007: return(NULL);
! 29008: }
! 29009: static void des_xmlAutomataStatePtr(int no ATTRIBUTE_UNUSED, xmlAutomataStatePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 29010: }
! 29011: #endif
! 29012:
! 29013:
! 29014: static int
! 29015: test_xmlAutomataNewAllTrans(void) {
! 29016: int test_ret = 0;
! 29017:
! 29018:
! 29019: /* missing type support */
! 29020: return(test_ret);
! 29021: }
! 29022:
! 29023:
! 29024: static int
! 29025: test_xmlAutomataNewCountTrans(void) {
! 29026: int test_ret = 0;
! 29027:
! 29028:
! 29029: /* missing type support */
! 29030: return(test_ret);
! 29031: }
! 29032:
! 29033:
! 29034: static int
! 29035: test_xmlAutomataNewCountTrans2(void) {
! 29036: int test_ret = 0;
! 29037:
! 29038:
! 29039: /* missing type support */
! 29040: return(test_ret);
! 29041: }
! 29042:
! 29043:
! 29044: static int
! 29045: test_xmlAutomataNewCountedTrans(void) {
! 29046: int test_ret = 0;
! 29047:
! 29048:
! 29049: /* missing type support */
! 29050: return(test_ret);
! 29051: }
! 29052:
! 29053:
! 29054: static int
! 29055: test_xmlAutomataNewCounter(void) {
! 29056: int test_ret = 0;
! 29057:
! 29058: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED)
! 29059: int mem_base;
! 29060: int ret_val;
! 29061: xmlAutomataPtr am; /* an automata */
! 29062: int n_am;
! 29063: int min; /* the minimal value on the counter */
! 29064: int n_min;
! 29065: int max; /* the maximal value on the counter */
! 29066: int n_max;
! 29067:
! 29068: for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) {
! 29069: for (n_min = 0;n_min < gen_nb_int;n_min++) {
! 29070: for (n_max = 0;n_max < gen_nb_int;n_max++) {
! 29071: mem_base = xmlMemBlocks();
! 29072: am = gen_xmlAutomataPtr(n_am, 0);
! 29073: min = gen_int(n_min, 1);
! 29074: max = gen_int(n_max, 2);
! 29075:
! 29076: ret_val = xmlAutomataNewCounter(am, min, max);
! 29077: desret_int(ret_val);
! 29078: call_tests++;
! 29079: des_xmlAutomataPtr(n_am, am, 0);
! 29080: des_int(n_min, min, 1);
! 29081: des_int(n_max, max, 2);
! 29082: xmlResetLastError();
! 29083: if (mem_base != xmlMemBlocks()) {
! 29084: printf("Leak of %d blocks found in xmlAutomataNewCounter",
! 29085: xmlMemBlocks() - mem_base);
! 29086: test_ret++;
! 29087: printf(" %d", n_am);
! 29088: printf(" %d", n_min);
! 29089: printf(" %d", n_max);
! 29090: printf("\n");
! 29091: }
! 29092: }
! 29093: }
! 29094: }
! 29095: function_tests++;
! 29096: #endif
! 29097:
! 29098: return(test_ret);
! 29099: }
! 29100:
! 29101:
! 29102: static int
! 29103: test_xmlAutomataNewCounterTrans(void) {
! 29104: int test_ret = 0;
! 29105:
! 29106:
! 29107: /* missing type support */
! 29108: return(test_ret);
! 29109: }
! 29110:
! 29111:
! 29112: static int
! 29113: test_xmlAutomataNewEpsilon(void) {
! 29114: int test_ret = 0;
! 29115:
! 29116:
! 29117: /* missing type support */
! 29118: return(test_ret);
! 29119: }
! 29120:
! 29121:
! 29122: static int
! 29123: test_xmlAutomataNewNegTrans(void) {
! 29124: int test_ret = 0;
! 29125:
! 29126:
! 29127: /* missing type support */
! 29128: return(test_ret);
! 29129: }
! 29130:
! 29131:
! 29132: static int
! 29133: test_xmlAutomataNewOnceTrans(void) {
! 29134: int test_ret = 0;
! 29135:
! 29136:
! 29137: /* missing type support */
! 29138: return(test_ret);
! 29139: }
! 29140:
! 29141:
! 29142: static int
! 29143: test_xmlAutomataNewOnceTrans2(void) {
! 29144: int test_ret = 0;
! 29145:
! 29146:
! 29147: /* missing type support */
! 29148: return(test_ret);
! 29149: }
! 29150:
! 29151:
! 29152: static int
! 29153: test_xmlAutomataNewState(void) {
! 29154: int test_ret = 0;
! 29155:
! 29156:
! 29157: /* missing type support */
! 29158: return(test_ret);
! 29159: }
! 29160:
! 29161:
! 29162: static int
! 29163: test_xmlAutomataNewTransition(void) {
! 29164: int test_ret = 0;
! 29165:
! 29166:
! 29167: /* missing type support */
! 29168: return(test_ret);
! 29169: }
! 29170:
! 29171:
! 29172: static int
! 29173: test_xmlAutomataNewTransition2(void) {
! 29174: int test_ret = 0;
! 29175:
! 29176:
! 29177: /* missing type support */
! 29178: return(test_ret);
! 29179: }
! 29180:
! 29181:
! 29182: static int
! 29183: test_xmlAutomataSetFinalState(void) {
! 29184: int test_ret = 0;
! 29185:
! 29186: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED)
! 29187: int mem_base;
! 29188: int ret_val;
! 29189: xmlAutomataPtr am; /* an automata */
! 29190: int n_am;
! 29191: xmlAutomataStatePtr state; /* a state in this automata */
! 29192: int n_state;
! 29193:
! 29194: for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) {
! 29195: for (n_state = 0;n_state < gen_nb_xmlAutomataStatePtr;n_state++) {
! 29196: mem_base = xmlMemBlocks();
! 29197: am = gen_xmlAutomataPtr(n_am, 0);
! 29198: state = gen_xmlAutomataStatePtr(n_state, 1);
! 29199:
! 29200: ret_val = xmlAutomataSetFinalState(am, state);
! 29201: desret_int(ret_val);
! 29202: call_tests++;
! 29203: des_xmlAutomataPtr(n_am, am, 0);
! 29204: des_xmlAutomataStatePtr(n_state, state, 1);
! 29205: xmlResetLastError();
! 29206: if (mem_base != xmlMemBlocks()) {
! 29207: printf("Leak of %d blocks found in xmlAutomataSetFinalState",
! 29208: xmlMemBlocks() - mem_base);
! 29209: test_ret++;
! 29210: printf(" %d", n_am);
! 29211: printf(" %d", n_state);
! 29212: printf("\n");
! 29213: }
! 29214: }
! 29215: }
! 29216: function_tests++;
! 29217: #endif
! 29218:
! 29219: return(test_ret);
! 29220: }
! 29221:
! 29222:
! 29223: static int
! 29224: test_xmlNewAutomata(void) {
! 29225: int test_ret = 0;
! 29226:
! 29227:
! 29228: /* missing type support */
! 29229: return(test_ret);
! 29230: }
! 29231:
! 29232: static int
! 29233: test_xmlautomata(void) {
! 29234: int test_ret = 0;
! 29235:
! 29236: if (quiet == 0) printf("Testing xmlautomata : 3 of 19 functions ...\n");
! 29237: test_ret += test_xmlAutomataCompile();
! 29238: test_ret += test_xmlAutomataGetInitState();
! 29239: test_ret += test_xmlAutomataIsDeterminist();
! 29240: test_ret += test_xmlAutomataNewAllTrans();
! 29241: test_ret += test_xmlAutomataNewCountTrans();
! 29242: test_ret += test_xmlAutomataNewCountTrans2();
! 29243: test_ret += test_xmlAutomataNewCountedTrans();
! 29244: test_ret += test_xmlAutomataNewCounter();
! 29245: test_ret += test_xmlAutomataNewCounterTrans();
! 29246: test_ret += test_xmlAutomataNewEpsilon();
! 29247: test_ret += test_xmlAutomataNewNegTrans();
! 29248: test_ret += test_xmlAutomataNewOnceTrans();
! 29249: test_ret += test_xmlAutomataNewOnceTrans2();
! 29250: test_ret += test_xmlAutomataNewState();
! 29251: test_ret += test_xmlAutomataNewTransition();
! 29252: test_ret += test_xmlAutomataNewTransition2();
! 29253: test_ret += test_xmlAutomataSetFinalState();
! 29254: test_ret += test_xmlNewAutomata();
! 29255:
! 29256: if (test_ret != 0)
! 29257: printf("Module xmlautomata: %d errors\n", test_ret);
! 29258: return(test_ret);
! 29259: }
! 29260:
! 29261: #define gen_nb_xmlGenericErrorFunc_ptr 1
! 29262: static xmlGenericErrorFunc * gen_xmlGenericErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 29263: return(NULL);
! 29264: }
! 29265: static void des_xmlGenericErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlGenericErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 29266: }
! 29267:
! 29268: static int
! 29269: test_initGenericErrorDefaultFunc(void) {
! 29270: int test_ret = 0;
! 29271:
! 29272: int mem_base;
! 29273: xmlGenericErrorFunc * handler; /* the handler */
! 29274: int n_handler;
! 29275:
! 29276: for (n_handler = 0;n_handler < gen_nb_xmlGenericErrorFunc_ptr;n_handler++) {
! 29277: mem_base = xmlMemBlocks();
! 29278: handler = gen_xmlGenericErrorFunc_ptr(n_handler, 0);
! 29279:
! 29280: initGenericErrorDefaultFunc(handler);
! 29281: call_tests++;
! 29282: des_xmlGenericErrorFunc_ptr(n_handler, handler, 0);
! 29283: xmlResetLastError();
! 29284: if (mem_base != xmlMemBlocks()) {
! 29285: printf("Leak of %d blocks found in initGenericErrorDefaultFunc",
! 29286: xmlMemBlocks() - mem_base);
! 29287: test_ret++;
! 29288: printf(" %d", n_handler);
! 29289: printf("\n");
! 29290: }
! 29291: }
! 29292: function_tests++;
! 29293:
! 29294: return(test_ret);
! 29295: }
! 29296:
! 29297:
! 29298: #define gen_nb_xmlErrorPtr 1
! 29299: static xmlErrorPtr gen_xmlErrorPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 29300: return(NULL);
! 29301: }
! 29302: static void des_xmlErrorPtr(int no ATTRIBUTE_UNUSED, xmlErrorPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 29303: }
! 29304:
! 29305: static int
! 29306: test_xmlCopyError(void) {
! 29307: int test_ret = 0;
! 29308:
! 29309: int mem_base;
! 29310: int ret_val;
! 29311: xmlErrorPtr from; /* a source error */
! 29312: int n_from;
! 29313: xmlErrorPtr to; /* a target error */
! 29314: int n_to;
! 29315:
! 29316: for (n_from = 0;n_from < gen_nb_xmlErrorPtr;n_from++) {
! 29317: for (n_to = 0;n_to < gen_nb_xmlErrorPtr;n_to++) {
! 29318: mem_base = xmlMemBlocks();
! 29319: from = gen_xmlErrorPtr(n_from, 0);
! 29320: to = gen_xmlErrorPtr(n_to, 1);
! 29321:
! 29322: ret_val = xmlCopyError(from, to);
! 29323: desret_int(ret_val);
! 29324: call_tests++;
! 29325: des_xmlErrorPtr(n_from, from, 0);
! 29326: des_xmlErrorPtr(n_to, to, 1);
! 29327: xmlResetLastError();
! 29328: if (mem_base != xmlMemBlocks()) {
! 29329: printf("Leak of %d blocks found in xmlCopyError",
! 29330: xmlMemBlocks() - mem_base);
! 29331: test_ret++;
! 29332: printf(" %d", n_from);
! 29333: printf(" %d", n_to);
! 29334: printf("\n");
! 29335: }
! 29336: }
! 29337: }
! 29338: function_tests++;
! 29339:
! 29340: return(test_ret);
! 29341: }
! 29342:
! 29343:
! 29344: static int
! 29345: test_xmlCtxtGetLastError(void) {
! 29346: int test_ret = 0;
! 29347:
! 29348:
! 29349: /* missing type support */
! 29350: return(test_ret);
! 29351: }
! 29352:
! 29353:
! 29354: static int
! 29355: test_xmlCtxtResetLastError(void) {
! 29356: int test_ret = 0;
! 29357:
! 29358: int mem_base;
! 29359: void * ctx; /* an XML parser context */
! 29360: int n_ctx;
! 29361:
! 29362: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
! 29363: mem_base = xmlMemBlocks();
! 29364: ctx = gen_void_ptr(n_ctx, 0);
! 29365:
! 29366: xmlCtxtResetLastError(ctx);
! 29367: call_tests++;
! 29368: des_void_ptr(n_ctx, ctx, 0);
! 29369: xmlResetLastError();
! 29370: if (mem_base != xmlMemBlocks()) {
! 29371: printf("Leak of %d blocks found in xmlCtxtResetLastError",
! 29372: xmlMemBlocks() - mem_base);
! 29373: test_ret++;
! 29374: printf(" %d", n_ctx);
! 29375: printf("\n");
! 29376: }
! 29377: }
! 29378: function_tests++;
! 29379:
! 29380: return(test_ret);
! 29381: }
! 29382:
! 29383:
! 29384: static int
! 29385: test_xmlGetLastError(void) {
! 29386: int test_ret = 0;
! 29387:
! 29388:
! 29389: /* missing type support */
! 29390: return(test_ret);
! 29391: }
! 29392:
! 29393:
! 29394: static int
! 29395: test_xmlParserError(void) {
! 29396: int test_ret = 0;
! 29397:
! 29398:
! 29399: /* missing type support */
! 29400: return(test_ret);
! 29401: }
! 29402:
! 29403:
! 29404: static int
! 29405: test_xmlParserPrintFileContext(void) {
! 29406: int test_ret = 0;
! 29407:
! 29408: int mem_base;
! 29409: xmlParserInputPtr input; /* an xmlParserInputPtr input */
! 29410: int n_input;
! 29411:
! 29412: for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
! 29413: mem_base = xmlMemBlocks();
! 29414: input = gen_xmlParserInputPtr(n_input, 0);
! 29415:
! 29416: xmlParserPrintFileContext(input);
! 29417: call_tests++;
! 29418: des_xmlParserInputPtr(n_input, input, 0);
! 29419: xmlResetLastError();
! 29420: if (mem_base != xmlMemBlocks()) {
! 29421: printf("Leak of %d blocks found in xmlParserPrintFileContext",
! 29422: xmlMemBlocks() - mem_base);
! 29423: test_ret++;
! 29424: printf(" %d", n_input);
! 29425: printf("\n");
! 29426: }
! 29427: }
! 29428: function_tests++;
! 29429:
! 29430: return(test_ret);
! 29431: }
! 29432:
! 29433:
! 29434: static int
! 29435: test_xmlParserPrintFileInfo(void) {
! 29436: int test_ret = 0;
! 29437:
! 29438: int mem_base;
! 29439: xmlParserInputPtr input; /* an xmlParserInputPtr input */
! 29440: int n_input;
! 29441:
! 29442: for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
! 29443: mem_base = xmlMemBlocks();
! 29444: input = gen_xmlParserInputPtr(n_input, 0);
! 29445:
! 29446: xmlParserPrintFileInfo(input);
! 29447: call_tests++;
! 29448: des_xmlParserInputPtr(n_input, input, 0);
! 29449: xmlResetLastError();
! 29450: if (mem_base != xmlMemBlocks()) {
! 29451: printf("Leak of %d blocks found in xmlParserPrintFileInfo",
! 29452: xmlMemBlocks() - mem_base);
! 29453: test_ret++;
! 29454: printf(" %d", n_input);
! 29455: printf("\n");
! 29456: }
! 29457: }
! 29458: function_tests++;
! 29459:
! 29460: return(test_ret);
! 29461: }
! 29462:
! 29463:
! 29464: static int
! 29465: test_xmlParserValidityError(void) {
! 29466: int test_ret = 0;
! 29467:
! 29468:
! 29469: /* missing type support */
! 29470: return(test_ret);
! 29471: }
! 29472:
! 29473:
! 29474: static int
! 29475: test_xmlParserValidityWarning(void) {
! 29476: int test_ret = 0;
! 29477:
! 29478:
! 29479: /* missing type support */
! 29480: return(test_ret);
! 29481: }
! 29482:
! 29483:
! 29484: static int
! 29485: test_xmlParserWarning(void) {
! 29486: int test_ret = 0;
! 29487:
! 29488:
! 29489: /* missing type support */
! 29490: return(test_ret);
! 29491: }
! 29492:
! 29493:
! 29494: static int
! 29495: test_xmlResetError(void) {
! 29496: int test_ret = 0;
! 29497:
! 29498: int mem_base;
! 29499: xmlErrorPtr err; /* pointer to the error. */
! 29500: int n_err;
! 29501:
! 29502: for (n_err = 0;n_err < gen_nb_xmlErrorPtr;n_err++) {
! 29503: mem_base = xmlMemBlocks();
! 29504: err = gen_xmlErrorPtr(n_err, 0);
! 29505:
! 29506: xmlResetError(err);
! 29507: call_tests++;
! 29508: des_xmlErrorPtr(n_err, err, 0);
! 29509: xmlResetLastError();
! 29510: if (mem_base != xmlMemBlocks()) {
! 29511: printf("Leak of %d blocks found in xmlResetError",
! 29512: xmlMemBlocks() - mem_base);
! 29513: test_ret++;
! 29514: printf(" %d", n_err);
! 29515: printf("\n");
! 29516: }
! 29517: }
! 29518: function_tests++;
! 29519:
! 29520: return(test_ret);
! 29521: }
! 29522:
! 29523:
! 29524: static int
! 29525: test_xmlResetLastError(void) {
! 29526: int test_ret = 0;
! 29527:
! 29528:
! 29529:
! 29530: xmlResetLastError();
! 29531: call_tests++;
! 29532: xmlResetLastError();
! 29533: function_tests++;
! 29534:
! 29535: return(test_ret);
! 29536: }
! 29537:
! 29538:
! 29539: static int
! 29540: test_xmlSetGenericErrorFunc(void) {
! 29541: int test_ret = 0;
! 29542:
! 29543:
! 29544: /* missing type support */
! 29545: return(test_ret);
! 29546: }
! 29547:
! 29548:
! 29549: static int
! 29550: test_xmlSetStructuredErrorFunc(void) {
! 29551: int test_ret = 0;
! 29552:
! 29553:
! 29554: /* missing type support */
! 29555: return(test_ret);
! 29556: }
! 29557:
! 29558: static int
! 29559: test_xmlerror(void) {
! 29560: int test_ret = 0;
! 29561:
! 29562: if (quiet == 0) printf("Testing xmlerror : 7 of 15 functions ...\n");
! 29563: test_ret += test_initGenericErrorDefaultFunc();
! 29564: test_ret += test_xmlCopyError();
! 29565: test_ret += test_xmlCtxtGetLastError();
! 29566: test_ret += test_xmlCtxtResetLastError();
! 29567: test_ret += test_xmlGetLastError();
! 29568: test_ret += test_xmlParserError();
! 29569: test_ret += test_xmlParserPrintFileContext();
! 29570: test_ret += test_xmlParserPrintFileInfo();
! 29571: test_ret += test_xmlParserValidityError();
! 29572: test_ret += test_xmlParserValidityWarning();
! 29573: test_ret += test_xmlParserWarning();
! 29574: test_ret += test_xmlResetError();
! 29575: test_ret += test_xmlResetLastError();
! 29576: test_ret += test_xmlSetGenericErrorFunc();
! 29577: test_ret += test_xmlSetStructuredErrorFunc();
! 29578:
! 29579: if (test_ret != 0)
! 29580: printf("Module xmlerror: %d errors\n", test_ret);
! 29581: return(test_ret);
! 29582: }
! 29583: #ifdef LIBXML_MODULES_ENABLED
! 29584:
! 29585: #define gen_nb_xmlModulePtr 1
! 29586: static xmlModulePtr gen_xmlModulePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 29587: return(NULL);
! 29588: }
! 29589: static void des_xmlModulePtr(int no ATTRIBUTE_UNUSED, xmlModulePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 29590: }
! 29591: #endif
! 29592:
! 29593:
! 29594: static int
! 29595: test_xmlModuleClose(void) {
! 29596: int test_ret = 0;
! 29597:
! 29598: #if defined(LIBXML_MODULES_ENABLED)
! 29599: int mem_base;
! 29600: int ret_val;
! 29601: xmlModulePtr module; /* the module handle */
! 29602: int n_module;
! 29603:
! 29604: for (n_module = 0;n_module < gen_nb_xmlModulePtr;n_module++) {
! 29605: mem_base = xmlMemBlocks();
! 29606: module = gen_xmlModulePtr(n_module, 0);
! 29607:
! 29608: ret_val = xmlModuleClose(module);
! 29609: desret_int(ret_val);
! 29610: call_tests++;
! 29611: des_xmlModulePtr(n_module, module, 0);
! 29612: xmlResetLastError();
! 29613: if (mem_base != xmlMemBlocks()) {
! 29614: printf("Leak of %d blocks found in xmlModuleClose",
! 29615: xmlMemBlocks() - mem_base);
! 29616: test_ret++;
! 29617: printf(" %d", n_module);
! 29618: printf("\n");
! 29619: }
! 29620: }
! 29621: function_tests++;
! 29622: #endif
! 29623:
! 29624: return(test_ret);
! 29625: }
! 29626:
! 29627:
! 29628: static int
! 29629: test_xmlModuleOpen(void) {
! 29630: int test_ret = 0;
! 29631:
! 29632:
! 29633: /* missing type support */
! 29634: return(test_ret);
! 29635: }
! 29636:
! 29637:
! 29638: static int
! 29639: test_xmlModuleSymbol(void) {
! 29640: int test_ret = 0;
! 29641:
! 29642: #if defined(LIBXML_MODULES_ENABLED)
! 29643: int mem_base;
! 29644: int ret_val;
! 29645: xmlModulePtr module; /* the module */
! 29646: int n_module;
! 29647: char * name; /* the name of the symbol */
! 29648: int n_name;
! 29649: void ** symbol; /* the resulting symbol address */
! 29650: int n_symbol;
! 29651:
! 29652: for (n_module = 0;n_module < gen_nb_xmlModulePtr;n_module++) {
! 29653: for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
! 29654: for (n_symbol = 0;n_symbol < gen_nb_void_ptr_ptr;n_symbol++) {
! 29655: mem_base = xmlMemBlocks();
! 29656: module = gen_xmlModulePtr(n_module, 0);
! 29657: name = gen_const_char_ptr(n_name, 1);
! 29658: symbol = gen_void_ptr_ptr(n_symbol, 2);
! 29659:
! 29660: ret_val = xmlModuleSymbol(module, (const char *)name, symbol);
! 29661: desret_int(ret_val);
! 29662: call_tests++;
! 29663: des_xmlModulePtr(n_module, module, 0);
! 29664: des_const_char_ptr(n_name, (const char *)name, 1);
! 29665: des_void_ptr_ptr(n_symbol, symbol, 2);
! 29666: xmlResetLastError();
! 29667: if (mem_base != xmlMemBlocks()) {
! 29668: printf("Leak of %d blocks found in xmlModuleSymbol",
! 29669: xmlMemBlocks() - mem_base);
! 29670: test_ret++;
! 29671: printf(" %d", n_module);
! 29672: printf(" %d", n_name);
! 29673: printf(" %d", n_symbol);
! 29674: printf("\n");
! 29675: }
! 29676: }
! 29677: }
! 29678: }
! 29679: function_tests++;
! 29680: #endif
! 29681:
! 29682: return(test_ret);
! 29683: }
! 29684:
! 29685: static int
! 29686: test_xmlmodule(void) {
! 29687: int test_ret = 0;
! 29688:
! 29689: if (quiet == 0) printf("Testing xmlmodule : 2 of 4 functions ...\n");
! 29690: test_ret += test_xmlModuleClose();
! 29691: test_ret += test_xmlModuleOpen();
! 29692: test_ret += test_xmlModuleSymbol();
! 29693:
! 29694: if (test_ret != 0)
! 29695: printf("Module xmlmodule: %d errors\n", test_ret);
! 29696: return(test_ret);
! 29697: }
! 29698:
! 29699: static int
! 29700: test_xmlNewTextReader(void) {
! 29701: int test_ret = 0;
! 29702:
! 29703: #if defined(LIBXML_READER_ENABLED)
! 29704: int mem_base;
! 29705: xmlTextReaderPtr ret_val;
! 29706: xmlParserInputBufferPtr input; /* the xmlParserInputBufferPtr used to read data */
! 29707: int n_input;
! 29708: const char * URI; /* the URI information for the source if available */
! 29709: int n_URI;
! 29710:
! 29711: for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
! 29712: for (n_URI = 0;n_URI < gen_nb_filepath;n_URI++) {
! 29713: mem_base = xmlMemBlocks();
! 29714: input = gen_xmlParserInputBufferPtr(n_input, 0);
! 29715: URI = gen_filepath(n_URI, 1);
! 29716:
! 29717: ret_val = xmlNewTextReader(input, URI);
! 29718: desret_xmlTextReaderPtr(ret_val);
! 29719: call_tests++;
! 29720: des_xmlParserInputBufferPtr(n_input, input, 0);
! 29721: des_filepath(n_URI, URI, 1);
! 29722: xmlResetLastError();
! 29723: if (mem_base != xmlMemBlocks()) {
! 29724: printf("Leak of %d blocks found in xmlNewTextReader",
! 29725: xmlMemBlocks() - mem_base);
! 29726: test_ret++;
! 29727: printf(" %d", n_input);
! 29728: printf(" %d", n_URI);
! 29729: printf("\n");
! 29730: }
! 29731: }
! 29732: }
! 29733: function_tests++;
! 29734: #endif
! 29735:
! 29736: return(test_ret);
! 29737: }
! 29738:
! 29739:
! 29740: static int
! 29741: test_xmlNewTextReaderFilename(void) {
! 29742: int test_ret = 0;
! 29743:
! 29744: #if defined(LIBXML_READER_ENABLED)
! 29745: int mem_base;
! 29746: xmlTextReaderPtr ret_val;
! 29747: const char * URI; /* the URI of the resource to process */
! 29748: int n_URI;
! 29749:
! 29750: for (n_URI = 0;n_URI < gen_nb_filepath;n_URI++) {
! 29751: mem_base = xmlMemBlocks();
! 29752: URI = gen_filepath(n_URI, 0);
! 29753:
! 29754: ret_val = xmlNewTextReaderFilename(URI);
! 29755: desret_xmlTextReaderPtr(ret_val);
! 29756: call_tests++;
! 29757: des_filepath(n_URI, URI, 0);
! 29758: xmlResetLastError();
! 29759: if (mem_base != xmlMemBlocks()) {
! 29760: printf("Leak of %d blocks found in xmlNewTextReaderFilename",
! 29761: xmlMemBlocks() - mem_base);
! 29762: test_ret++;
! 29763: printf(" %d", n_URI);
! 29764: printf("\n");
! 29765: }
! 29766: }
! 29767: function_tests++;
! 29768: #endif
! 29769:
! 29770: return(test_ret);
! 29771: }
! 29772:
! 29773:
! 29774: static int
! 29775: test_xmlReaderForDoc(void) {
! 29776: int test_ret = 0;
! 29777:
! 29778: #if defined(LIBXML_READER_ENABLED)
! 29779: int mem_base;
! 29780: xmlTextReaderPtr ret_val;
! 29781: xmlChar * cur; /* a pointer to a zero terminated string */
! 29782: int n_cur;
! 29783: const char * URL; /* the base URL to use for the document */
! 29784: int n_URL;
! 29785: char * encoding; /* the document encoding, or NULL */
! 29786: int n_encoding;
! 29787: int options; /* a combination of xmlParserOption */
! 29788: int n_options;
! 29789:
! 29790: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
! 29791: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 29792: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 29793: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
! 29794: mem_base = xmlMemBlocks();
! 29795: cur = gen_const_xmlChar_ptr(n_cur, 0);
! 29796: URL = gen_filepath(n_URL, 1);
! 29797: encoding = gen_const_char_ptr(n_encoding, 2);
! 29798: options = gen_parseroptions(n_options, 3);
! 29799:
! 29800: ret_val = xmlReaderForDoc((const xmlChar *)cur, URL, (const char *)encoding, options);
! 29801: desret_xmlTextReaderPtr(ret_val);
! 29802: call_tests++;
! 29803: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
! 29804: des_filepath(n_URL, URL, 1);
! 29805: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
! 29806: des_parseroptions(n_options, options, 3);
! 29807: xmlResetLastError();
! 29808: if (mem_base != xmlMemBlocks()) {
! 29809: printf("Leak of %d blocks found in xmlReaderForDoc",
! 29810: xmlMemBlocks() - mem_base);
! 29811: test_ret++;
! 29812: printf(" %d", n_cur);
! 29813: printf(" %d", n_URL);
! 29814: printf(" %d", n_encoding);
! 29815: printf(" %d", n_options);
! 29816: printf("\n");
! 29817: }
! 29818: }
! 29819: }
! 29820: }
! 29821: }
! 29822: function_tests++;
! 29823: #endif
! 29824:
! 29825: return(test_ret);
! 29826: }
! 29827:
! 29828:
! 29829: static int
! 29830: test_xmlReaderForFile(void) {
! 29831: int test_ret = 0;
! 29832:
! 29833: #if defined(LIBXML_READER_ENABLED)
! 29834: int mem_base;
! 29835: xmlTextReaderPtr ret_val;
! 29836: const char * filename; /* a file or URL */
! 29837: int n_filename;
! 29838: char * encoding; /* the document encoding, or NULL */
! 29839: int n_encoding;
! 29840: int options; /* a combination of xmlParserOption */
! 29841: int n_options;
! 29842:
! 29843: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 29844: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 29845: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
! 29846: mem_base = xmlMemBlocks();
! 29847: filename = gen_filepath(n_filename, 0);
! 29848: encoding = gen_const_char_ptr(n_encoding, 1);
! 29849: options = gen_parseroptions(n_options, 2);
! 29850:
! 29851: ret_val = xmlReaderForFile(filename, (const char *)encoding, options);
! 29852: desret_xmlTextReaderPtr(ret_val);
! 29853: call_tests++;
! 29854: des_filepath(n_filename, filename, 0);
! 29855: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
! 29856: des_parseroptions(n_options, options, 2);
! 29857: xmlResetLastError();
! 29858: if (mem_base != xmlMemBlocks()) {
! 29859: printf("Leak of %d blocks found in xmlReaderForFile",
! 29860: xmlMemBlocks() - mem_base);
! 29861: test_ret++;
! 29862: printf(" %d", n_filename);
! 29863: printf(" %d", n_encoding);
! 29864: printf(" %d", n_options);
! 29865: printf("\n");
! 29866: }
! 29867: }
! 29868: }
! 29869: }
! 29870: function_tests++;
! 29871: #endif
! 29872:
! 29873: return(test_ret);
! 29874: }
! 29875:
! 29876:
! 29877: static int
! 29878: test_xmlReaderForMemory(void) {
! 29879: int test_ret = 0;
! 29880:
! 29881: #if defined(LIBXML_READER_ENABLED)
! 29882: int mem_base;
! 29883: xmlTextReaderPtr ret_val;
! 29884: char * buffer; /* a pointer to a char array */
! 29885: int n_buffer;
! 29886: int size; /* the size of the array */
! 29887: int n_size;
! 29888: const char * URL; /* the base URL to use for the document */
! 29889: int n_URL;
! 29890: char * encoding; /* the document encoding, or NULL */
! 29891: int n_encoding;
! 29892: int options; /* a combination of xmlParserOption */
! 29893: int n_options;
! 29894:
! 29895: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
! 29896: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 29897: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 29898: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 29899: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
! 29900: mem_base = xmlMemBlocks();
! 29901: buffer = gen_const_char_ptr(n_buffer, 0);
! 29902: size = gen_int(n_size, 1);
! 29903: URL = gen_filepath(n_URL, 2);
! 29904: encoding = gen_const_char_ptr(n_encoding, 3);
! 29905: options = gen_parseroptions(n_options, 4);
! 29906:
! 29907: ret_val = xmlReaderForMemory((const char *)buffer, size, URL, (const char *)encoding, options);
! 29908: desret_xmlTextReaderPtr(ret_val);
! 29909: call_tests++;
! 29910: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
! 29911: des_int(n_size, size, 1);
! 29912: des_filepath(n_URL, URL, 2);
! 29913: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
! 29914: des_parseroptions(n_options, options, 4);
! 29915: xmlResetLastError();
! 29916: if (mem_base != xmlMemBlocks()) {
! 29917: printf("Leak of %d blocks found in xmlReaderForMemory",
! 29918: xmlMemBlocks() - mem_base);
! 29919: test_ret++;
! 29920: printf(" %d", n_buffer);
! 29921: printf(" %d", n_size);
! 29922: printf(" %d", n_URL);
! 29923: printf(" %d", n_encoding);
! 29924: printf(" %d", n_options);
! 29925: printf("\n");
! 29926: }
! 29927: }
! 29928: }
! 29929: }
! 29930: }
! 29931: }
! 29932: function_tests++;
! 29933: #endif
! 29934:
! 29935: return(test_ret);
! 29936: }
! 29937:
! 29938:
! 29939: static int
! 29940: test_xmlReaderNewDoc(void) {
! 29941: int test_ret = 0;
! 29942:
! 29943: #if defined(LIBXML_READER_ENABLED)
! 29944: int mem_base;
! 29945: int ret_val;
! 29946: xmlTextReaderPtr reader; /* an XML reader */
! 29947: int n_reader;
! 29948: xmlChar * cur; /* a pointer to a zero terminated string */
! 29949: int n_cur;
! 29950: const char * URL; /* the base URL to use for the document */
! 29951: int n_URL;
! 29952: char * encoding; /* the document encoding, or NULL */
! 29953: int n_encoding;
! 29954: int options; /* a combination of xmlParserOption */
! 29955: int n_options;
! 29956:
! 29957: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 29958: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
! 29959: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 29960: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 29961: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
! 29962: mem_base = xmlMemBlocks();
! 29963: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 29964: cur = gen_const_xmlChar_ptr(n_cur, 1);
! 29965: URL = gen_filepath(n_URL, 2);
! 29966: encoding = gen_const_char_ptr(n_encoding, 3);
! 29967: options = gen_parseroptions(n_options, 4);
! 29968:
! 29969: ret_val = xmlReaderNewDoc(reader, (const xmlChar *)cur, URL, (const char *)encoding, options);
! 29970: desret_int(ret_val);
! 29971: call_tests++;
! 29972: des_xmlTextReaderPtr(n_reader, reader, 0);
! 29973: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
! 29974: des_filepath(n_URL, URL, 2);
! 29975: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
! 29976: des_parseroptions(n_options, options, 4);
! 29977: xmlResetLastError();
! 29978: if (mem_base != xmlMemBlocks()) {
! 29979: printf("Leak of %d blocks found in xmlReaderNewDoc",
! 29980: xmlMemBlocks() - mem_base);
! 29981: test_ret++;
! 29982: printf(" %d", n_reader);
! 29983: printf(" %d", n_cur);
! 29984: printf(" %d", n_URL);
! 29985: printf(" %d", n_encoding);
! 29986: printf(" %d", n_options);
! 29987: printf("\n");
! 29988: }
! 29989: }
! 29990: }
! 29991: }
! 29992: }
! 29993: }
! 29994: function_tests++;
! 29995: #endif
! 29996:
! 29997: return(test_ret);
! 29998: }
! 29999:
! 30000:
! 30001: static int
! 30002: test_xmlReaderNewFile(void) {
! 30003: int test_ret = 0;
! 30004:
! 30005: #if defined(LIBXML_READER_ENABLED)
! 30006: int mem_base;
! 30007: int ret_val;
! 30008: xmlTextReaderPtr reader; /* an XML reader */
! 30009: int n_reader;
! 30010: const char * filename; /* a file or URL */
! 30011: int n_filename;
! 30012: char * encoding; /* the document encoding, or NULL */
! 30013: int n_encoding;
! 30014: int options; /* a combination of xmlParserOption */
! 30015: int n_options;
! 30016:
! 30017: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30018: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 30019: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 30020: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
! 30021: mem_base = xmlMemBlocks();
! 30022: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30023: filename = gen_filepath(n_filename, 1);
! 30024: encoding = gen_const_char_ptr(n_encoding, 2);
! 30025: options = gen_parseroptions(n_options, 3);
! 30026:
! 30027: ret_val = xmlReaderNewFile(reader, filename, (const char *)encoding, options);
! 30028: desret_int(ret_val);
! 30029: call_tests++;
! 30030: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30031: des_filepath(n_filename, filename, 1);
! 30032: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
! 30033: des_parseroptions(n_options, options, 3);
! 30034: xmlResetLastError();
! 30035: if (mem_base != xmlMemBlocks()) {
! 30036: printf("Leak of %d blocks found in xmlReaderNewFile",
! 30037: xmlMemBlocks() - mem_base);
! 30038: test_ret++;
! 30039: printf(" %d", n_reader);
! 30040: printf(" %d", n_filename);
! 30041: printf(" %d", n_encoding);
! 30042: printf(" %d", n_options);
! 30043: printf("\n");
! 30044: }
! 30045: }
! 30046: }
! 30047: }
! 30048: }
! 30049: function_tests++;
! 30050: #endif
! 30051:
! 30052: return(test_ret);
! 30053: }
! 30054:
! 30055:
! 30056: static int
! 30057: test_xmlReaderNewMemory(void) {
! 30058: int test_ret = 0;
! 30059:
! 30060: #if defined(LIBXML_READER_ENABLED)
! 30061: int mem_base;
! 30062: int ret_val;
! 30063: xmlTextReaderPtr reader; /* an XML reader */
! 30064: int n_reader;
! 30065: char * buffer; /* a pointer to a char array */
! 30066: int n_buffer;
! 30067: int size; /* the size of the array */
! 30068: int n_size;
! 30069: const char * URL; /* the base URL to use for the document */
! 30070: int n_URL;
! 30071: char * encoding; /* the document encoding, or NULL */
! 30072: int n_encoding;
! 30073: int options; /* a combination of xmlParserOption */
! 30074: int n_options;
! 30075:
! 30076: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30077: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
! 30078: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 30079: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 30080: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 30081: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
! 30082: mem_base = xmlMemBlocks();
! 30083: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30084: buffer = gen_const_char_ptr(n_buffer, 1);
! 30085: size = gen_int(n_size, 2);
! 30086: URL = gen_filepath(n_URL, 3);
! 30087: encoding = gen_const_char_ptr(n_encoding, 4);
! 30088: options = gen_parseroptions(n_options, 5);
! 30089:
! 30090: ret_val = xmlReaderNewMemory(reader, (const char *)buffer, size, URL, (const char *)encoding, options);
! 30091: desret_int(ret_val);
! 30092: call_tests++;
! 30093: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30094: des_const_char_ptr(n_buffer, (const char *)buffer, 1);
! 30095: des_int(n_size, size, 2);
! 30096: des_filepath(n_URL, URL, 3);
! 30097: des_const_char_ptr(n_encoding, (const char *)encoding, 4);
! 30098: des_parseroptions(n_options, options, 5);
! 30099: xmlResetLastError();
! 30100: if (mem_base != xmlMemBlocks()) {
! 30101: printf("Leak of %d blocks found in xmlReaderNewMemory",
! 30102: xmlMemBlocks() - mem_base);
! 30103: test_ret++;
! 30104: printf(" %d", n_reader);
! 30105: printf(" %d", n_buffer);
! 30106: printf(" %d", n_size);
! 30107: printf(" %d", n_URL);
! 30108: printf(" %d", n_encoding);
! 30109: printf(" %d", n_options);
! 30110: printf("\n");
! 30111: }
! 30112: }
! 30113: }
! 30114: }
! 30115: }
! 30116: }
! 30117: }
! 30118: function_tests++;
! 30119: #endif
! 30120:
! 30121: return(test_ret);
! 30122: }
! 30123:
! 30124:
! 30125: static int
! 30126: test_xmlReaderNewWalker(void) {
! 30127: int test_ret = 0;
! 30128:
! 30129: #if defined(LIBXML_READER_ENABLED)
! 30130: int mem_base;
! 30131: int ret_val;
! 30132: xmlTextReaderPtr reader; /* an XML reader */
! 30133: int n_reader;
! 30134: xmlDocPtr doc; /* a preparsed document */
! 30135: int n_doc;
! 30136:
! 30137: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30138: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 30139: mem_base = xmlMemBlocks();
! 30140: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30141: doc = gen_xmlDocPtr(n_doc, 1);
! 30142:
! 30143: ret_val = xmlReaderNewWalker(reader, doc);
! 30144: desret_int(ret_val);
! 30145: call_tests++;
! 30146: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30147: des_xmlDocPtr(n_doc, doc, 1);
! 30148: xmlResetLastError();
! 30149: if (mem_base != xmlMemBlocks()) {
! 30150: printf("Leak of %d blocks found in xmlReaderNewWalker",
! 30151: xmlMemBlocks() - mem_base);
! 30152: test_ret++;
! 30153: printf(" %d", n_reader);
! 30154: printf(" %d", n_doc);
! 30155: printf("\n");
! 30156: }
! 30157: }
! 30158: }
! 30159: function_tests++;
! 30160: #endif
! 30161:
! 30162: return(test_ret);
! 30163: }
! 30164:
! 30165:
! 30166: static int
! 30167: test_xmlReaderWalker(void) {
! 30168: int test_ret = 0;
! 30169:
! 30170: #if defined(LIBXML_READER_ENABLED)
! 30171: int mem_base;
! 30172: xmlTextReaderPtr ret_val;
! 30173: xmlDocPtr doc; /* a preparsed document */
! 30174: int n_doc;
! 30175:
! 30176: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 30177: mem_base = xmlMemBlocks();
! 30178: doc = gen_xmlDocPtr(n_doc, 0);
! 30179:
! 30180: ret_val = xmlReaderWalker(doc);
! 30181: desret_xmlTextReaderPtr(ret_val);
! 30182: call_tests++;
! 30183: des_xmlDocPtr(n_doc, doc, 0);
! 30184: xmlResetLastError();
! 30185: if (mem_base != xmlMemBlocks()) {
! 30186: printf("Leak of %d blocks found in xmlReaderWalker",
! 30187: xmlMemBlocks() - mem_base);
! 30188: test_ret++;
! 30189: printf(" %d", n_doc);
! 30190: printf("\n");
! 30191: }
! 30192: }
! 30193: function_tests++;
! 30194: #endif
! 30195:
! 30196: return(test_ret);
! 30197: }
! 30198:
! 30199:
! 30200: static int
! 30201: test_xmlTextReaderAttributeCount(void) {
! 30202: int test_ret = 0;
! 30203:
! 30204: #if defined(LIBXML_READER_ENABLED)
! 30205: int mem_base;
! 30206: int ret_val;
! 30207: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30208: int n_reader;
! 30209:
! 30210: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30211: mem_base = xmlMemBlocks();
! 30212: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30213:
! 30214: ret_val = xmlTextReaderAttributeCount(reader);
! 30215: desret_int(ret_val);
! 30216: call_tests++;
! 30217: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30218: xmlResetLastError();
! 30219: if (mem_base != xmlMemBlocks()) {
! 30220: printf("Leak of %d blocks found in xmlTextReaderAttributeCount",
! 30221: xmlMemBlocks() - mem_base);
! 30222: test_ret++;
! 30223: printf(" %d", n_reader);
! 30224: printf("\n");
! 30225: }
! 30226: }
! 30227: function_tests++;
! 30228: #endif
! 30229:
! 30230: return(test_ret);
! 30231: }
! 30232:
! 30233:
! 30234: static int
! 30235: test_xmlTextReaderBaseUri(void) {
! 30236: int test_ret = 0;
! 30237:
! 30238: #if defined(LIBXML_READER_ENABLED)
! 30239: int mem_base;
! 30240: xmlChar * ret_val;
! 30241: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30242: int n_reader;
! 30243:
! 30244: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30245: mem_base = xmlMemBlocks();
! 30246: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30247:
! 30248: ret_val = xmlTextReaderBaseUri(reader);
! 30249: desret_xmlChar_ptr(ret_val);
! 30250: call_tests++;
! 30251: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30252: xmlResetLastError();
! 30253: if (mem_base != xmlMemBlocks()) {
! 30254: printf("Leak of %d blocks found in xmlTextReaderBaseUri",
! 30255: xmlMemBlocks() - mem_base);
! 30256: test_ret++;
! 30257: printf(" %d", n_reader);
! 30258: printf("\n");
! 30259: }
! 30260: }
! 30261: function_tests++;
! 30262: #endif
! 30263:
! 30264: return(test_ret);
! 30265: }
! 30266:
! 30267:
! 30268: static int
! 30269: test_xmlTextReaderByteConsumed(void) {
! 30270: int test_ret = 0;
! 30271:
! 30272: #if defined(LIBXML_READER_ENABLED)
! 30273: int mem_base;
! 30274: long ret_val;
! 30275: xmlTextReaderPtr reader; /* an XML reader */
! 30276: int n_reader;
! 30277:
! 30278: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30279: mem_base = xmlMemBlocks();
! 30280: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30281:
! 30282: ret_val = xmlTextReaderByteConsumed(reader);
! 30283: desret_long(ret_val);
! 30284: call_tests++;
! 30285: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30286: xmlResetLastError();
! 30287: if (mem_base != xmlMemBlocks()) {
! 30288: printf("Leak of %d blocks found in xmlTextReaderByteConsumed",
! 30289: xmlMemBlocks() - mem_base);
! 30290: test_ret++;
! 30291: printf(" %d", n_reader);
! 30292: printf("\n");
! 30293: }
! 30294: }
! 30295: function_tests++;
! 30296: #endif
! 30297:
! 30298: return(test_ret);
! 30299: }
! 30300:
! 30301:
! 30302: static int
! 30303: test_xmlTextReaderClose(void) {
! 30304: int test_ret = 0;
! 30305:
! 30306: #if defined(LIBXML_READER_ENABLED)
! 30307: int mem_base;
! 30308: int ret_val;
! 30309: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30310: int n_reader;
! 30311:
! 30312: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30313: mem_base = xmlMemBlocks();
! 30314: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30315:
! 30316: ret_val = xmlTextReaderClose(reader);
! 30317: desret_int(ret_val);
! 30318: call_tests++;
! 30319: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30320: xmlResetLastError();
! 30321: if (mem_base != xmlMemBlocks()) {
! 30322: printf("Leak of %d blocks found in xmlTextReaderClose",
! 30323: xmlMemBlocks() - mem_base);
! 30324: test_ret++;
! 30325: printf(" %d", n_reader);
! 30326: printf("\n");
! 30327: }
! 30328: }
! 30329: function_tests++;
! 30330: #endif
! 30331:
! 30332: return(test_ret);
! 30333: }
! 30334:
! 30335:
! 30336: static int
! 30337: test_xmlTextReaderConstBaseUri(void) {
! 30338: int test_ret = 0;
! 30339:
! 30340: #if defined(LIBXML_READER_ENABLED)
! 30341: int mem_base;
! 30342: const xmlChar * ret_val;
! 30343: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30344: int n_reader;
! 30345:
! 30346: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30347: mem_base = xmlMemBlocks();
! 30348: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30349:
! 30350: ret_val = xmlTextReaderConstBaseUri(reader);
! 30351: desret_const_xmlChar_ptr(ret_val);
! 30352: call_tests++;
! 30353: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30354: xmlResetLastError();
! 30355: if (mem_base != xmlMemBlocks()) {
! 30356: printf("Leak of %d blocks found in xmlTextReaderConstBaseUri",
! 30357: xmlMemBlocks() - mem_base);
! 30358: test_ret++;
! 30359: printf(" %d", n_reader);
! 30360: printf("\n");
! 30361: }
! 30362: }
! 30363: function_tests++;
! 30364: #endif
! 30365:
! 30366: return(test_ret);
! 30367: }
! 30368:
! 30369:
! 30370: static int
! 30371: test_xmlTextReaderConstEncoding(void) {
! 30372: int test_ret = 0;
! 30373:
! 30374: #if defined(LIBXML_READER_ENABLED)
! 30375: int mem_base;
! 30376: const xmlChar * ret_val;
! 30377: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30378: int n_reader;
! 30379:
! 30380: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30381: mem_base = xmlMemBlocks();
! 30382: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30383:
! 30384: ret_val = xmlTextReaderConstEncoding(reader);
! 30385: desret_const_xmlChar_ptr(ret_val);
! 30386: call_tests++;
! 30387: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30388: xmlResetLastError();
! 30389: if (mem_base != xmlMemBlocks()) {
! 30390: printf("Leak of %d blocks found in xmlTextReaderConstEncoding",
! 30391: xmlMemBlocks() - mem_base);
! 30392: test_ret++;
! 30393: printf(" %d", n_reader);
! 30394: printf("\n");
! 30395: }
! 30396: }
! 30397: function_tests++;
! 30398: #endif
! 30399:
! 30400: return(test_ret);
! 30401: }
! 30402:
! 30403:
! 30404: static int
! 30405: test_xmlTextReaderConstLocalName(void) {
! 30406: int test_ret = 0;
! 30407:
! 30408: #if defined(LIBXML_READER_ENABLED)
! 30409: int mem_base;
! 30410: const xmlChar * ret_val;
! 30411: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30412: int n_reader;
! 30413:
! 30414: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30415: mem_base = xmlMemBlocks();
! 30416: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30417:
! 30418: ret_val = xmlTextReaderConstLocalName(reader);
! 30419: desret_const_xmlChar_ptr(ret_val);
! 30420: call_tests++;
! 30421: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30422: xmlResetLastError();
! 30423: if (mem_base != xmlMemBlocks()) {
! 30424: printf("Leak of %d blocks found in xmlTextReaderConstLocalName",
! 30425: xmlMemBlocks() - mem_base);
! 30426: test_ret++;
! 30427: printf(" %d", n_reader);
! 30428: printf("\n");
! 30429: }
! 30430: }
! 30431: function_tests++;
! 30432: #endif
! 30433:
! 30434: return(test_ret);
! 30435: }
! 30436:
! 30437:
! 30438: static int
! 30439: test_xmlTextReaderConstName(void) {
! 30440: int test_ret = 0;
! 30441:
! 30442: #if defined(LIBXML_READER_ENABLED)
! 30443: int mem_base;
! 30444: const xmlChar * ret_val;
! 30445: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30446: int n_reader;
! 30447:
! 30448: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30449: mem_base = xmlMemBlocks();
! 30450: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30451:
! 30452: ret_val = xmlTextReaderConstName(reader);
! 30453: desret_const_xmlChar_ptr(ret_val);
! 30454: call_tests++;
! 30455: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30456: xmlResetLastError();
! 30457: if (mem_base != xmlMemBlocks()) {
! 30458: printf("Leak of %d blocks found in xmlTextReaderConstName",
! 30459: xmlMemBlocks() - mem_base);
! 30460: test_ret++;
! 30461: printf(" %d", n_reader);
! 30462: printf("\n");
! 30463: }
! 30464: }
! 30465: function_tests++;
! 30466: #endif
! 30467:
! 30468: return(test_ret);
! 30469: }
! 30470:
! 30471:
! 30472: static int
! 30473: test_xmlTextReaderConstNamespaceUri(void) {
! 30474: int test_ret = 0;
! 30475:
! 30476: #if defined(LIBXML_READER_ENABLED)
! 30477: int mem_base;
! 30478: const xmlChar * ret_val;
! 30479: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30480: int n_reader;
! 30481:
! 30482: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30483: mem_base = xmlMemBlocks();
! 30484: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30485:
! 30486: ret_val = xmlTextReaderConstNamespaceUri(reader);
! 30487: desret_const_xmlChar_ptr(ret_val);
! 30488: call_tests++;
! 30489: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30490: xmlResetLastError();
! 30491: if (mem_base != xmlMemBlocks()) {
! 30492: printf("Leak of %d blocks found in xmlTextReaderConstNamespaceUri",
! 30493: xmlMemBlocks() - mem_base);
! 30494: test_ret++;
! 30495: printf(" %d", n_reader);
! 30496: printf("\n");
! 30497: }
! 30498: }
! 30499: function_tests++;
! 30500: #endif
! 30501:
! 30502: return(test_ret);
! 30503: }
! 30504:
! 30505:
! 30506: static int
! 30507: test_xmlTextReaderConstPrefix(void) {
! 30508: int test_ret = 0;
! 30509:
! 30510: #if defined(LIBXML_READER_ENABLED)
! 30511: int mem_base;
! 30512: const xmlChar * ret_val;
! 30513: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30514: int n_reader;
! 30515:
! 30516: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30517: mem_base = xmlMemBlocks();
! 30518: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30519:
! 30520: ret_val = xmlTextReaderConstPrefix(reader);
! 30521: desret_const_xmlChar_ptr(ret_val);
! 30522: call_tests++;
! 30523: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30524: xmlResetLastError();
! 30525: if (mem_base != xmlMemBlocks()) {
! 30526: printf("Leak of %d blocks found in xmlTextReaderConstPrefix",
! 30527: xmlMemBlocks() - mem_base);
! 30528: test_ret++;
! 30529: printf(" %d", n_reader);
! 30530: printf("\n");
! 30531: }
! 30532: }
! 30533: function_tests++;
! 30534: #endif
! 30535:
! 30536: return(test_ret);
! 30537: }
! 30538:
! 30539:
! 30540: static int
! 30541: test_xmlTextReaderConstString(void) {
! 30542: int test_ret = 0;
! 30543:
! 30544: #if defined(LIBXML_READER_ENABLED)
! 30545: int mem_base;
! 30546: const xmlChar * ret_val;
! 30547: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30548: int n_reader;
! 30549: xmlChar * str; /* the string to intern. */
! 30550: int n_str;
! 30551:
! 30552: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30553: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 30554: mem_base = xmlMemBlocks();
! 30555: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30556: str = gen_const_xmlChar_ptr(n_str, 1);
! 30557:
! 30558: ret_val = xmlTextReaderConstString(reader, (const xmlChar *)str);
! 30559: desret_const_xmlChar_ptr(ret_val);
! 30560: call_tests++;
! 30561: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30562: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
! 30563: xmlResetLastError();
! 30564: if (mem_base != xmlMemBlocks()) {
! 30565: printf("Leak of %d blocks found in xmlTextReaderConstString",
! 30566: xmlMemBlocks() - mem_base);
! 30567: test_ret++;
! 30568: printf(" %d", n_reader);
! 30569: printf(" %d", n_str);
! 30570: printf("\n");
! 30571: }
! 30572: }
! 30573: }
! 30574: function_tests++;
! 30575: #endif
! 30576:
! 30577: return(test_ret);
! 30578: }
! 30579:
! 30580:
! 30581: static int
! 30582: test_xmlTextReaderConstValue(void) {
! 30583: int test_ret = 0;
! 30584:
! 30585: #if defined(LIBXML_READER_ENABLED)
! 30586: int mem_base;
! 30587: const xmlChar * ret_val;
! 30588: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30589: int n_reader;
! 30590:
! 30591: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30592: mem_base = xmlMemBlocks();
! 30593: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30594:
! 30595: ret_val = xmlTextReaderConstValue(reader);
! 30596: desret_const_xmlChar_ptr(ret_val);
! 30597: call_tests++;
! 30598: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30599: xmlResetLastError();
! 30600: if (mem_base != xmlMemBlocks()) {
! 30601: printf("Leak of %d blocks found in xmlTextReaderConstValue",
! 30602: xmlMemBlocks() - mem_base);
! 30603: test_ret++;
! 30604: printf(" %d", n_reader);
! 30605: printf("\n");
! 30606: }
! 30607: }
! 30608: function_tests++;
! 30609: #endif
! 30610:
! 30611: return(test_ret);
! 30612: }
! 30613:
! 30614:
! 30615: static int
! 30616: test_xmlTextReaderConstXmlLang(void) {
! 30617: int test_ret = 0;
! 30618:
! 30619: #if defined(LIBXML_READER_ENABLED)
! 30620: int mem_base;
! 30621: const xmlChar * ret_val;
! 30622: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30623: int n_reader;
! 30624:
! 30625: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30626: mem_base = xmlMemBlocks();
! 30627: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30628:
! 30629: ret_val = xmlTextReaderConstXmlLang(reader);
! 30630: desret_const_xmlChar_ptr(ret_val);
! 30631: call_tests++;
! 30632: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30633: xmlResetLastError();
! 30634: if (mem_base != xmlMemBlocks()) {
! 30635: printf("Leak of %d blocks found in xmlTextReaderConstXmlLang",
! 30636: xmlMemBlocks() - mem_base);
! 30637: test_ret++;
! 30638: printf(" %d", n_reader);
! 30639: printf("\n");
! 30640: }
! 30641: }
! 30642: function_tests++;
! 30643: #endif
! 30644:
! 30645: return(test_ret);
! 30646: }
! 30647:
! 30648:
! 30649: static int
! 30650: test_xmlTextReaderConstXmlVersion(void) {
! 30651: int test_ret = 0;
! 30652:
! 30653: #if defined(LIBXML_READER_ENABLED)
! 30654: int mem_base;
! 30655: const xmlChar * ret_val;
! 30656: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30657: int n_reader;
! 30658:
! 30659: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30660: mem_base = xmlMemBlocks();
! 30661: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30662:
! 30663: ret_val = xmlTextReaderConstXmlVersion(reader);
! 30664: desret_const_xmlChar_ptr(ret_val);
! 30665: call_tests++;
! 30666: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30667: xmlResetLastError();
! 30668: if (mem_base != xmlMemBlocks()) {
! 30669: printf("Leak of %d blocks found in xmlTextReaderConstXmlVersion",
! 30670: xmlMemBlocks() - mem_base);
! 30671: test_ret++;
! 30672: printf(" %d", n_reader);
! 30673: printf("\n");
! 30674: }
! 30675: }
! 30676: function_tests++;
! 30677: #endif
! 30678:
! 30679: return(test_ret);
! 30680: }
! 30681:
! 30682:
! 30683: static int
! 30684: test_xmlTextReaderCurrentDoc(void) {
! 30685: int test_ret = 0;
! 30686:
! 30687: #if defined(LIBXML_READER_ENABLED)
! 30688: int mem_base;
! 30689: xmlDocPtr ret_val;
! 30690: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30691: int n_reader;
! 30692:
! 30693: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30694: mem_base = xmlMemBlocks();
! 30695: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30696:
! 30697: ret_val = xmlTextReaderCurrentDoc(reader);
! 30698: desret_xmlDocPtr(ret_val);
! 30699: call_tests++;
! 30700: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30701: xmlResetLastError();
! 30702: if (mem_base != xmlMemBlocks()) {
! 30703: printf("Leak of %d blocks found in xmlTextReaderCurrentDoc",
! 30704: xmlMemBlocks() - mem_base);
! 30705: test_ret++;
! 30706: printf(" %d", n_reader);
! 30707: printf("\n");
! 30708: }
! 30709: }
! 30710: function_tests++;
! 30711: #endif
! 30712:
! 30713: return(test_ret);
! 30714: }
! 30715:
! 30716:
! 30717: static int
! 30718: test_xmlTextReaderCurrentNode(void) {
! 30719: int test_ret = 0;
! 30720:
! 30721: #if defined(LIBXML_READER_ENABLED)
! 30722: int mem_base;
! 30723: xmlNodePtr ret_val;
! 30724: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30725: int n_reader;
! 30726:
! 30727: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30728: mem_base = xmlMemBlocks();
! 30729: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30730:
! 30731: ret_val = xmlTextReaderCurrentNode(reader);
! 30732: desret_xmlNodePtr(ret_val);
! 30733: call_tests++;
! 30734: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30735: xmlResetLastError();
! 30736: if (mem_base != xmlMemBlocks()) {
! 30737: printf("Leak of %d blocks found in xmlTextReaderCurrentNode",
! 30738: xmlMemBlocks() - mem_base);
! 30739: test_ret++;
! 30740: printf(" %d", n_reader);
! 30741: printf("\n");
! 30742: }
! 30743: }
! 30744: function_tests++;
! 30745: #endif
! 30746:
! 30747: return(test_ret);
! 30748: }
! 30749:
! 30750:
! 30751: static int
! 30752: test_xmlTextReaderDepth(void) {
! 30753: int test_ret = 0;
! 30754:
! 30755: #if defined(LIBXML_READER_ENABLED)
! 30756: int mem_base;
! 30757: int ret_val;
! 30758: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30759: int n_reader;
! 30760:
! 30761: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30762: mem_base = xmlMemBlocks();
! 30763: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30764:
! 30765: ret_val = xmlTextReaderDepth(reader);
! 30766: desret_int(ret_val);
! 30767: call_tests++;
! 30768: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30769: xmlResetLastError();
! 30770: if (mem_base != xmlMemBlocks()) {
! 30771: printf("Leak of %d blocks found in xmlTextReaderDepth",
! 30772: xmlMemBlocks() - mem_base);
! 30773: test_ret++;
! 30774: printf(" %d", n_reader);
! 30775: printf("\n");
! 30776: }
! 30777: }
! 30778: function_tests++;
! 30779: #endif
! 30780:
! 30781: return(test_ret);
! 30782: }
! 30783:
! 30784:
! 30785: static int
! 30786: test_xmlTextReaderExpand(void) {
! 30787: int test_ret = 0;
! 30788:
! 30789: #if defined(LIBXML_READER_ENABLED)
! 30790: int mem_base;
! 30791: xmlNodePtr ret_val;
! 30792: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30793: int n_reader;
! 30794:
! 30795: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30796: mem_base = xmlMemBlocks();
! 30797: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30798:
! 30799: ret_val = xmlTextReaderExpand(reader);
! 30800: desret_xmlNodePtr(ret_val);
! 30801: call_tests++;
! 30802: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30803: xmlResetLastError();
! 30804: if (mem_base != xmlMemBlocks()) {
! 30805: printf("Leak of %d blocks found in xmlTextReaderExpand",
! 30806: xmlMemBlocks() - mem_base);
! 30807: test_ret++;
! 30808: printf(" %d", n_reader);
! 30809: printf("\n");
! 30810: }
! 30811: }
! 30812: function_tests++;
! 30813: #endif
! 30814:
! 30815: return(test_ret);
! 30816: }
! 30817:
! 30818:
! 30819: static int
! 30820: test_xmlTextReaderGetAttribute(void) {
! 30821: int test_ret = 0;
! 30822:
! 30823: #if defined(LIBXML_READER_ENABLED)
! 30824: int mem_base;
! 30825: xmlChar * ret_val;
! 30826: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30827: int n_reader;
! 30828: xmlChar * name; /* the qualified name of the attribute. */
! 30829: int n_name;
! 30830:
! 30831: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30832: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 30833: mem_base = xmlMemBlocks();
! 30834: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30835: name = gen_const_xmlChar_ptr(n_name, 1);
! 30836:
! 30837: ret_val = xmlTextReaderGetAttribute(reader, (const xmlChar *)name);
! 30838: desret_xmlChar_ptr(ret_val);
! 30839: call_tests++;
! 30840: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30841: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 30842: xmlResetLastError();
! 30843: if (mem_base != xmlMemBlocks()) {
! 30844: printf("Leak of %d blocks found in xmlTextReaderGetAttribute",
! 30845: xmlMemBlocks() - mem_base);
! 30846: test_ret++;
! 30847: printf(" %d", n_reader);
! 30848: printf(" %d", n_name);
! 30849: printf("\n");
! 30850: }
! 30851: }
! 30852: }
! 30853: function_tests++;
! 30854: #endif
! 30855:
! 30856: return(test_ret);
! 30857: }
! 30858:
! 30859:
! 30860: static int
! 30861: test_xmlTextReaderGetAttributeNo(void) {
! 30862: int test_ret = 0;
! 30863:
! 30864: #if defined(LIBXML_READER_ENABLED)
! 30865: int mem_base;
! 30866: xmlChar * ret_val;
! 30867: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30868: int n_reader;
! 30869: int no; /* the zero-based index of the attribute relative to the containing element */
! 30870: int n_no;
! 30871:
! 30872: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30873: for (n_no = 0;n_no < gen_nb_int;n_no++) {
! 30874: mem_base = xmlMemBlocks();
! 30875: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30876: no = gen_int(n_no, 1);
! 30877:
! 30878: ret_val = xmlTextReaderGetAttributeNo(reader, no);
! 30879: desret_xmlChar_ptr(ret_val);
! 30880: call_tests++;
! 30881: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30882: des_int(n_no, no, 1);
! 30883: xmlResetLastError();
! 30884: if (mem_base != xmlMemBlocks()) {
! 30885: printf("Leak of %d blocks found in xmlTextReaderGetAttributeNo",
! 30886: xmlMemBlocks() - mem_base);
! 30887: test_ret++;
! 30888: printf(" %d", n_reader);
! 30889: printf(" %d", n_no);
! 30890: printf("\n");
! 30891: }
! 30892: }
! 30893: }
! 30894: function_tests++;
! 30895: #endif
! 30896:
! 30897: return(test_ret);
! 30898: }
! 30899:
! 30900:
! 30901: static int
! 30902: test_xmlTextReaderGetAttributeNs(void) {
! 30903: int test_ret = 0;
! 30904:
! 30905: #if defined(LIBXML_READER_ENABLED)
! 30906: int mem_base;
! 30907: xmlChar * ret_val;
! 30908: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30909: int n_reader;
! 30910: xmlChar * localName; /* the local name of the attribute. */
! 30911: int n_localName;
! 30912: xmlChar * namespaceURI; /* the namespace URI of the attribute. */
! 30913: int n_namespaceURI;
! 30914:
! 30915: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30916: for (n_localName = 0;n_localName < gen_nb_const_xmlChar_ptr;n_localName++) {
! 30917: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
! 30918: mem_base = xmlMemBlocks();
! 30919: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30920: localName = gen_const_xmlChar_ptr(n_localName, 1);
! 30921: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 2);
! 30922:
! 30923: ret_val = xmlTextReaderGetAttributeNs(reader, (const xmlChar *)localName, (const xmlChar *)namespaceURI);
! 30924: desret_xmlChar_ptr(ret_val);
! 30925: call_tests++;
! 30926: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30927: des_const_xmlChar_ptr(n_localName, (const xmlChar *)localName, 1);
! 30928: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 2);
! 30929: xmlResetLastError();
! 30930: if (mem_base != xmlMemBlocks()) {
! 30931: printf("Leak of %d blocks found in xmlTextReaderGetAttributeNs",
! 30932: xmlMemBlocks() - mem_base);
! 30933: test_ret++;
! 30934: printf(" %d", n_reader);
! 30935: printf(" %d", n_localName);
! 30936: printf(" %d", n_namespaceURI);
! 30937: printf("\n");
! 30938: }
! 30939: }
! 30940: }
! 30941: }
! 30942: function_tests++;
! 30943: #endif
! 30944:
! 30945: return(test_ret);
! 30946: }
! 30947:
! 30948: #ifdef LIBXML_READER_ENABLED
! 30949:
! 30950: #define gen_nb_xmlTextReaderErrorFunc_ptr 1
! 30951: static xmlTextReaderErrorFunc * gen_xmlTextReaderErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 30952: return(NULL);
! 30953: }
! 30954: static void des_xmlTextReaderErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlTextReaderErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 30955: }
! 30956: #endif
! 30957:
! 30958:
! 30959: static int
! 30960: test_xmlTextReaderGetErrorHandler(void) {
! 30961: int test_ret = 0;
! 30962:
! 30963: #if defined(LIBXML_READER_ENABLED)
! 30964: int mem_base;
! 30965: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 30966: int n_reader;
! 30967: xmlTextReaderErrorFunc * f; /* the callback function or NULL is no callback has been registered */
! 30968: int n_f;
! 30969: void ** arg; /* a user argument */
! 30970: int n_arg;
! 30971:
! 30972: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 30973: for (n_f = 0;n_f < gen_nb_xmlTextReaderErrorFunc_ptr;n_f++) {
! 30974: for (n_arg = 0;n_arg < gen_nb_void_ptr_ptr;n_arg++) {
! 30975: mem_base = xmlMemBlocks();
! 30976: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 30977: f = gen_xmlTextReaderErrorFunc_ptr(n_f, 1);
! 30978: arg = gen_void_ptr_ptr(n_arg, 2);
! 30979:
! 30980: xmlTextReaderGetErrorHandler(reader, f, arg);
! 30981: call_tests++;
! 30982: des_xmlTextReaderPtr(n_reader, reader, 0);
! 30983: des_xmlTextReaderErrorFunc_ptr(n_f, f, 1);
! 30984: des_void_ptr_ptr(n_arg, arg, 2);
! 30985: xmlResetLastError();
! 30986: if (mem_base != xmlMemBlocks()) {
! 30987: printf("Leak of %d blocks found in xmlTextReaderGetErrorHandler",
! 30988: xmlMemBlocks() - mem_base);
! 30989: test_ret++;
! 30990: printf(" %d", n_reader);
! 30991: printf(" %d", n_f);
! 30992: printf(" %d", n_arg);
! 30993: printf("\n");
! 30994: }
! 30995: }
! 30996: }
! 30997: }
! 30998: function_tests++;
! 30999: #endif
! 31000:
! 31001: return(test_ret);
! 31002: }
! 31003:
! 31004:
! 31005: static int
! 31006: test_xmlTextReaderGetParserColumnNumber(void) {
! 31007: int test_ret = 0;
! 31008:
! 31009: #if defined(LIBXML_READER_ENABLED)
! 31010: int mem_base;
! 31011: int ret_val;
! 31012: xmlTextReaderPtr reader; /* the user data (XML reader context) */
! 31013: int n_reader;
! 31014:
! 31015: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31016: mem_base = xmlMemBlocks();
! 31017: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31018:
! 31019: ret_val = xmlTextReaderGetParserColumnNumber(reader);
! 31020: desret_int(ret_val);
! 31021: call_tests++;
! 31022: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31023: xmlResetLastError();
! 31024: if (mem_base != xmlMemBlocks()) {
! 31025: printf("Leak of %d blocks found in xmlTextReaderGetParserColumnNumber",
! 31026: xmlMemBlocks() - mem_base);
! 31027: test_ret++;
! 31028: printf(" %d", n_reader);
! 31029: printf("\n");
! 31030: }
! 31031: }
! 31032: function_tests++;
! 31033: #endif
! 31034:
! 31035: return(test_ret);
! 31036: }
! 31037:
! 31038:
! 31039: static int
! 31040: test_xmlTextReaderGetParserLineNumber(void) {
! 31041: int test_ret = 0;
! 31042:
! 31043: #if defined(LIBXML_READER_ENABLED)
! 31044: int mem_base;
! 31045: int ret_val;
! 31046: xmlTextReaderPtr reader; /* the user data (XML reader context) */
! 31047: int n_reader;
! 31048:
! 31049: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31050: mem_base = xmlMemBlocks();
! 31051: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31052:
! 31053: ret_val = xmlTextReaderGetParserLineNumber(reader);
! 31054: desret_int(ret_val);
! 31055: call_tests++;
! 31056: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31057: xmlResetLastError();
! 31058: if (mem_base != xmlMemBlocks()) {
! 31059: printf("Leak of %d blocks found in xmlTextReaderGetParserLineNumber",
! 31060: xmlMemBlocks() - mem_base);
! 31061: test_ret++;
! 31062: printf(" %d", n_reader);
! 31063: printf("\n");
! 31064: }
! 31065: }
! 31066: function_tests++;
! 31067: #endif
! 31068:
! 31069: return(test_ret);
! 31070: }
! 31071:
! 31072:
! 31073: static int
! 31074: test_xmlTextReaderGetParserProp(void) {
! 31075: int test_ret = 0;
! 31076:
! 31077: #if defined(LIBXML_READER_ENABLED)
! 31078: int mem_base;
! 31079: int ret_val;
! 31080: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31081: int n_reader;
! 31082: int prop; /* the xmlParserProperties to get */
! 31083: int n_prop;
! 31084:
! 31085: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31086: for (n_prop = 0;n_prop < gen_nb_int;n_prop++) {
! 31087: mem_base = xmlMemBlocks();
! 31088: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31089: prop = gen_int(n_prop, 1);
! 31090:
! 31091: ret_val = xmlTextReaderGetParserProp(reader, prop);
! 31092: desret_int(ret_val);
! 31093: call_tests++;
! 31094: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31095: des_int(n_prop, prop, 1);
! 31096: xmlResetLastError();
! 31097: if (mem_base != xmlMemBlocks()) {
! 31098: printf("Leak of %d blocks found in xmlTextReaderGetParserProp",
! 31099: xmlMemBlocks() - mem_base);
! 31100: test_ret++;
! 31101: printf(" %d", n_reader);
! 31102: printf(" %d", n_prop);
! 31103: printf("\n");
! 31104: }
! 31105: }
! 31106: }
! 31107: function_tests++;
! 31108: #endif
! 31109:
! 31110: return(test_ret);
! 31111: }
! 31112:
! 31113:
! 31114: static int
! 31115: test_xmlTextReaderGetRemainder(void) {
! 31116: int test_ret = 0;
! 31117:
! 31118: #if defined(LIBXML_READER_ENABLED)
! 31119: int mem_base;
! 31120: xmlParserInputBufferPtr ret_val;
! 31121: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31122: int n_reader;
! 31123:
! 31124: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31125: mem_base = xmlMemBlocks();
! 31126: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31127:
! 31128: ret_val = xmlTextReaderGetRemainder(reader);
! 31129: desret_xmlParserInputBufferPtr(ret_val);
! 31130: call_tests++;
! 31131: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31132: xmlResetLastError();
! 31133: if (mem_base != xmlMemBlocks()) {
! 31134: printf("Leak of %d blocks found in xmlTextReaderGetRemainder",
! 31135: xmlMemBlocks() - mem_base);
! 31136: test_ret++;
! 31137: printf(" %d", n_reader);
! 31138: printf("\n");
! 31139: }
! 31140: }
! 31141: function_tests++;
! 31142: #endif
! 31143:
! 31144: return(test_ret);
! 31145: }
! 31146:
! 31147:
! 31148: static int
! 31149: test_xmlTextReaderHasAttributes(void) {
! 31150: int test_ret = 0;
! 31151:
! 31152: #if defined(LIBXML_READER_ENABLED)
! 31153: int mem_base;
! 31154: int ret_val;
! 31155: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31156: int n_reader;
! 31157:
! 31158: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31159: mem_base = xmlMemBlocks();
! 31160: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31161:
! 31162: ret_val = xmlTextReaderHasAttributes(reader);
! 31163: desret_int(ret_val);
! 31164: call_tests++;
! 31165: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31166: xmlResetLastError();
! 31167: if (mem_base != xmlMemBlocks()) {
! 31168: printf("Leak of %d blocks found in xmlTextReaderHasAttributes",
! 31169: xmlMemBlocks() - mem_base);
! 31170: test_ret++;
! 31171: printf(" %d", n_reader);
! 31172: printf("\n");
! 31173: }
! 31174: }
! 31175: function_tests++;
! 31176: #endif
! 31177:
! 31178: return(test_ret);
! 31179: }
! 31180:
! 31181:
! 31182: static int
! 31183: test_xmlTextReaderHasValue(void) {
! 31184: int test_ret = 0;
! 31185:
! 31186: #if defined(LIBXML_READER_ENABLED)
! 31187: int mem_base;
! 31188: int ret_val;
! 31189: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31190: int n_reader;
! 31191:
! 31192: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31193: mem_base = xmlMemBlocks();
! 31194: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31195:
! 31196: ret_val = xmlTextReaderHasValue(reader);
! 31197: desret_int(ret_val);
! 31198: call_tests++;
! 31199: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31200: xmlResetLastError();
! 31201: if (mem_base != xmlMemBlocks()) {
! 31202: printf("Leak of %d blocks found in xmlTextReaderHasValue",
! 31203: xmlMemBlocks() - mem_base);
! 31204: test_ret++;
! 31205: printf(" %d", n_reader);
! 31206: printf("\n");
! 31207: }
! 31208: }
! 31209: function_tests++;
! 31210: #endif
! 31211:
! 31212: return(test_ret);
! 31213: }
! 31214:
! 31215:
! 31216: static int
! 31217: test_xmlTextReaderIsDefault(void) {
! 31218: int test_ret = 0;
! 31219:
! 31220: #if defined(LIBXML_READER_ENABLED)
! 31221: int mem_base;
! 31222: int ret_val;
! 31223: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31224: int n_reader;
! 31225:
! 31226: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31227: mem_base = xmlMemBlocks();
! 31228: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31229:
! 31230: ret_val = xmlTextReaderIsDefault(reader);
! 31231: desret_int(ret_val);
! 31232: call_tests++;
! 31233: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31234: xmlResetLastError();
! 31235: if (mem_base != xmlMemBlocks()) {
! 31236: printf("Leak of %d blocks found in xmlTextReaderIsDefault",
! 31237: xmlMemBlocks() - mem_base);
! 31238: test_ret++;
! 31239: printf(" %d", n_reader);
! 31240: printf("\n");
! 31241: }
! 31242: }
! 31243: function_tests++;
! 31244: #endif
! 31245:
! 31246: return(test_ret);
! 31247: }
! 31248:
! 31249:
! 31250: static int
! 31251: test_xmlTextReaderIsEmptyElement(void) {
! 31252: int test_ret = 0;
! 31253:
! 31254: #if defined(LIBXML_READER_ENABLED)
! 31255: int mem_base;
! 31256: int ret_val;
! 31257: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31258: int n_reader;
! 31259:
! 31260: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31261: mem_base = xmlMemBlocks();
! 31262: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31263:
! 31264: ret_val = xmlTextReaderIsEmptyElement(reader);
! 31265: desret_int(ret_val);
! 31266: call_tests++;
! 31267: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31268: xmlResetLastError();
! 31269: if (mem_base != xmlMemBlocks()) {
! 31270: printf("Leak of %d blocks found in xmlTextReaderIsEmptyElement",
! 31271: xmlMemBlocks() - mem_base);
! 31272: test_ret++;
! 31273: printf(" %d", n_reader);
! 31274: printf("\n");
! 31275: }
! 31276: }
! 31277: function_tests++;
! 31278: #endif
! 31279:
! 31280: return(test_ret);
! 31281: }
! 31282:
! 31283:
! 31284: static int
! 31285: test_xmlTextReaderIsNamespaceDecl(void) {
! 31286: int test_ret = 0;
! 31287:
! 31288: #if defined(LIBXML_READER_ENABLED)
! 31289: int mem_base;
! 31290: int ret_val;
! 31291: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31292: int n_reader;
! 31293:
! 31294: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31295: mem_base = xmlMemBlocks();
! 31296: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31297:
! 31298: ret_val = xmlTextReaderIsNamespaceDecl(reader);
! 31299: desret_int(ret_val);
! 31300: call_tests++;
! 31301: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31302: xmlResetLastError();
! 31303: if (mem_base != xmlMemBlocks()) {
! 31304: printf("Leak of %d blocks found in xmlTextReaderIsNamespaceDecl",
! 31305: xmlMemBlocks() - mem_base);
! 31306: test_ret++;
! 31307: printf(" %d", n_reader);
! 31308: printf("\n");
! 31309: }
! 31310: }
! 31311: function_tests++;
! 31312: #endif
! 31313:
! 31314: return(test_ret);
! 31315: }
! 31316:
! 31317:
! 31318: static int
! 31319: test_xmlTextReaderIsValid(void) {
! 31320: int test_ret = 0;
! 31321:
! 31322: #if defined(LIBXML_READER_ENABLED)
! 31323: int mem_base;
! 31324: int ret_val;
! 31325: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31326: int n_reader;
! 31327:
! 31328: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31329: mem_base = xmlMemBlocks();
! 31330: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31331:
! 31332: ret_val = xmlTextReaderIsValid(reader);
! 31333: desret_int(ret_val);
! 31334: call_tests++;
! 31335: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31336: xmlResetLastError();
! 31337: if (mem_base != xmlMemBlocks()) {
! 31338: printf("Leak of %d blocks found in xmlTextReaderIsValid",
! 31339: xmlMemBlocks() - mem_base);
! 31340: test_ret++;
! 31341: printf(" %d", n_reader);
! 31342: printf("\n");
! 31343: }
! 31344: }
! 31345: function_tests++;
! 31346: #endif
! 31347:
! 31348: return(test_ret);
! 31349: }
! 31350:
! 31351:
! 31352: static int
! 31353: test_xmlTextReaderLocalName(void) {
! 31354: int test_ret = 0;
! 31355:
! 31356: #if defined(LIBXML_READER_ENABLED)
! 31357: int mem_base;
! 31358: xmlChar * ret_val;
! 31359: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31360: int n_reader;
! 31361:
! 31362: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31363: mem_base = xmlMemBlocks();
! 31364: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31365:
! 31366: ret_val = xmlTextReaderLocalName(reader);
! 31367: desret_xmlChar_ptr(ret_val);
! 31368: call_tests++;
! 31369: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31370: xmlResetLastError();
! 31371: if (mem_base != xmlMemBlocks()) {
! 31372: printf("Leak of %d blocks found in xmlTextReaderLocalName",
! 31373: xmlMemBlocks() - mem_base);
! 31374: test_ret++;
! 31375: printf(" %d", n_reader);
! 31376: printf("\n");
! 31377: }
! 31378: }
! 31379: function_tests++;
! 31380: #endif
! 31381:
! 31382: return(test_ret);
! 31383: }
! 31384:
! 31385: #ifdef LIBXML_READER_ENABLED
! 31386:
! 31387: #define gen_nb_xmlTextReaderLocatorPtr 1
! 31388: static xmlTextReaderLocatorPtr gen_xmlTextReaderLocatorPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 31389: return(NULL);
! 31390: }
! 31391: static void des_xmlTextReaderLocatorPtr(int no ATTRIBUTE_UNUSED, xmlTextReaderLocatorPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 31392: }
! 31393: #endif
! 31394:
! 31395:
! 31396: static int
! 31397: test_xmlTextReaderLocatorBaseURI(void) {
! 31398: int test_ret = 0;
! 31399:
! 31400: #if defined(LIBXML_READER_ENABLED)
! 31401: int mem_base;
! 31402: xmlChar * ret_val;
! 31403: xmlTextReaderLocatorPtr locator; /* the xmlTextReaderLocatorPtr used */
! 31404: int n_locator;
! 31405:
! 31406: for (n_locator = 0;n_locator < gen_nb_xmlTextReaderLocatorPtr;n_locator++) {
! 31407: mem_base = xmlMemBlocks();
! 31408: locator = gen_xmlTextReaderLocatorPtr(n_locator, 0);
! 31409:
! 31410: ret_val = xmlTextReaderLocatorBaseURI(locator);
! 31411: desret_xmlChar_ptr(ret_val);
! 31412: call_tests++;
! 31413: des_xmlTextReaderLocatorPtr(n_locator, locator, 0);
! 31414: xmlResetLastError();
! 31415: if (mem_base != xmlMemBlocks()) {
! 31416: printf("Leak of %d blocks found in xmlTextReaderLocatorBaseURI",
! 31417: xmlMemBlocks() - mem_base);
! 31418: test_ret++;
! 31419: printf(" %d", n_locator);
! 31420: printf("\n");
! 31421: }
! 31422: }
! 31423: function_tests++;
! 31424: #endif
! 31425:
! 31426: return(test_ret);
! 31427: }
! 31428:
! 31429:
! 31430: static int
! 31431: test_xmlTextReaderLocatorLineNumber(void) {
! 31432: int test_ret = 0;
! 31433:
! 31434: #if defined(LIBXML_READER_ENABLED)
! 31435: int mem_base;
! 31436: int ret_val;
! 31437: xmlTextReaderLocatorPtr locator; /* the xmlTextReaderLocatorPtr used */
! 31438: int n_locator;
! 31439:
! 31440: for (n_locator = 0;n_locator < gen_nb_xmlTextReaderLocatorPtr;n_locator++) {
! 31441: mem_base = xmlMemBlocks();
! 31442: locator = gen_xmlTextReaderLocatorPtr(n_locator, 0);
! 31443:
! 31444: ret_val = xmlTextReaderLocatorLineNumber(locator);
! 31445: desret_int(ret_val);
! 31446: call_tests++;
! 31447: des_xmlTextReaderLocatorPtr(n_locator, locator, 0);
! 31448: xmlResetLastError();
! 31449: if (mem_base != xmlMemBlocks()) {
! 31450: printf("Leak of %d blocks found in xmlTextReaderLocatorLineNumber",
! 31451: xmlMemBlocks() - mem_base);
! 31452: test_ret++;
! 31453: printf(" %d", n_locator);
! 31454: printf("\n");
! 31455: }
! 31456: }
! 31457: function_tests++;
! 31458: #endif
! 31459:
! 31460: return(test_ret);
! 31461: }
! 31462:
! 31463:
! 31464: static int
! 31465: test_xmlTextReaderLookupNamespace(void) {
! 31466: int test_ret = 0;
! 31467:
! 31468: #if defined(LIBXML_READER_ENABLED)
! 31469: int mem_base;
! 31470: xmlChar * ret_val;
! 31471: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31472: int n_reader;
! 31473: xmlChar * prefix; /* the prefix whose namespace URI is to be resolved. To return the default namespace, specify NULL */
! 31474: int n_prefix;
! 31475:
! 31476: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31477: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
! 31478: mem_base = xmlMemBlocks();
! 31479: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31480: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
! 31481:
! 31482: ret_val = xmlTextReaderLookupNamespace(reader, (const xmlChar *)prefix);
! 31483: desret_xmlChar_ptr(ret_val);
! 31484: call_tests++;
! 31485: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31486: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
! 31487: xmlResetLastError();
! 31488: if (mem_base != xmlMemBlocks()) {
! 31489: printf("Leak of %d blocks found in xmlTextReaderLookupNamespace",
! 31490: xmlMemBlocks() - mem_base);
! 31491: test_ret++;
! 31492: printf(" %d", n_reader);
! 31493: printf(" %d", n_prefix);
! 31494: printf("\n");
! 31495: }
! 31496: }
! 31497: }
! 31498: function_tests++;
! 31499: #endif
! 31500:
! 31501: return(test_ret);
! 31502: }
! 31503:
! 31504:
! 31505: static int
! 31506: test_xmlTextReaderMoveToAttribute(void) {
! 31507: int test_ret = 0;
! 31508:
! 31509: #if defined(LIBXML_READER_ENABLED)
! 31510: int mem_base;
! 31511: int ret_val;
! 31512: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31513: int n_reader;
! 31514: xmlChar * name; /* the qualified name of the attribute. */
! 31515: int n_name;
! 31516:
! 31517: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31518: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 31519: mem_base = xmlMemBlocks();
! 31520: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31521: name = gen_const_xmlChar_ptr(n_name, 1);
! 31522:
! 31523: ret_val = xmlTextReaderMoveToAttribute(reader, (const xmlChar *)name);
! 31524: desret_int(ret_val);
! 31525: call_tests++;
! 31526: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31527: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 31528: xmlResetLastError();
! 31529: if (mem_base != xmlMemBlocks()) {
! 31530: printf("Leak of %d blocks found in xmlTextReaderMoveToAttribute",
! 31531: xmlMemBlocks() - mem_base);
! 31532: test_ret++;
! 31533: printf(" %d", n_reader);
! 31534: printf(" %d", n_name);
! 31535: printf("\n");
! 31536: }
! 31537: }
! 31538: }
! 31539: function_tests++;
! 31540: #endif
! 31541:
! 31542: return(test_ret);
! 31543: }
! 31544:
! 31545:
! 31546: static int
! 31547: test_xmlTextReaderMoveToAttributeNo(void) {
! 31548: int test_ret = 0;
! 31549:
! 31550: #if defined(LIBXML_READER_ENABLED)
! 31551: int mem_base;
! 31552: int ret_val;
! 31553: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31554: int n_reader;
! 31555: int no; /* the zero-based index of the attribute relative to the containing element. */
! 31556: int n_no;
! 31557:
! 31558: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31559: for (n_no = 0;n_no < gen_nb_int;n_no++) {
! 31560: mem_base = xmlMemBlocks();
! 31561: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31562: no = gen_int(n_no, 1);
! 31563:
! 31564: ret_val = xmlTextReaderMoveToAttributeNo(reader, no);
! 31565: desret_int(ret_val);
! 31566: call_tests++;
! 31567: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31568: des_int(n_no, no, 1);
! 31569: xmlResetLastError();
! 31570: if (mem_base != xmlMemBlocks()) {
! 31571: printf("Leak of %d blocks found in xmlTextReaderMoveToAttributeNo",
! 31572: xmlMemBlocks() - mem_base);
! 31573: test_ret++;
! 31574: printf(" %d", n_reader);
! 31575: printf(" %d", n_no);
! 31576: printf("\n");
! 31577: }
! 31578: }
! 31579: }
! 31580: function_tests++;
! 31581: #endif
! 31582:
! 31583: return(test_ret);
! 31584: }
! 31585:
! 31586:
! 31587: static int
! 31588: test_xmlTextReaderMoveToAttributeNs(void) {
! 31589: int test_ret = 0;
! 31590:
! 31591: #if defined(LIBXML_READER_ENABLED)
! 31592: int mem_base;
! 31593: int ret_val;
! 31594: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31595: int n_reader;
! 31596: xmlChar * localName; /* the local name of the attribute. */
! 31597: int n_localName;
! 31598: xmlChar * namespaceURI; /* the namespace URI of the attribute. */
! 31599: int n_namespaceURI;
! 31600:
! 31601: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31602: for (n_localName = 0;n_localName < gen_nb_const_xmlChar_ptr;n_localName++) {
! 31603: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
! 31604: mem_base = xmlMemBlocks();
! 31605: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31606: localName = gen_const_xmlChar_ptr(n_localName, 1);
! 31607: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 2);
! 31608:
! 31609: ret_val = xmlTextReaderMoveToAttributeNs(reader, (const xmlChar *)localName, (const xmlChar *)namespaceURI);
! 31610: desret_int(ret_val);
! 31611: call_tests++;
! 31612: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31613: des_const_xmlChar_ptr(n_localName, (const xmlChar *)localName, 1);
! 31614: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 2);
! 31615: xmlResetLastError();
! 31616: if (mem_base != xmlMemBlocks()) {
! 31617: printf("Leak of %d blocks found in xmlTextReaderMoveToAttributeNs",
! 31618: xmlMemBlocks() - mem_base);
! 31619: test_ret++;
! 31620: printf(" %d", n_reader);
! 31621: printf(" %d", n_localName);
! 31622: printf(" %d", n_namespaceURI);
! 31623: printf("\n");
! 31624: }
! 31625: }
! 31626: }
! 31627: }
! 31628: function_tests++;
! 31629: #endif
! 31630:
! 31631: return(test_ret);
! 31632: }
! 31633:
! 31634:
! 31635: static int
! 31636: test_xmlTextReaderMoveToElement(void) {
! 31637: int test_ret = 0;
! 31638:
! 31639: #if defined(LIBXML_READER_ENABLED)
! 31640: int mem_base;
! 31641: int ret_val;
! 31642: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31643: int n_reader;
! 31644:
! 31645: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31646: mem_base = xmlMemBlocks();
! 31647: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31648:
! 31649: ret_val = xmlTextReaderMoveToElement(reader);
! 31650: desret_int(ret_val);
! 31651: call_tests++;
! 31652: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31653: xmlResetLastError();
! 31654: if (mem_base != xmlMemBlocks()) {
! 31655: printf("Leak of %d blocks found in xmlTextReaderMoveToElement",
! 31656: xmlMemBlocks() - mem_base);
! 31657: test_ret++;
! 31658: printf(" %d", n_reader);
! 31659: printf("\n");
! 31660: }
! 31661: }
! 31662: function_tests++;
! 31663: #endif
! 31664:
! 31665: return(test_ret);
! 31666: }
! 31667:
! 31668:
! 31669: static int
! 31670: test_xmlTextReaderMoveToFirstAttribute(void) {
! 31671: int test_ret = 0;
! 31672:
! 31673: #if defined(LIBXML_READER_ENABLED)
! 31674: int mem_base;
! 31675: int ret_val;
! 31676: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31677: int n_reader;
! 31678:
! 31679: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31680: mem_base = xmlMemBlocks();
! 31681: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31682:
! 31683: ret_val = xmlTextReaderMoveToFirstAttribute(reader);
! 31684: desret_int(ret_val);
! 31685: call_tests++;
! 31686: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31687: xmlResetLastError();
! 31688: if (mem_base != xmlMemBlocks()) {
! 31689: printf("Leak of %d blocks found in xmlTextReaderMoveToFirstAttribute",
! 31690: xmlMemBlocks() - mem_base);
! 31691: test_ret++;
! 31692: printf(" %d", n_reader);
! 31693: printf("\n");
! 31694: }
! 31695: }
! 31696: function_tests++;
! 31697: #endif
! 31698:
! 31699: return(test_ret);
! 31700: }
! 31701:
! 31702:
! 31703: static int
! 31704: test_xmlTextReaderMoveToNextAttribute(void) {
! 31705: int test_ret = 0;
! 31706:
! 31707: #if defined(LIBXML_READER_ENABLED)
! 31708: int mem_base;
! 31709: int ret_val;
! 31710: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31711: int n_reader;
! 31712:
! 31713: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31714: mem_base = xmlMemBlocks();
! 31715: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31716:
! 31717: ret_val = xmlTextReaderMoveToNextAttribute(reader);
! 31718: desret_int(ret_val);
! 31719: call_tests++;
! 31720: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31721: xmlResetLastError();
! 31722: if (mem_base != xmlMemBlocks()) {
! 31723: printf("Leak of %d blocks found in xmlTextReaderMoveToNextAttribute",
! 31724: xmlMemBlocks() - mem_base);
! 31725: test_ret++;
! 31726: printf(" %d", n_reader);
! 31727: printf("\n");
! 31728: }
! 31729: }
! 31730: function_tests++;
! 31731: #endif
! 31732:
! 31733: return(test_ret);
! 31734: }
! 31735:
! 31736:
! 31737: static int
! 31738: test_xmlTextReaderName(void) {
! 31739: int test_ret = 0;
! 31740:
! 31741: #if defined(LIBXML_READER_ENABLED)
! 31742: int mem_base;
! 31743: xmlChar * ret_val;
! 31744: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31745: int n_reader;
! 31746:
! 31747: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31748: mem_base = xmlMemBlocks();
! 31749: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31750:
! 31751: ret_val = xmlTextReaderName(reader);
! 31752: desret_xmlChar_ptr(ret_val);
! 31753: call_tests++;
! 31754: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31755: xmlResetLastError();
! 31756: if (mem_base != xmlMemBlocks()) {
! 31757: printf("Leak of %d blocks found in xmlTextReaderName",
! 31758: xmlMemBlocks() - mem_base);
! 31759: test_ret++;
! 31760: printf(" %d", n_reader);
! 31761: printf("\n");
! 31762: }
! 31763: }
! 31764: function_tests++;
! 31765: #endif
! 31766:
! 31767: return(test_ret);
! 31768: }
! 31769:
! 31770:
! 31771: static int
! 31772: test_xmlTextReaderNamespaceUri(void) {
! 31773: int test_ret = 0;
! 31774:
! 31775: #if defined(LIBXML_READER_ENABLED)
! 31776: int mem_base;
! 31777: xmlChar * ret_val;
! 31778: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31779: int n_reader;
! 31780:
! 31781: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31782: mem_base = xmlMemBlocks();
! 31783: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31784:
! 31785: ret_val = xmlTextReaderNamespaceUri(reader);
! 31786: desret_xmlChar_ptr(ret_val);
! 31787: call_tests++;
! 31788: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31789: xmlResetLastError();
! 31790: if (mem_base != xmlMemBlocks()) {
! 31791: printf("Leak of %d blocks found in xmlTextReaderNamespaceUri",
! 31792: xmlMemBlocks() - mem_base);
! 31793: test_ret++;
! 31794: printf(" %d", n_reader);
! 31795: printf("\n");
! 31796: }
! 31797: }
! 31798: function_tests++;
! 31799: #endif
! 31800:
! 31801: return(test_ret);
! 31802: }
! 31803:
! 31804:
! 31805: static int
! 31806: test_xmlTextReaderNext(void) {
! 31807: int test_ret = 0;
! 31808:
! 31809: #if defined(LIBXML_READER_ENABLED)
! 31810: int mem_base;
! 31811: int ret_val;
! 31812: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31813: int n_reader;
! 31814:
! 31815: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31816: mem_base = xmlMemBlocks();
! 31817: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31818:
! 31819: ret_val = xmlTextReaderNext(reader);
! 31820: desret_int(ret_val);
! 31821: call_tests++;
! 31822: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31823: xmlResetLastError();
! 31824: if (mem_base != xmlMemBlocks()) {
! 31825: printf("Leak of %d blocks found in xmlTextReaderNext",
! 31826: xmlMemBlocks() - mem_base);
! 31827: test_ret++;
! 31828: printf(" %d", n_reader);
! 31829: printf("\n");
! 31830: }
! 31831: }
! 31832: function_tests++;
! 31833: #endif
! 31834:
! 31835: return(test_ret);
! 31836: }
! 31837:
! 31838:
! 31839: static int
! 31840: test_xmlTextReaderNextSibling(void) {
! 31841: int test_ret = 0;
! 31842:
! 31843: #if defined(LIBXML_READER_ENABLED)
! 31844: int mem_base;
! 31845: int ret_val;
! 31846: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31847: int n_reader;
! 31848:
! 31849: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31850: mem_base = xmlMemBlocks();
! 31851: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31852:
! 31853: ret_val = xmlTextReaderNextSibling(reader);
! 31854: desret_int(ret_val);
! 31855: call_tests++;
! 31856: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31857: xmlResetLastError();
! 31858: if (mem_base != xmlMemBlocks()) {
! 31859: printf("Leak of %d blocks found in xmlTextReaderNextSibling",
! 31860: xmlMemBlocks() - mem_base);
! 31861: test_ret++;
! 31862: printf(" %d", n_reader);
! 31863: printf("\n");
! 31864: }
! 31865: }
! 31866: function_tests++;
! 31867: #endif
! 31868:
! 31869: return(test_ret);
! 31870: }
! 31871:
! 31872:
! 31873: static int
! 31874: test_xmlTextReaderNodeType(void) {
! 31875: int test_ret = 0;
! 31876:
! 31877: #if defined(LIBXML_READER_ENABLED)
! 31878: int mem_base;
! 31879: int ret_val;
! 31880: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31881: int n_reader;
! 31882:
! 31883: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31884: mem_base = xmlMemBlocks();
! 31885: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31886:
! 31887: ret_val = xmlTextReaderNodeType(reader);
! 31888: desret_int(ret_val);
! 31889: call_tests++;
! 31890: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31891: xmlResetLastError();
! 31892: if (mem_base != xmlMemBlocks()) {
! 31893: printf("Leak of %d blocks found in xmlTextReaderNodeType",
! 31894: xmlMemBlocks() - mem_base);
! 31895: test_ret++;
! 31896: printf(" %d", n_reader);
! 31897: printf("\n");
! 31898: }
! 31899: }
! 31900: function_tests++;
! 31901: #endif
! 31902:
! 31903: return(test_ret);
! 31904: }
! 31905:
! 31906:
! 31907: static int
! 31908: test_xmlTextReaderNormalization(void) {
! 31909: int test_ret = 0;
! 31910:
! 31911: #if defined(LIBXML_READER_ENABLED)
! 31912: int mem_base;
! 31913: int ret_val;
! 31914: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31915: int n_reader;
! 31916:
! 31917: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31918: mem_base = xmlMemBlocks();
! 31919: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31920:
! 31921: ret_val = xmlTextReaderNormalization(reader);
! 31922: desret_int(ret_val);
! 31923: call_tests++;
! 31924: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31925: xmlResetLastError();
! 31926: if (mem_base != xmlMemBlocks()) {
! 31927: printf("Leak of %d blocks found in xmlTextReaderNormalization",
! 31928: xmlMemBlocks() - mem_base);
! 31929: test_ret++;
! 31930: printf(" %d", n_reader);
! 31931: printf("\n");
! 31932: }
! 31933: }
! 31934: function_tests++;
! 31935: #endif
! 31936:
! 31937: return(test_ret);
! 31938: }
! 31939:
! 31940:
! 31941: static int
! 31942: test_xmlTextReaderPrefix(void) {
! 31943: int test_ret = 0;
! 31944:
! 31945: #if defined(LIBXML_READER_ENABLED)
! 31946: int mem_base;
! 31947: xmlChar * ret_val;
! 31948: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31949: int n_reader;
! 31950:
! 31951: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31952: mem_base = xmlMemBlocks();
! 31953: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31954:
! 31955: ret_val = xmlTextReaderPrefix(reader);
! 31956: desret_xmlChar_ptr(ret_val);
! 31957: call_tests++;
! 31958: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31959: xmlResetLastError();
! 31960: if (mem_base != xmlMemBlocks()) {
! 31961: printf("Leak of %d blocks found in xmlTextReaderPrefix",
! 31962: xmlMemBlocks() - mem_base);
! 31963: test_ret++;
! 31964: printf(" %d", n_reader);
! 31965: printf("\n");
! 31966: }
! 31967: }
! 31968: function_tests++;
! 31969: #endif
! 31970:
! 31971: return(test_ret);
! 31972: }
! 31973:
! 31974:
! 31975: static int
! 31976: test_xmlTextReaderPreserve(void) {
! 31977: int test_ret = 0;
! 31978:
! 31979: #if defined(LIBXML_READER_ENABLED)
! 31980: int mem_base;
! 31981: xmlNodePtr ret_val;
! 31982: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 31983: int n_reader;
! 31984:
! 31985: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 31986: mem_base = xmlMemBlocks();
! 31987: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 31988:
! 31989: ret_val = xmlTextReaderPreserve(reader);
! 31990: desret_xmlNodePtr(ret_val);
! 31991: call_tests++;
! 31992: des_xmlTextReaderPtr(n_reader, reader, 0);
! 31993: xmlResetLastError();
! 31994: if (mem_base != xmlMemBlocks()) {
! 31995: printf("Leak of %d blocks found in xmlTextReaderPreserve",
! 31996: xmlMemBlocks() - mem_base);
! 31997: test_ret++;
! 31998: printf(" %d", n_reader);
! 31999: printf("\n");
! 32000: }
! 32001: }
! 32002: function_tests++;
! 32003: #endif
! 32004:
! 32005: return(test_ret);
! 32006: }
! 32007:
! 32008:
! 32009: static int
! 32010: test_xmlTextReaderPreservePattern(void) {
! 32011: int test_ret = 0;
! 32012:
! 32013: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_PATTERN_ENABLED)
! 32014: #ifdef LIBXML_PATTERN_ENABLED
! 32015: int mem_base;
! 32016: int ret_val;
! 32017: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 32018: int n_reader;
! 32019: xmlChar * pattern; /* an XPath subset pattern */
! 32020: int n_pattern;
! 32021: xmlChar ** namespaces; /* the prefix definitions, array of [URI, prefix] or NULL */
! 32022: int n_namespaces;
! 32023:
! 32024: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 32025: for (n_pattern = 0;n_pattern < gen_nb_const_xmlChar_ptr;n_pattern++) {
! 32026: for (n_namespaces = 0;n_namespaces < gen_nb_const_xmlChar_ptr_ptr;n_namespaces++) {
! 32027: mem_base = xmlMemBlocks();
! 32028: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 32029: pattern = gen_const_xmlChar_ptr(n_pattern, 1);
! 32030: namespaces = gen_const_xmlChar_ptr_ptr(n_namespaces, 2);
! 32031:
! 32032: ret_val = xmlTextReaderPreservePattern(reader, (const xmlChar *)pattern, (const xmlChar **)namespaces);
! 32033: desret_int(ret_val);
! 32034: call_tests++;
! 32035: des_xmlTextReaderPtr(n_reader, reader, 0);
! 32036: des_const_xmlChar_ptr(n_pattern, (const xmlChar *)pattern, 1);
! 32037: des_const_xmlChar_ptr_ptr(n_namespaces, (const xmlChar **)namespaces, 2);
! 32038: xmlResetLastError();
! 32039: if (mem_base != xmlMemBlocks()) {
! 32040: printf("Leak of %d blocks found in xmlTextReaderPreservePattern",
! 32041: xmlMemBlocks() - mem_base);
! 32042: test_ret++;
! 32043: printf(" %d", n_reader);
! 32044: printf(" %d", n_pattern);
! 32045: printf(" %d", n_namespaces);
! 32046: printf("\n");
! 32047: }
! 32048: }
! 32049: }
! 32050: }
! 32051: function_tests++;
! 32052: #endif
! 32053: #endif
! 32054:
! 32055: return(test_ret);
! 32056: }
! 32057:
! 32058:
! 32059: static int
! 32060: test_xmlTextReaderQuoteChar(void) {
! 32061: int test_ret = 0;
! 32062:
! 32063: #if defined(LIBXML_READER_ENABLED)
! 32064: int mem_base;
! 32065: int ret_val;
! 32066: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 32067: int n_reader;
! 32068:
! 32069: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 32070: mem_base = xmlMemBlocks();
! 32071: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 32072:
! 32073: ret_val = xmlTextReaderQuoteChar(reader);
! 32074: desret_int(ret_val);
! 32075: call_tests++;
! 32076: des_xmlTextReaderPtr(n_reader, reader, 0);
! 32077: xmlResetLastError();
! 32078: if (mem_base != xmlMemBlocks()) {
! 32079: printf("Leak of %d blocks found in xmlTextReaderQuoteChar",
! 32080: xmlMemBlocks() - mem_base);
! 32081: test_ret++;
! 32082: printf(" %d", n_reader);
! 32083: printf("\n");
! 32084: }
! 32085: }
! 32086: function_tests++;
! 32087: #endif
! 32088:
! 32089: return(test_ret);
! 32090: }
! 32091:
! 32092:
! 32093: static int
! 32094: test_xmlTextReaderRead(void) {
! 32095: int test_ret = 0;
! 32096:
! 32097: #if defined(LIBXML_READER_ENABLED)
! 32098: int mem_base;
! 32099: int ret_val;
! 32100: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 32101: int n_reader;
! 32102:
! 32103: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 32104: mem_base = xmlMemBlocks();
! 32105: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 32106:
! 32107: ret_val = xmlTextReaderRead(reader);
! 32108: desret_int(ret_val);
! 32109: call_tests++;
! 32110: des_xmlTextReaderPtr(n_reader, reader, 0);
! 32111: xmlResetLastError();
! 32112: if (mem_base != xmlMemBlocks()) {
! 32113: printf("Leak of %d blocks found in xmlTextReaderRead",
! 32114: xmlMemBlocks() - mem_base);
! 32115: test_ret++;
! 32116: printf(" %d", n_reader);
! 32117: printf("\n");
! 32118: }
! 32119: }
! 32120: function_tests++;
! 32121: #endif
! 32122:
! 32123: return(test_ret);
! 32124: }
! 32125:
! 32126:
! 32127: static int
! 32128: test_xmlTextReaderReadAttributeValue(void) {
! 32129: int test_ret = 0;
! 32130:
! 32131: #if defined(LIBXML_READER_ENABLED)
! 32132: int mem_base;
! 32133: int ret_val;
! 32134: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 32135: int n_reader;
! 32136:
! 32137: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 32138: mem_base = xmlMemBlocks();
! 32139: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 32140:
! 32141: ret_val = xmlTextReaderReadAttributeValue(reader);
! 32142: desret_int(ret_val);
! 32143: call_tests++;
! 32144: des_xmlTextReaderPtr(n_reader, reader, 0);
! 32145: xmlResetLastError();
! 32146: if (mem_base != xmlMemBlocks()) {
! 32147: printf("Leak of %d blocks found in xmlTextReaderReadAttributeValue",
! 32148: xmlMemBlocks() - mem_base);
! 32149: test_ret++;
! 32150: printf(" %d", n_reader);
! 32151: printf("\n");
! 32152: }
! 32153: }
! 32154: function_tests++;
! 32155: #endif
! 32156:
! 32157: return(test_ret);
! 32158: }
! 32159:
! 32160:
! 32161: static int
! 32162: test_xmlTextReaderReadState(void) {
! 32163: int test_ret = 0;
! 32164:
! 32165: #if defined(LIBXML_READER_ENABLED)
! 32166: int mem_base;
! 32167: int ret_val;
! 32168: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 32169: int n_reader;
! 32170:
! 32171: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 32172: mem_base = xmlMemBlocks();
! 32173: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 32174:
! 32175: ret_val = xmlTextReaderReadState(reader);
! 32176: desret_int(ret_val);
! 32177: call_tests++;
! 32178: des_xmlTextReaderPtr(n_reader, reader, 0);
! 32179: xmlResetLastError();
! 32180: if (mem_base != xmlMemBlocks()) {
! 32181: printf("Leak of %d blocks found in xmlTextReaderReadState",
! 32182: xmlMemBlocks() - mem_base);
! 32183: test_ret++;
! 32184: printf(" %d", n_reader);
! 32185: printf("\n");
! 32186: }
! 32187: }
! 32188: function_tests++;
! 32189: #endif
! 32190:
! 32191: return(test_ret);
! 32192: }
! 32193:
! 32194:
! 32195: static int
! 32196: test_xmlTextReaderRelaxNGSetSchema(void) {
! 32197: int test_ret = 0;
! 32198:
! 32199: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
! 32200: int mem_base;
! 32201: int ret_val;
! 32202: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 32203: int n_reader;
! 32204: xmlRelaxNGPtr schema; /* a precompiled RelaxNG schema */
! 32205: int n_schema;
! 32206:
! 32207: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 32208: for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) {
! 32209: mem_base = xmlMemBlocks();
! 32210: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 32211: schema = gen_xmlRelaxNGPtr(n_schema, 1);
! 32212:
! 32213: ret_val = xmlTextReaderRelaxNGSetSchema(reader, schema);
! 32214: desret_int(ret_val);
! 32215: call_tests++;
! 32216: des_xmlTextReaderPtr(n_reader, reader, 0);
! 32217: des_xmlRelaxNGPtr(n_schema, schema, 1);
! 32218: xmlResetLastError();
! 32219: if (mem_base != xmlMemBlocks()) {
! 32220: printf("Leak of %d blocks found in xmlTextReaderRelaxNGSetSchema",
! 32221: xmlMemBlocks() - mem_base);
! 32222: test_ret++;
! 32223: printf(" %d", n_reader);
! 32224: printf(" %d", n_schema);
! 32225: printf("\n");
! 32226: }
! 32227: }
! 32228: }
! 32229: function_tests++;
! 32230: #endif
! 32231:
! 32232: return(test_ret);
! 32233: }
! 32234:
! 32235:
! 32236: static int
! 32237: test_xmlTextReaderRelaxNGValidate(void) {
! 32238: int test_ret = 0;
! 32239:
! 32240: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
! 32241: int mem_base;
! 32242: int ret_val;
! 32243: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 32244: int n_reader;
! 32245: char * rng; /* the path to a RelaxNG schema or NULL */
! 32246: int n_rng;
! 32247:
! 32248: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 32249: for (n_rng = 0;n_rng < gen_nb_const_char_ptr;n_rng++) {
! 32250: mem_base = xmlMemBlocks();
! 32251: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 32252: rng = gen_const_char_ptr(n_rng, 1);
! 32253:
! 32254: ret_val = xmlTextReaderRelaxNGValidate(reader, (const char *)rng);
! 32255: desret_int(ret_val);
! 32256: call_tests++;
! 32257: des_xmlTextReaderPtr(n_reader, reader, 0);
! 32258: des_const_char_ptr(n_rng, (const char *)rng, 1);
! 32259: xmlResetLastError();
! 32260: if (mem_base != xmlMemBlocks()) {
! 32261: printf("Leak of %d blocks found in xmlTextReaderRelaxNGValidate",
! 32262: xmlMemBlocks() - mem_base);
! 32263: test_ret++;
! 32264: printf(" %d", n_reader);
! 32265: printf(" %d", n_rng);
! 32266: printf("\n");
! 32267: }
! 32268: }
! 32269: }
! 32270: function_tests++;
! 32271: #endif
! 32272:
! 32273: return(test_ret);
! 32274: }
! 32275:
! 32276:
! 32277: static int
! 32278: test_xmlTextReaderSchemaValidate(void) {
! 32279: int test_ret = 0;
! 32280:
! 32281: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
! 32282: int ret_val;
! 32283: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 32284: int n_reader;
! 32285: char * xsd; /* the path to a W3C XSD schema or NULL */
! 32286: int n_xsd;
! 32287:
! 32288: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 32289: for (n_xsd = 0;n_xsd < gen_nb_const_char_ptr;n_xsd++) {
! 32290: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 32291: xsd = gen_const_char_ptr(n_xsd, 1);
! 32292:
! 32293: ret_val = xmlTextReaderSchemaValidate(reader, (const char *)xsd);
! 32294: desret_int(ret_val);
! 32295: call_tests++;
! 32296: des_xmlTextReaderPtr(n_reader, reader, 0);
! 32297: des_const_char_ptr(n_xsd, (const char *)xsd, 1);
! 32298: xmlResetLastError();
! 32299: }
! 32300: }
! 32301: function_tests++;
! 32302: #endif
! 32303:
! 32304: return(test_ret);
! 32305: }
! 32306:
! 32307:
! 32308: static int
! 32309: test_xmlTextReaderSchemaValidateCtxt(void) {
! 32310: int test_ret = 0;
! 32311:
! 32312: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
! 32313: int mem_base;
! 32314: int ret_val;
! 32315: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 32316: int n_reader;
! 32317: xmlSchemaValidCtxtPtr ctxt; /* the XML Schema validation context or NULL */
! 32318: int n_ctxt;
! 32319: int options; /* options (not used yet) */
! 32320: int n_options;
! 32321:
! 32322: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 32323: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
! 32324: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
! 32325: mem_base = xmlMemBlocks();
! 32326: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 32327: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 1);
! 32328: options = gen_parseroptions(n_options, 2);
! 32329:
! 32330: ret_val = xmlTextReaderSchemaValidateCtxt(reader, ctxt, options);
! 32331: desret_int(ret_val);
! 32332: call_tests++;
! 32333: des_xmlTextReaderPtr(n_reader, reader, 0);
! 32334: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 1);
! 32335: des_parseroptions(n_options, options, 2);
! 32336: xmlResetLastError();
! 32337: if (mem_base != xmlMemBlocks()) {
! 32338: printf("Leak of %d blocks found in xmlTextReaderSchemaValidateCtxt",
! 32339: xmlMemBlocks() - mem_base);
! 32340: test_ret++;
! 32341: printf(" %d", n_reader);
! 32342: printf(" %d", n_ctxt);
! 32343: printf(" %d", n_options);
! 32344: printf("\n");
! 32345: }
! 32346: }
! 32347: }
! 32348: }
! 32349: function_tests++;
! 32350: #endif
! 32351:
! 32352: return(test_ret);
! 32353: }
! 32354:
! 32355:
! 32356: static int
! 32357: test_xmlTextReaderSetErrorHandler(void) {
! 32358: int test_ret = 0;
! 32359:
! 32360:
! 32361: /* missing type support */
! 32362: return(test_ret);
! 32363: }
! 32364:
! 32365:
! 32366: static int
! 32367: test_xmlTextReaderSetParserProp(void) {
! 32368: int test_ret = 0;
! 32369:
! 32370: #if defined(LIBXML_READER_ENABLED)
! 32371: int mem_base;
! 32372: int ret_val;
! 32373: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 32374: int n_reader;
! 32375: int prop; /* the xmlParserProperties to set */
! 32376: int n_prop;
! 32377: int value; /* usually 0 or 1 to (de)activate it */
! 32378: int n_value;
! 32379:
! 32380: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 32381: for (n_prop = 0;n_prop < gen_nb_int;n_prop++) {
! 32382: for (n_value = 0;n_value < gen_nb_int;n_value++) {
! 32383: mem_base = xmlMemBlocks();
! 32384: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 32385: prop = gen_int(n_prop, 1);
! 32386: value = gen_int(n_value, 2);
! 32387:
! 32388: ret_val = xmlTextReaderSetParserProp(reader, prop, value);
! 32389: desret_int(ret_val);
! 32390: call_tests++;
! 32391: des_xmlTextReaderPtr(n_reader, reader, 0);
! 32392: des_int(n_prop, prop, 1);
! 32393: des_int(n_value, value, 2);
! 32394: xmlResetLastError();
! 32395: if (mem_base != xmlMemBlocks()) {
! 32396: printf("Leak of %d blocks found in xmlTextReaderSetParserProp",
! 32397: xmlMemBlocks() - mem_base);
! 32398: test_ret++;
! 32399: printf(" %d", n_reader);
! 32400: printf(" %d", n_prop);
! 32401: printf(" %d", n_value);
! 32402: printf("\n");
! 32403: }
! 32404: }
! 32405: }
! 32406: }
! 32407: function_tests++;
! 32408: #endif
! 32409:
! 32410: return(test_ret);
! 32411: }
! 32412:
! 32413:
! 32414: static int
! 32415: test_xmlTextReaderSetSchema(void) {
! 32416: int test_ret = 0;
! 32417:
! 32418: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
! 32419: int mem_base;
! 32420: int ret_val;
! 32421: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 32422: int n_reader;
! 32423: xmlSchemaPtr schema; /* a precompiled Schema schema */
! 32424: int n_schema;
! 32425:
! 32426: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 32427: for (n_schema = 0;n_schema < gen_nb_xmlSchemaPtr;n_schema++) {
! 32428: mem_base = xmlMemBlocks();
! 32429: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 32430: schema = gen_xmlSchemaPtr(n_schema, 1);
! 32431:
! 32432: ret_val = xmlTextReaderSetSchema(reader, schema);
! 32433: desret_int(ret_val);
! 32434: call_tests++;
! 32435: des_xmlTextReaderPtr(n_reader, reader, 0);
! 32436: des_xmlSchemaPtr(n_schema, schema, 1);
! 32437: xmlResetLastError();
! 32438: if (mem_base != xmlMemBlocks()) {
! 32439: printf("Leak of %d blocks found in xmlTextReaderSetSchema",
! 32440: xmlMemBlocks() - mem_base);
! 32441: test_ret++;
! 32442: printf(" %d", n_reader);
! 32443: printf(" %d", n_schema);
! 32444: printf("\n");
! 32445: }
! 32446: }
! 32447: }
! 32448: function_tests++;
! 32449: #endif
! 32450:
! 32451: return(test_ret);
! 32452: }
! 32453:
! 32454:
! 32455: static int
! 32456: test_xmlTextReaderSetStructuredErrorHandler(void) {
! 32457: int test_ret = 0;
! 32458:
! 32459:
! 32460: /* missing type support */
! 32461: return(test_ret);
! 32462: }
! 32463:
! 32464:
! 32465: static int
! 32466: test_xmlTextReaderSetup(void) {
! 32467: int test_ret = 0;
! 32468:
! 32469: #if defined(LIBXML_READER_ENABLED)
! 32470: int mem_base;
! 32471: int ret_val;
! 32472: xmlTextReaderPtr reader; /* an XML reader */
! 32473: int n_reader;
! 32474: xmlParserInputBufferPtr input; /* xmlParserInputBufferPtr used to feed the reader, will be destroyed with it. */
! 32475: int n_input;
! 32476: const char * URL; /* the base URL to use for the document */
! 32477: int n_URL;
! 32478: char * encoding; /* the document encoding, or NULL */
! 32479: int n_encoding;
! 32480: int options; /* a combination of xmlParserOption */
! 32481: int n_options;
! 32482:
! 32483: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 32484: for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
! 32485: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
! 32486: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 32487: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
! 32488: mem_base = xmlMemBlocks();
! 32489: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 32490: input = gen_xmlParserInputBufferPtr(n_input, 1);
! 32491: URL = gen_filepath(n_URL, 2);
! 32492: encoding = gen_const_char_ptr(n_encoding, 3);
! 32493: options = gen_parseroptions(n_options, 4);
! 32494:
! 32495: ret_val = xmlTextReaderSetup(reader, input, URL, (const char *)encoding, options);
! 32496: desret_int(ret_val);
! 32497: call_tests++;
! 32498: des_xmlTextReaderPtr(n_reader, reader, 0);
! 32499: des_filepath(n_URL, URL, 2);
! 32500: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
! 32501: des_parseroptions(n_options, options, 4);
! 32502: xmlResetLastError();
! 32503: if (mem_base != xmlMemBlocks()) {
! 32504: printf("Leak of %d blocks found in xmlTextReaderSetup",
! 32505: xmlMemBlocks() - mem_base);
! 32506: test_ret++;
! 32507: printf(" %d", n_reader);
! 32508: printf(" %d", n_input);
! 32509: printf(" %d", n_URL);
! 32510: printf(" %d", n_encoding);
! 32511: printf(" %d", n_options);
! 32512: printf("\n");
! 32513: }
! 32514: }
! 32515: }
! 32516: }
! 32517: }
! 32518: }
! 32519: function_tests++;
! 32520: #endif
! 32521:
! 32522: return(test_ret);
! 32523: }
! 32524:
! 32525:
! 32526: static int
! 32527: test_xmlTextReaderStandalone(void) {
! 32528: int test_ret = 0;
! 32529:
! 32530: #if defined(LIBXML_READER_ENABLED)
! 32531: int mem_base;
! 32532: int ret_val;
! 32533: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 32534: int n_reader;
! 32535:
! 32536: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 32537: mem_base = xmlMemBlocks();
! 32538: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 32539:
! 32540: ret_val = xmlTextReaderStandalone(reader);
! 32541: desret_int(ret_val);
! 32542: call_tests++;
! 32543: des_xmlTextReaderPtr(n_reader, reader, 0);
! 32544: xmlResetLastError();
! 32545: if (mem_base != xmlMemBlocks()) {
! 32546: printf("Leak of %d blocks found in xmlTextReaderStandalone",
! 32547: xmlMemBlocks() - mem_base);
! 32548: test_ret++;
! 32549: printf(" %d", n_reader);
! 32550: printf("\n");
! 32551: }
! 32552: }
! 32553: function_tests++;
! 32554: #endif
! 32555:
! 32556: return(test_ret);
! 32557: }
! 32558:
! 32559:
! 32560: static int
! 32561: test_xmlTextReaderValue(void) {
! 32562: int test_ret = 0;
! 32563:
! 32564: #if defined(LIBXML_READER_ENABLED)
! 32565: int mem_base;
! 32566: xmlChar * ret_val;
! 32567: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 32568: int n_reader;
! 32569:
! 32570: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 32571: mem_base = xmlMemBlocks();
! 32572: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 32573:
! 32574: ret_val = xmlTextReaderValue(reader);
! 32575: desret_xmlChar_ptr(ret_val);
! 32576: call_tests++;
! 32577: des_xmlTextReaderPtr(n_reader, reader, 0);
! 32578: xmlResetLastError();
! 32579: if (mem_base != xmlMemBlocks()) {
! 32580: printf("Leak of %d blocks found in xmlTextReaderValue",
! 32581: xmlMemBlocks() - mem_base);
! 32582: test_ret++;
! 32583: printf(" %d", n_reader);
! 32584: printf("\n");
! 32585: }
! 32586: }
! 32587: function_tests++;
! 32588: #endif
! 32589:
! 32590: return(test_ret);
! 32591: }
! 32592:
! 32593:
! 32594: static int
! 32595: test_xmlTextReaderXmlLang(void) {
! 32596: int test_ret = 0;
! 32597:
! 32598: #if defined(LIBXML_READER_ENABLED)
! 32599: int mem_base;
! 32600: xmlChar * ret_val;
! 32601: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 32602: int n_reader;
! 32603:
! 32604: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 32605: mem_base = xmlMemBlocks();
! 32606: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 32607:
! 32608: ret_val = xmlTextReaderXmlLang(reader);
! 32609: desret_xmlChar_ptr(ret_val);
! 32610: call_tests++;
! 32611: des_xmlTextReaderPtr(n_reader, reader, 0);
! 32612: xmlResetLastError();
! 32613: if (mem_base != xmlMemBlocks()) {
! 32614: printf("Leak of %d blocks found in xmlTextReaderXmlLang",
! 32615: xmlMemBlocks() - mem_base);
! 32616: test_ret++;
! 32617: printf(" %d", n_reader);
! 32618: printf("\n");
! 32619: }
! 32620: }
! 32621: function_tests++;
! 32622: #endif
! 32623:
! 32624: return(test_ret);
! 32625: }
! 32626:
! 32627: static int
! 32628: test_xmlreader(void) {
! 32629: int test_ret = 0;
! 32630:
! 32631: if (quiet == 0) printf("Testing xmlreader : 75 of 85 functions ...\n");
! 32632: test_ret += test_xmlNewTextReader();
! 32633: test_ret += test_xmlNewTextReaderFilename();
! 32634: test_ret += test_xmlReaderForDoc();
! 32635: test_ret += test_xmlReaderForFile();
! 32636: test_ret += test_xmlReaderForMemory();
! 32637: test_ret += test_xmlReaderNewDoc();
! 32638: test_ret += test_xmlReaderNewFile();
! 32639: test_ret += test_xmlReaderNewMemory();
! 32640: test_ret += test_xmlReaderNewWalker();
! 32641: test_ret += test_xmlReaderWalker();
! 32642: test_ret += test_xmlTextReaderAttributeCount();
! 32643: test_ret += test_xmlTextReaderBaseUri();
! 32644: test_ret += test_xmlTextReaderByteConsumed();
! 32645: test_ret += test_xmlTextReaderClose();
! 32646: test_ret += test_xmlTextReaderConstBaseUri();
! 32647: test_ret += test_xmlTextReaderConstEncoding();
! 32648: test_ret += test_xmlTextReaderConstLocalName();
! 32649: test_ret += test_xmlTextReaderConstName();
! 32650: test_ret += test_xmlTextReaderConstNamespaceUri();
! 32651: test_ret += test_xmlTextReaderConstPrefix();
! 32652: test_ret += test_xmlTextReaderConstString();
! 32653: test_ret += test_xmlTextReaderConstValue();
! 32654: test_ret += test_xmlTextReaderConstXmlLang();
! 32655: test_ret += test_xmlTextReaderConstXmlVersion();
! 32656: test_ret += test_xmlTextReaderCurrentDoc();
! 32657: test_ret += test_xmlTextReaderCurrentNode();
! 32658: test_ret += test_xmlTextReaderDepth();
! 32659: test_ret += test_xmlTextReaderExpand();
! 32660: test_ret += test_xmlTextReaderGetAttribute();
! 32661: test_ret += test_xmlTextReaderGetAttributeNo();
! 32662: test_ret += test_xmlTextReaderGetAttributeNs();
! 32663: test_ret += test_xmlTextReaderGetErrorHandler();
! 32664: test_ret += test_xmlTextReaderGetParserColumnNumber();
! 32665: test_ret += test_xmlTextReaderGetParserLineNumber();
! 32666: test_ret += test_xmlTextReaderGetParserProp();
! 32667: test_ret += test_xmlTextReaderGetRemainder();
! 32668: test_ret += test_xmlTextReaderHasAttributes();
! 32669: test_ret += test_xmlTextReaderHasValue();
! 32670: test_ret += test_xmlTextReaderIsDefault();
! 32671: test_ret += test_xmlTextReaderIsEmptyElement();
! 32672: test_ret += test_xmlTextReaderIsNamespaceDecl();
! 32673: test_ret += test_xmlTextReaderIsValid();
! 32674: test_ret += test_xmlTextReaderLocalName();
! 32675: test_ret += test_xmlTextReaderLocatorBaseURI();
! 32676: test_ret += test_xmlTextReaderLocatorLineNumber();
! 32677: test_ret += test_xmlTextReaderLookupNamespace();
! 32678: test_ret += test_xmlTextReaderMoveToAttribute();
! 32679: test_ret += test_xmlTextReaderMoveToAttributeNo();
! 32680: test_ret += test_xmlTextReaderMoveToAttributeNs();
! 32681: test_ret += test_xmlTextReaderMoveToElement();
! 32682: test_ret += test_xmlTextReaderMoveToFirstAttribute();
! 32683: test_ret += test_xmlTextReaderMoveToNextAttribute();
! 32684: test_ret += test_xmlTextReaderName();
! 32685: test_ret += test_xmlTextReaderNamespaceUri();
! 32686: test_ret += test_xmlTextReaderNext();
! 32687: test_ret += test_xmlTextReaderNextSibling();
! 32688: test_ret += test_xmlTextReaderNodeType();
! 32689: test_ret += test_xmlTextReaderNormalization();
! 32690: test_ret += test_xmlTextReaderPrefix();
! 32691: test_ret += test_xmlTextReaderPreserve();
! 32692: test_ret += test_xmlTextReaderPreservePattern();
! 32693: test_ret += test_xmlTextReaderQuoteChar();
! 32694: test_ret += test_xmlTextReaderRead();
! 32695: test_ret += test_xmlTextReaderReadAttributeValue();
! 32696: test_ret += test_xmlTextReaderReadState();
! 32697: test_ret += test_xmlTextReaderRelaxNGSetSchema();
! 32698: test_ret += test_xmlTextReaderRelaxNGValidate();
! 32699: test_ret += test_xmlTextReaderSchemaValidate();
! 32700: test_ret += test_xmlTextReaderSchemaValidateCtxt();
! 32701: test_ret += test_xmlTextReaderSetErrorHandler();
! 32702: test_ret += test_xmlTextReaderSetParserProp();
! 32703: test_ret += test_xmlTextReaderSetSchema();
! 32704: test_ret += test_xmlTextReaderSetStructuredErrorHandler();
! 32705: test_ret += test_xmlTextReaderSetup();
! 32706: test_ret += test_xmlTextReaderStandalone();
! 32707: test_ret += test_xmlTextReaderValue();
! 32708: test_ret += test_xmlTextReaderXmlLang();
! 32709:
! 32710: if (test_ret != 0)
! 32711: printf("Module xmlreader: %d errors\n", test_ret);
! 32712: return(test_ret);
! 32713: }
! 32714:
! 32715: static int
! 32716: test_xmlExpCtxtNbCons(void) {
! 32717: int test_ret = 0;
! 32718:
! 32719: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
! 32720: int mem_base;
! 32721: int ret_val;
! 32722: xmlExpCtxtPtr ctxt; /* an expression context */
! 32723: int n_ctxt;
! 32724:
! 32725: for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
! 32726: mem_base = xmlMemBlocks();
! 32727: ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
! 32728:
! 32729: ret_val = xmlExpCtxtNbCons(ctxt);
! 32730: desret_int(ret_val);
! 32731: call_tests++;
! 32732: des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
! 32733: xmlResetLastError();
! 32734: if (mem_base != xmlMemBlocks()) {
! 32735: printf("Leak of %d blocks found in xmlExpCtxtNbCons",
! 32736: xmlMemBlocks() - mem_base);
! 32737: test_ret++;
! 32738: printf(" %d", n_ctxt);
! 32739: printf("\n");
! 32740: }
! 32741: }
! 32742: function_tests++;
! 32743: #endif
! 32744:
! 32745: return(test_ret);
! 32746: }
! 32747:
! 32748:
! 32749: static int
! 32750: test_xmlExpCtxtNbNodes(void) {
! 32751: int test_ret = 0;
! 32752:
! 32753: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
! 32754: int mem_base;
! 32755: int ret_val;
! 32756: xmlExpCtxtPtr ctxt; /* an expression context */
! 32757: int n_ctxt;
! 32758:
! 32759: for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
! 32760: mem_base = xmlMemBlocks();
! 32761: ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
! 32762:
! 32763: ret_val = xmlExpCtxtNbNodes(ctxt);
! 32764: desret_int(ret_val);
! 32765: call_tests++;
! 32766: des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
! 32767: xmlResetLastError();
! 32768: if (mem_base != xmlMemBlocks()) {
! 32769: printf("Leak of %d blocks found in xmlExpCtxtNbNodes",
! 32770: xmlMemBlocks() - mem_base);
! 32771: test_ret++;
! 32772: printf(" %d", n_ctxt);
! 32773: printf("\n");
! 32774: }
! 32775: }
! 32776: function_tests++;
! 32777: #endif
! 32778:
! 32779: return(test_ret);
! 32780: }
! 32781:
! 32782:
! 32783: static int
! 32784: test_xmlExpDump(void) {
! 32785: int test_ret = 0;
! 32786:
! 32787: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
! 32788: int mem_base;
! 32789: xmlBufferPtr buf; /* a buffer to receive the output */
! 32790: int n_buf;
! 32791: xmlExpNodePtr expr; /* the compiled expression */
! 32792: int n_expr;
! 32793:
! 32794: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 32795: for (n_expr = 0;n_expr < gen_nb_xmlExpNodePtr;n_expr++) {
! 32796: mem_base = xmlMemBlocks();
! 32797: buf = gen_xmlBufferPtr(n_buf, 0);
! 32798: expr = gen_xmlExpNodePtr(n_expr, 1);
! 32799:
! 32800: xmlExpDump(buf, expr);
! 32801: call_tests++;
! 32802: des_xmlBufferPtr(n_buf, buf, 0);
! 32803: des_xmlExpNodePtr(n_expr, expr, 1);
! 32804: xmlResetLastError();
! 32805: if (mem_base != xmlMemBlocks()) {
! 32806: printf("Leak of %d blocks found in xmlExpDump",
! 32807: xmlMemBlocks() - mem_base);
! 32808: test_ret++;
! 32809: printf(" %d", n_buf);
! 32810: printf(" %d", n_expr);
! 32811: printf("\n");
! 32812: }
! 32813: }
! 32814: }
! 32815: function_tests++;
! 32816: #endif
! 32817:
! 32818: return(test_ret);
! 32819: }
! 32820:
! 32821:
! 32822: static int
! 32823: test_xmlExpExpDerive(void) {
! 32824: int test_ret = 0;
! 32825:
! 32826:
! 32827: /* missing type support */
! 32828: return(test_ret);
! 32829: }
! 32830:
! 32831:
! 32832: static int
! 32833: test_xmlExpGetLanguage(void) {
! 32834: int test_ret = 0;
! 32835:
! 32836: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
! 32837: int mem_base;
! 32838: int ret_val;
! 32839: xmlExpCtxtPtr ctxt; /* the expression context */
! 32840: int n_ctxt;
! 32841: xmlExpNodePtr exp; /* the expression */
! 32842: int n_exp;
! 32843: xmlChar ** langList; /* where to store the tokens */
! 32844: int n_langList;
! 32845: int len; /* the allocated lenght of @list */
! 32846: int n_len;
! 32847:
! 32848: for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
! 32849: for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
! 32850: for (n_langList = 0;n_langList < gen_nb_const_xmlChar_ptr_ptr;n_langList++) {
! 32851: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 32852: mem_base = xmlMemBlocks();
! 32853: ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
! 32854: exp = gen_xmlExpNodePtr(n_exp, 1);
! 32855: langList = gen_const_xmlChar_ptr_ptr(n_langList, 2);
! 32856: len = gen_int(n_len, 3);
! 32857:
! 32858: ret_val = xmlExpGetLanguage(ctxt, exp, (const xmlChar **)langList, len);
! 32859: desret_int(ret_val);
! 32860: call_tests++;
! 32861: des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
! 32862: des_xmlExpNodePtr(n_exp, exp, 1);
! 32863: des_const_xmlChar_ptr_ptr(n_langList, (const xmlChar **)langList, 2);
! 32864: des_int(n_len, len, 3);
! 32865: xmlResetLastError();
! 32866: if (mem_base != xmlMemBlocks()) {
! 32867: printf("Leak of %d blocks found in xmlExpGetLanguage",
! 32868: xmlMemBlocks() - mem_base);
! 32869: test_ret++;
! 32870: printf(" %d", n_ctxt);
! 32871: printf(" %d", n_exp);
! 32872: printf(" %d", n_langList);
! 32873: printf(" %d", n_len);
! 32874: printf("\n");
! 32875: }
! 32876: }
! 32877: }
! 32878: }
! 32879: }
! 32880: function_tests++;
! 32881: #endif
! 32882:
! 32883: return(test_ret);
! 32884: }
! 32885:
! 32886:
! 32887: static int
! 32888: test_xmlExpGetStart(void) {
! 32889: int test_ret = 0;
! 32890:
! 32891: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
! 32892: int mem_base;
! 32893: int ret_val;
! 32894: xmlExpCtxtPtr ctxt; /* the expression context */
! 32895: int n_ctxt;
! 32896: xmlExpNodePtr exp; /* the expression */
! 32897: int n_exp;
! 32898: xmlChar ** tokList; /* where to store the tokens */
! 32899: int n_tokList;
! 32900: int len; /* the allocated lenght of @list */
! 32901: int n_len;
! 32902:
! 32903: for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
! 32904: for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
! 32905: for (n_tokList = 0;n_tokList < gen_nb_const_xmlChar_ptr_ptr;n_tokList++) {
! 32906: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 32907: mem_base = xmlMemBlocks();
! 32908: ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
! 32909: exp = gen_xmlExpNodePtr(n_exp, 1);
! 32910: tokList = gen_const_xmlChar_ptr_ptr(n_tokList, 2);
! 32911: len = gen_int(n_len, 3);
! 32912:
! 32913: ret_val = xmlExpGetStart(ctxt, exp, (const xmlChar **)tokList, len);
! 32914: desret_int(ret_val);
! 32915: call_tests++;
! 32916: des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
! 32917: des_xmlExpNodePtr(n_exp, exp, 1);
! 32918: des_const_xmlChar_ptr_ptr(n_tokList, (const xmlChar **)tokList, 2);
! 32919: des_int(n_len, len, 3);
! 32920: xmlResetLastError();
! 32921: if (mem_base != xmlMemBlocks()) {
! 32922: printf("Leak of %d blocks found in xmlExpGetStart",
! 32923: xmlMemBlocks() - mem_base);
! 32924: test_ret++;
! 32925: printf(" %d", n_ctxt);
! 32926: printf(" %d", n_exp);
! 32927: printf(" %d", n_tokList);
! 32928: printf(" %d", n_len);
! 32929: printf("\n");
! 32930: }
! 32931: }
! 32932: }
! 32933: }
! 32934: }
! 32935: function_tests++;
! 32936: #endif
! 32937:
! 32938: return(test_ret);
! 32939: }
! 32940:
! 32941:
! 32942: static int
! 32943: test_xmlExpIsNillable(void) {
! 32944: int test_ret = 0;
! 32945:
! 32946: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
! 32947: int mem_base;
! 32948: int ret_val;
! 32949: xmlExpNodePtr exp; /* the expression */
! 32950: int n_exp;
! 32951:
! 32952: for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
! 32953: mem_base = xmlMemBlocks();
! 32954: exp = gen_xmlExpNodePtr(n_exp, 0);
! 32955:
! 32956: ret_val = xmlExpIsNillable(exp);
! 32957: desret_int(ret_val);
! 32958: call_tests++;
! 32959: des_xmlExpNodePtr(n_exp, exp, 0);
! 32960: xmlResetLastError();
! 32961: if (mem_base != xmlMemBlocks()) {
! 32962: printf("Leak of %d blocks found in xmlExpIsNillable",
! 32963: xmlMemBlocks() - mem_base);
! 32964: test_ret++;
! 32965: printf(" %d", n_exp);
! 32966: printf("\n");
! 32967: }
! 32968: }
! 32969: function_tests++;
! 32970: #endif
! 32971:
! 32972: return(test_ret);
! 32973: }
! 32974:
! 32975:
! 32976: static int
! 32977: test_xmlExpMaxToken(void) {
! 32978: int test_ret = 0;
! 32979:
! 32980: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
! 32981: int mem_base;
! 32982: int ret_val;
! 32983: xmlExpNodePtr expr; /* a compiled expression */
! 32984: int n_expr;
! 32985:
! 32986: for (n_expr = 0;n_expr < gen_nb_xmlExpNodePtr;n_expr++) {
! 32987: mem_base = xmlMemBlocks();
! 32988: expr = gen_xmlExpNodePtr(n_expr, 0);
! 32989:
! 32990: ret_val = xmlExpMaxToken(expr);
! 32991: desret_int(ret_val);
! 32992: call_tests++;
! 32993: des_xmlExpNodePtr(n_expr, expr, 0);
! 32994: xmlResetLastError();
! 32995: if (mem_base != xmlMemBlocks()) {
! 32996: printf("Leak of %d blocks found in xmlExpMaxToken",
! 32997: xmlMemBlocks() - mem_base);
! 32998: test_ret++;
! 32999: printf(" %d", n_expr);
! 33000: printf("\n");
! 33001: }
! 33002: }
! 33003: function_tests++;
! 33004: #endif
! 33005:
! 33006: return(test_ret);
! 33007: }
! 33008:
! 33009:
! 33010: static int
! 33011: test_xmlExpNewAtom(void) {
! 33012: int test_ret = 0;
! 33013:
! 33014:
! 33015: /* missing type support */
! 33016: return(test_ret);
! 33017: }
! 33018:
! 33019:
! 33020: static int
! 33021: test_xmlExpNewCtxt(void) {
! 33022: int test_ret = 0;
! 33023:
! 33024:
! 33025: /* missing type support */
! 33026: return(test_ret);
! 33027: }
! 33028:
! 33029:
! 33030: static int
! 33031: test_xmlExpNewOr(void) {
! 33032: int test_ret = 0;
! 33033:
! 33034:
! 33035: /* missing type support */
! 33036: return(test_ret);
! 33037: }
! 33038:
! 33039:
! 33040: static int
! 33041: test_xmlExpNewRange(void) {
! 33042: int test_ret = 0;
! 33043:
! 33044:
! 33045: /* missing type support */
! 33046: return(test_ret);
! 33047: }
! 33048:
! 33049:
! 33050: static int
! 33051: test_xmlExpNewSeq(void) {
! 33052: int test_ret = 0;
! 33053:
! 33054:
! 33055: /* missing type support */
! 33056: return(test_ret);
! 33057: }
! 33058:
! 33059:
! 33060: static int
! 33061: test_xmlExpParse(void) {
! 33062: int test_ret = 0;
! 33063:
! 33064:
! 33065: /* missing type support */
! 33066: return(test_ret);
! 33067: }
! 33068:
! 33069:
! 33070: static int
! 33071: test_xmlExpRef(void) {
! 33072: int test_ret = 0;
! 33073:
! 33074: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
! 33075: int mem_base;
! 33076: xmlExpNodePtr exp; /* the expression */
! 33077: int n_exp;
! 33078:
! 33079: for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
! 33080: mem_base = xmlMemBlocks();
! 33081: exp = gen_xmlExpNodePtr(n_exp, 0);
! 33082:
! 33083: xmlExpRef(exp);
! 33084: call_tests++;
! 33085: des_xmlExpNodePtr(n_exp, exp, 0);
! 33086: xmlResetLastError();
! 33087: if (mem_base != xmlMemBlocks()) {
! 33088: printf("Leak of %d blocks found in xmlExpRef",
! 33089: xmlMemBlocks() - mem_base);
! 33090: test_ret++;
! 33091: printf(" %d", n_exp);
! 33092: printf("\n");
! 33093: }
! 33094: }
! 33095: function_tests++;
! 33096: #endif
! 33097:
! 33098: return(test_ret);
! 33099: }
! 33100:
! 33101:
! 33102: static int
! 33103: test_xmlExpStringDerive(void) {
! 33104: int test_ret = 0;
! 33105:
! 33106:
! 33107: /* missing type support */
! 33108: return(test_ret);
! 33109: }
! 33110:
! 33111:
! 33112: static int
! 33113: test_xmlExpSubsume(void) {
! 33114: int test_ret = 0;
! 33115:
! 33116: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
! 33117: int mem_base;
! 33118: int ret_val;
! 33119: xmlExpCtxtPtr ctxt; /* the expressions context */
! 33120: int n_ctxt;
! 33121: xmlExpNodePtr exp; /* the englobing expression */
! 33122: int n_exp;
! 33123: xmlExpNodePtr sub; /* the subexpression */
! 33124: int n_sub;
! 33125:
! 33126: for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
! 33127: for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
! 33128: for (n_sub = 0;n_sub < gen_nb_xmlExpNodePtr;n_sub++) {
! 33129: mem_base = xmlMemBlocks();
! 33130: ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
! 33131: exp = gen_xmlExpNodePtr(n_exp, 1);
! 33132: sub = gen_xmlExpNodePtr(n_sub, 2);
! 33133:
! 33134: ret_val = xmlExpSubsume(ctxt, exp, sub);
! 33135: desret_int(ret_val);
! 33136: call_tests++;
! 33137: des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
! 33138: des_xmlExpNodePtr(n_exp, exp, 1);
! 33139: des_xmlExpNodePtr(n_sub, sub, 2);
! 33140: xmlResetLastError();
! 33141: if (mem_base != xmlMemBlocks()) {
! 33142: printf("Leak of %d blocks found in xmlExpSubsume",
! 33143: xmlMemBlocks() - mem_base);
! 33144: test_ret++;
! 33145: printf(" %d", n_ctxt);
! 33146: printf(" %d", n_exp);
! 33147: printf(" %d", n_sub);
! 33148: printf("\n");
! 33149: }
! 33150: }
! 33151: }
! 33152: }
! 33153: function_tests++;
! 33154: #endif
! 33155:
! 33156: return(test_ret);
! 33157: }
! 33158:
! 33159: #ifdef LIBXML_REGEXP_ENABLED
! 33160:
! 33161: #define gen_nb_xmlRegExecCtxtPtr 1
! 33162: static xmlRegExecCtxtPtr gen_xmlRegExecCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 33163: return(NULL);
! 33164: }
! 33165: static void des_xmlRegExecCtxtPtr(int no ATTRIBUTE_UNUSED, xmlRegExecCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 33166: }
! 33167: #endif
! 33168:
! 33169:
! 33170: static int
! 33171: test_xmlRegExecErrInfo(void) {
! 33172: int test_ret = 0;
! 33173:
! 33174: #if defined(LIBXML_REGEXP_ENABLED)
! 33175: int mem_base;
! 33176: int ret_val;
! 33177: xmlRegExecCtxtPtr exec; /* a regexp execution context generating an error */
! 33178: int n_exec;
! 33179: xmlChar ** string; /* return value for the error string */
! 33180: int n_string;
! 33181: int * nbval; /* pointer to the number of accepted values IN/OUT */
! 33182: int n_nbval;
! 33183: int * nbneg; /* return number of negative transitions */
! 33184: int n_nbneg;
! 33185: xmlChar ** values; /* pointer to the array of acceptable values */
! 33186: int n_values;
! 33187: int * terminal; /* return value if this was a terminal state */
! 33188: int n_terminal;
! 33189:
! 33190: for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
! 33191: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr_ptr;n_string++) {
! 33192: for (n_nbval = 0;n_nbval < gen_nb_int_ptr;n_nbval++) {
! 33193: for (n_nbneg = 0;n_nbneg < gen_nb_int_ptr;n_nbneg++) {
! 33194: for (n_values = 0;n_values < gen_nb_xmlChar_ptr_ptr;n_values++) {
! 33195: for (n_terminal = 0;n_terminal < gen_nb_int_ptr;n_terminal++) {
! 33196: mem_base = xmlMemBlocks();
! 33197: exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
! 33198: string = gen_const_xmlChar_ptr_ptr(n_string, 1);
! 33199: nbval = gen_int_ptr(n_nbval, 2);
! 33200: nbneg = gen_int_ptr(n_nbneg, 3);
! 33201: values = gen_xmlChar_ptr_ptr(n_values, 4);
! 33202: terminal = gen_int_ptr(n_terminal, 5);
! 33203:
! 33204: ret_val = xmlRegExecErrInfo(exec, (const xmlChar **)string, nbval, nbneg, values, terminal);
! 33205: desret_int(ret_val);
! 33206: call_tests++;
! 33207: des_xmlRegExecCtxtPtr(n_exec, exec, 0);
! 33208: des_const_xmlChar_ptr_ptr(n_string, (const xmlChar **)string, 1);
! 33209: des_int_ptr(n_nbval, nbval, 2);
! 33210: des_int_ptr(n_nbneg, nbneg, 3);
! 33211: des_xmlChar_ptr_ptr(n_values, values, 4);
! 33212: des_int_ptr(n_terminal, terminal, 5);
! 33213: xmlResetLastError();
! 33214: if (mem_base != xmlMemBlocks()) {
! 33215: printf("Leak of %d blocks found in xmlRegExecErrInfo",
! 33216: xmlMemBlocks() - mem_base);
! 33217: test_ret++;
! 33218: printf(" %d", n_exec);
! 33219: printf(" %d", n_string);
! 33220: printf(" %d", n_nbval);
! 33221: printf(" %d", n_nbneg);
! 33222: printf(" %d", n_values);
! 33223: printf(" %d", n_terminal);
! 33224: printf("\n");
! 33225: }
! 33226: }
! 33227: }
! 33228: }
! 33229: }
! 33230: }
! 33231: }
! 33232: function_tests++;
! 33233: #endif
! 33234:
! 33235: return(test_ret);
! 33236: }
! 33237:
! 33238:
! 33239: static int
! 33240: test_xmlRegExecNextValues(void) {
! 33241: int test_ret = 0;
! 33242:
! 33243: #if defined(LIBXML_REGEXP_ENABLED)
! 33244: int mem_base;
! 33245: int ret_val;
! 33246: xmlRegExecCtxtPtr exec; /* a regexp execution context */
! 33247: int n_exec;
! 33248: int * nbval; /* pointer to the number of accepted values IN/OUT */
! 33249: int n_nbval;
! 33250: int * nbneg; /* return number of negative transitions */
! 33251: int n_nbneg;
! 33252: xmlChar ** values; /* pointer to the array of acceptable values */
! 33253: int n_values;
! 33254: int * terminal; /* return value if this was a terminal state */
! 33255: int n_terminal;
! 33256:
! 33257: for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
! 33258: for (n_nbval = 0;n_nbval < gen_nb_int_ptr;n_nbval++) {
! 33259: for (n_nbneg = 0;n_nbneg < gen_nb_int_ptr;n_nbneg++) {
! 33260: for (n_values = 0;n_values < gen_nb_xmlChar_ptr_ptr;n_values++) {
! 33261: for (n_terminal = 0;n_terminal < gen_nb_int_ptr;n_terminal++) {
! 33262: mem_base = xmlMemBlocks();
! 33263: exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
! 33264: nbval = gen_int_ptr(n_nbval, 1);
! 33265: nbneg = gen_int_ptr(n_nbneg, 2);
! 33266: values = gen_xmlChar_ptr_ptr(n_values, 3);
! 33267: terminal = gen_int_ptr(n_terminal, 4);
! 33268:
! 33269: ret_val = xmlRegExecNextValues(exec, nbval, nbneg, values, terminal);
! 33270: desret_int(ret_val);
! 33271: call_tests++;
! 33272: des_xmlRegExecCtxtPtr(n_exec, exec, 0);
! 33273: des_int_ptr(n_nbval, nbval, 1);
! 33274: des_int_ptr(n_nbneg, nbneg, 2);
! 33275: des_xmlChar_ptr_ptr(n_values, values, 3);
! 33276: des_int_ptr(n_terminal, terminal, 4);
! 33277: xmlResetLastError();
! 33278: if (mem_base != xmlMemBlocks()) {
! 33279: printf("Leak of %d blocks found in xmlRegExecNextValues",
! 33280: xmlMemBlocks() - mem_base);
! 33281: test_ret++;
! 33282: printf(" %d", n_exec);
! 33283: printf(" %d", n_nbval);
! 33284: printf(" %d", n_nbneg);
! 33285: printf(" %d", n_values);
! 33286: printf(" %d", n_terminal);
! 33287: printf("\n");
! 33288: }
! 33289: }
! 33290: }
! 33291: }
! 33292: }
! 33293: }
! 33294: function_tests++;
! 33295: #endif
! 33296:
! 33297: return(test_ret);
! 33298: }
! 33299:
! 33300:
! 33301: static int
! 33302: test_xmlRegExecPushString(void) {
! 33303: int test_ret = 0;
! 33304:
! 33305: #if defined(LIBXML_REGEXP_ENABLED)
! 33306: int mem_base;
! 33307: int ret_val;
! 33308: xmlRegExecCtxtPtr exec; /* a regexp execution context or NULL to indicate the end */
! 33309: int n_exec;
! 33310: xmlChar * value; /* a string token input */
! 33311: int n_value;
! 33312: void * data; /* data associated to the token to reuse in callbacks */
! 33313: int n_data;
! 33314:
! 33315: for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
! 33316: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 33317: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
! 33318: mem_base = xmlMemBlocks();
! 33319: exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
! 33320: value = gen_const_xmlChar_ptr(n_value, 1);
! 33321: data = gen_userdata(n_data, 2);
! 33322:
! 33323: ret_val = xmlRegExecPushString(exec, (const xmlChar *)value, data);
! 33324: desret_int(ret_val);
! 33325: call_tests++;
! 33326: des_xmlRegExecCtxtPtr(n_exec, exec, 0);
! 33327: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
! 33328: des_userdata(n_data, data, 2);
! 33329: xmlResetLastError();
! 33330: if (mem_base != xmlMemBlocks()) {
! 33331: printf("Leak of %d blocks found in xmlRegExecPushString",
! 33332: xmlMemBlocks() - mem_base);
! 33333: test_ret++;
! 33334: printf(" %d", n_exec);
! 33335: printf(" %d", n_value);
! 33336: printf(" %d", n_data);
! 33337: printf("\n");
! 33338: }
! 33339: }
! 33340: }
! 33341: }
! 33342: function_tests++;
! 33343: #endif
! 33344:
! 33345: return(test_ret);
! 33346: }
! 33347:
! 33348:
! 33349: static int
! 33350: test_xmlRegExecPushString2(void) {
! 33351: int test_ret = 0;
! 33352:
! 33353: #if defined(LIBXML_REGEXP_ENABLED)
! 33354: int mem_base;
! 33355: int ret_val;
! 33356: xmlRegExecCtxtPtr exec; /* a regexp execution context or NULL to indicate the end */
! 33357: int n_exec;
! 33358: xmlChar * value; /* the first string token input */
! 33359: int n_value;
! 33360: xmlChar * value2; /* the second string token input */
! 33361: int n_value2;
! 33362: void * data; /* data associated to the token to reuse in callbacks */
! 33363: int n_data;
! 33364:
! 33365: for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
! 33366: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 33367: for (n_value2 = 0;n_value2 < gen_nb_const_xmlChar_ptr;n_value2++) {
! 33368: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
! 33369: mem_base = xmlMemBlocks();
! 33370: exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
! 33371: value = gen_const_xmlChar_ptr(n_value, 1);
! 33372: value2 = gen_const_xmlChar_ptr(n_value2, 2);
! 33373: data = gen_userdata(n_data, 3);
! 33374:
! 33375: ret_val = xmlRegExecPushString2(exec, (const xmlChar *)value, (const xmlChar *)value2, data);
! 33376: desret_int(ret_val);
! 33377: call_tests++;
! 33378: des_xmlRegExecCtxtPtr(n_exec, exec, 0);
! 33379: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
! 33380: des_const_xmlChar_ptr(n_value2, (const xmlChar *)value2, 2);
! 33381: des_userdata(n_data, data, 3);
! 33382: xmlResetLastError();
! 33383: if (mem_base != xmlMemBlocks()) {
! 33384: printf("Leak of %d blocks found in xmlRegExecPushString2",
! 33385: xmlMemBlocks() - mem_base);
! 33386: test_ret++;
! 33387: printf(" %d", n_exec);
! 33388: printf(" %d", n_value);
! 33389: printf(" %d", n_value2);
! 33390: printf(" %d", n_data);
! 33391: printf("\n");
! 33392: }
! 33393: }
! 33394: }
! 33395: }
! 33396: }
! 33397: function_tests++;
! 33398: #endif
! 33399:
! 33400: return(test_ret);
! 33401: }
! 33402:
! 33403: #ifdef LIBXML_REGEXP_ENABLED
! 33404:
! 33405: #define gen_nb_xmlRegexpPtr 1
! 33406: static xmlRegexpPtr gen_xmlRegexpPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 33407: return(NULL);
! 33408: }
! 33409: static void des_xmlRegexpPtr(int no ATTRIBUTE_UNUSED, xmlRegexpPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 33410: }
! 33411: #endif
! 33412:
! 33413:
! 33414: static int
! 33415: test_xmlRegNewExecCtxt(void) {
! 33416: int test_ret = 0;
! 33417:
! 33418:
! 33419: /* missing type support */
! 33420: return(test_ret);
! 33421: }
! 33422:
! 33423:
! 33424: static int
! 33425: test_xmlRegexpCompile(void) {
! 33426: int test_ret = 0;
! 33427:
! 33428:
! 33429: /* missing type support */
! 33430: return(test_ret);
! 33431: }
! 33432:
! 33433:
! 33434: static int
! 33435: test_xmlRegexpExec(void) {
! 33436: int test_ret = 0;
! 33437:
! 33438: #if defined(LIBXML_REGEXP_ENABLED)
! 33439: int mem_base;
! 33440: int ret_val;
! 33441: xmlRegexpPtr comp; /* the compiled regular expression */
! 33442: int n_comp;
! 33443: xmlChar * content; /* the value to check against the regular expression */
! 33444: int n_content;
! 33445:
! 33446: for (n_comp = 0;n_comp < gen_nb_xmlRegexpPtr;n_comp++) {
! 33447: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 33448: mem_base = xmlMemBlocks();
! 33449: comp = gen_xmlRegexpPtr(n_comp, 0);
! 33450: content = gen_const_xmlChar_ptr(n_content, 1);
! 33451:
! 33452: ret_val = xmlRegexpExec(comp, (const xmlChar *)content);
! 33453: desret_int(ret_val);
! 33454: call_tests++;
! 33455: des_xmlRegexpPtr(n_comp, comp, 0);
! 33456: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
! 33457: xmlResetLastError();
! 33458: if (mem_base != xmlMemBlocks()) {
! 33459: printf("Leak of %d blocks found in xmlRegexpExec",
! 33460: xmlMemBlocks() - mem_base);
! 33461: test_ret++;
! 33462: printf(" %d", n_comp);
! 33463: printf(" %d", n_content);
! 33464: printf("\n");
! 33465: }
! 33466: }
! 33467: }
! 33468: function_tests++;
! 33469: #endif
! 33470:
! 33471: return(test_ret);
! 33472: }
! 33473:
! 33474:
! 33475: static int
! 33476: test_xmlRegexpIsDeterminist(void) {
! 33477: int test_ret = 0;
! 33478:
! 33479: #if defined(LIBXML_REGEXP_ENABLED)
! 33480: int mem_base;
! 33481: int ret_val;
! 33482: xmlRegexpPtr comp; /* the compiled regular expression */
! 33483: int n_comp;
! 33484:
! 33485: for (n_comp = 0;n_comp < gen_nb_xmlRegexpPtr;n_comp++) {
! 33486: mem_base = xmlMemBlocks();
! 33487: comp = gen_xmlRegexpPtr(n_comp, 0);
! 33488:
! 33489: ret_val = xmlRegexpIsDeterminist(comp);
! 33490: desret_int(ret_val);
! 33491: call_tests++;
! 33492: des_xmlRegexpPtr(n_comp, comp, 0);
! 33493: xmlResetLastError();
! 33494: if (mem_base != xmlMemBlocks()) {
! 33495: printf("Leak of %d blocks found in xmlRegexpIsDeterminist",
! 33496: xmlMemBlocks() - mem_base);
! 33497: test_ret++;
! 33498: printf(" %d", n_comp);
! 33499: printf("\n");
! 33500: }
! 33501: }
! 33502: function_tests++;
! 33503: #endif
! 33504:
! 33505: return(test_ret);
! 33506: }
! 33507:
! 33508:
! 33509: static int
! 33510: test_xmlRegexpPrint(void) {
! 33511: int test_ret = 0;
! 33512:
! 33513: #if defined(LIBXML_REGEXP_ENABLED)
! 33514: int mem_base;
! 33515: FILE * output; /* the file for the output debug */
! 33516: int n_output;
! 33517: xmlRegexpPtr regexp; /* the compiled regexp */
! 33518: int n_regexp;
! 33519:
! 33520: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
! 33521: for (n_regexp = 0;n_regexp < gen_nb_xmlRegexpPtr;n_regexp++) {
! 33522: mem_base = xmlMemBlocks();
! 33523: output = gen_FILE_ptr(n_output, 0);
! 33524: regexp = gen_xmlRegexpPtr(n_regexp, 1);
! 33525:
! 33526: xmlRegexpPrint(output, regexp);
! 33527: call_tests++;
! 33528: des_FILE_ptr(n_output, output, 0);
! 33529: des_xmlRegexpPtr(n_regexp, regexp, 1);
! 33530: xmlResetLastError();
! 33531: if (mem_base != xmlMemBlocks()) {
! 33532: printf("Leak of %d blocks found in xmlRegexpPrint",
! 33533: xmlMemBlocks() - mem_base);
! 33534: test_ret++;
! 33535: printf(" %d", n_output);
! 33536: printf(" %d", n_regexp);
! 33537: printf("\n");
! 33538: }
! 33539: }
! 33540: }
! 33541: function_tests++;
! 33542: #endif
! 33543:
! 33544: return(test_ret);
! 33545: }
! 33546:
! 33547: static int
! 33548: test_xmlregexp(void) {
! 33549: int test_ret = 0;
! 33550:
! 33551: if (quiet == 0) printf("Testing xmlregexp : 16 of 30 functions ...\n");
! 33552: test_ret += test_xmlExpCtxtNbCons();
! 33553: test_ret += test_xmlExpCtxtNbNodes();
! 33554: test_ret += test_xmlExpDump();
! 33555: test_ret += test_xmlExpExpDerive();
! 33556: test_ret += test_xmlExpGetLanguage();
! 33557: test_ret += test_xmlExpGetStart();
! 33558: test_ret += test_xmlExpIsNillable();
! 33559: test_ret += test_xmlExpMaxToken();
! 33560: test_ret += test_xmlExpNewAtom();
! 33561: test_ret += test_xmlExpNewCtxt();
! 33562: test_ret += test_xmlExpNewOr();
! 33563: test_ret += test_xmlExpNewRange();
! 33564: test_ret += test_xmlExpNewSeq();
! 33565: test_ret += test_xmlExpParse();
! 33566: test_ret += test_xmlExpRef();
! 33567: test_ret += test_xmlExpStringDerive();
! 33568: test_ret += test_xmlExpSubsume();
! 33569: test_ret += test_xmlRegExecErrInfo();
! 33570: test_ret += test_xmlRegExecNextValues();
! 33571: test_ret += test_xmlRegExecPushString();
! 33572: test_ret += test_xmlRegExecPushString2();
! 33573: test_ret += test_xmlRegNewExecCtxt();
! 33574: test_ret += test_xmlRegexpCompile();
! 33575: test_ret += test_xmlRegexpExec();
! 33576: test_ret += test_xmlRegexpIsDeterminist();
! 33577: test_ret += test_xmlRegexpPrint();
! 33578:
! 33579: if (test_ret != 0)
! 33580: printf("Module xmlregexp: %d errors\n", test_ret);
! 33581: return(test_ret);
! 33582: }
! 33583: #ifdef LIBXML_OUTPUT_ENABLED
! 33584:
! 33585: #define gen_nb_xmlSaveCtxtPtr 1
! 33586: static xmlSaveCtxtPtr gen_xmlSaveCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 33587: return(NULL);
! 33588: }
! 33589: static void des_xmlSaveCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSaveCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 33590: }
! 33591: #endif
! 33592:
! 33593:
! 33594: static int
! 33595: test_xmlSaveClose(void) {
! 33596: int test_ret = 0;
! 33597:
! 33598: #if defined(LIBXML_OUTPUT_ENABLED)
! 33599: int mem_base;
! 33600: int ret_val;
! 33601: xmlSaveCtxtPtr ctxt; /* a document saving context */
! 33602: int n_ctxt;
! 33603:
! 33604: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
! 33605: mem_base = xmlMemBlocks();
! 33606: ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
! 33607:
! 33608: ret_val = xmlSaveClose(ctxt);
! 33609: desret_int(ret_val);
! 33610: call_tests++;
! 33611: des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
! 33612: xmlResetLastError();
! 33613: if (mem_base != xmlMemBlocks()) {
! 33614: printf("Leak of %d blocks found in xmlSaveClose",
! 33615: xmlMemBlocks() - mem_base);
! 33616: test_ret++;
! 33617: printf(" %d", n_ctxt);
! 33618: printf("\n");
! 33619: }
! 33620: }
! 33621: function_tests++;
! 33622: #endif
! 33623:
! 33624: return(test_ret);
! 33625: }
! 33626:
! 33627:
! 33628: static int
! 33629: test_xmlSaveDoc(void) {
! 33630: int test_ret = 0;
! 33631:
! 33632: #if defined(LIBXML_OUTPUT_ENABLED)
! 33633: int mem_base;
! 33634: long ret_val;
! 33635: xmlSaveCtxtPtr ctxt; /* a document saving context */
! 33636: int n_ctxt;
! 33637: xmlDocPtr doc; /* a document */
! 33638: int n_doc;
! 33639:
! 33640: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
! 33641: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 33642: mem_base = xmlMemBlocks();
! 33643: ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
! 33644: doc = gen_xmlDocPtr(n_doc, 1);
! 33645:
! 33646: ret_val = xmlSaveDoc(ctxt, doc);
! 33647: desret_long(ret_val);
! 33648: call_tests++;
! 33649: des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
! 33650: des_xmlDocPtr(n_doc, doc, 1);
! 33651: xmlResetLastError();
! 33652: if (mem_base != xmlMemBlocks()) {
! 33653: printf("Leak of %d blocks found in xmlSaveDoc",
! 33654: xmlMemBlocks() - mem_base);
! 33655: test_ret++;
! 33656: printf(" %d", n_ctxt);
! 33657: printf(" %d", n_doc);
! 33658: printf("\n");
! 33659: }
! 33660: }
! 33661: }
! 33662: function_tests++;
! 33663: #endif
! 33664:
! 33665: return(test_ret);
! 33666: }
! 33667:
! 33668:
! 33669: static int
! 33670: test_xmlSaveFlush(void) {
! 33671: int test_ret = 0;
! 33672:
! 33673: #if defined(LIBXML_OUTPUT_ENABLED)
! 33674: int mem_base;
! 33675: int ret_val;
! 33676: xmlSaveCtxtPtr ctxt; /* a document saving context */
! 33677: int n_ctxt;
! 33678:
! 33679: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
! 33680: mem_base = xmlMemBlocks();
! 33681: ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
! 33682:
! 33683: ret_val = xmlSaveFlush(ctxt);
! 33684: desret_int(ret_val);
! 33685: call_tests++;
! 33686: des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
! 33687: xmlResetLastError();
! 33688: if (mem_base != xmlMemBlocks()) {
! 33689: printf("Leak of %d blocks found in xmlSaveFlush",
! 33690: xmlMemBlocks() - mem_base);
! 33691: test_ret++;
! 33692: printf(" %d", n_ctxt);
! 33693: printf("\n");
! 33694: }
! 33695: }
! 33696: function_tests++;
! 33697: #endif
! 33698:
! 33699: return(test_ret);
! 33700: }
! 33701:
! 33702:
! 33703: static int
! 33704: test_xmlSaveSetAttrEscape(void) {
! 33705: int test_ret = 0;
! 33706:
! 33707:
! 33708: /* missing type support */
! 33709: return(test_ret);
! 33710: }
! 33711:
! 33712:
! 33713: static int
! 33714: test_xmlSaveSetEscape(void) {
! 33715: int test_ret = 0;
! 33716:
! 33717:
! 33718: /* missing type support */
! 33719: return(test_ret);
! 33720: }
! 33721:
! 33722:
! 33723: static int
! 33724: test_xmlSaveToBuffer(void) {
! 33725: int test_ret = 0;
! 33726:
! 33727:
! 33728: /* missing type support */
! 33729: return(test_ret);
! 33730: }
! 33731:
! 33732:
! 33733: static int
! 33734: test_xmlSaveToFd(void) {
! 33735: int test_ret = 0;
! 33736:
! 33737:
! 33738: /* missing type support */
! 33739: return(test_ret);
! 33740: }
! 33741:
! 33742:
! 33743: static int
! 33744: test_xmlSaveToFilename(void) {
! 33745: int test_ret = 0;
! 33746:
! 33747:
! 33748: /* missing type support */
! 33749: return(test_ret);
! 33750: }
! 33751:
! 33752:
! 33753: static int
! 33754: test_xmlSaveTree(void) {
! 33755: int test_ret = 0;
! 33756:
! 33757: #if defined(LIBXML_OUTPUT_ENABLED)
! 33758: int mem_base;
! 33759: long ret_val;
! 33760: xmlSaveCtxtPtr ctxt; /* a document saving context */
! 33761: int n_ctxt;
! 33762: xmlNodePtr node; /* the top node of the subtree to save */
! 33763: int n_node;
! 33764:
! 33765: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
! 33766: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 33767: mem_base = xmlMemBlocks();
! 33768: ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
! 33769: node = gen_xmlNodePtr(n_node, 1);
! 33770:
! 33771: ret_val = xmlSaveTree(ctxt, node);
! 33772: desret_long(ret_val);
! 33773: call_tests++;
! 33774: des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
! 33775: des_xmlNodePtr(n_node, node, 1);
! 33776: xmlResetLastError();
! 33777: if (mem_base != xmlMemBlocks()) {
! 33778: printf("Leak of %d blocks found in xmlSaveTree",
! 33779: xmlMemBlocks() - mem_base);
! 33780: test_ret++;
! 33781: printf(" %d", n_ctxt);
! 33782: printf(" %d", n_node);
! 33783: printf("\n");
! 33784: }
! 33785: }
! 33786: }
! 33787: function_tests++;
! 33788: #endif
! 33789:
! 33790: return(test_ret);
! 33791: }
! 33792:
! 33793: static int
! 33794: test_xmlsave(void) {
! 33795: int test_ret = 0;
! 33796:
! 33797: if (quiet == 0) printf("Testing xmlsave : 4 of 10 functions ...\n");
! 33798: test_ret += test_xmlSaveClose();
! 33799: test_ret += test_xmlSaveDoc();
! 33800: test_ret += test_xmlSaveFlush();
! 33801: test_ret += test_xmlSaveSetAttrEscape();
! 33802: test_ret += test_xmlSaveSetEscape();
! 33803: test_ret += test_xmlSaveToBuffer();
! 33804: test_ret += test_xmlSaveToFd();
! 33805: test_ret += test_xmlSaveToFilename();
! 33806: test_ret += test_xmlSaveTree();
! 33807:
! 33808: if (test_ret != 0)
! 33809: printf("Module xmlsave: %d errors\n", test_ret);
! 33810: return(test_ret);
! 33811: }
! 33812:
! 33813: static int
! 33814: test_xmlSchemaDump(void) {
! 33815: int test_ret = 0;
! 33816:
! 33817: #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 33818: int mem_base;
! 33819: FILE * output; /* the file output */
! 33820: int n_output;
! 33821: xmlSchemaPtr schema; /* a schema structure */
! 33822: int n_schema;
! 33823:
! 33824: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
! 33825: for (n_schema = 0;n_schema < gen_nb_xmlSchemaPtr;n_schema++) {
! 33826: mem_base = xmlMemBlocks();
! 33827: output = gen_FILE_ptr(n_output, 0);
! 33828: schema = gen_xmlSchemaPtr(n_schema, 1);
! 33829:
! 33830: xmlSchemaDump(output, schema);
! 33831: call_tests++;
! 33832: des_FILE_ptr(n_output, output, 0);
! 33833: des_xmlSchemaPtr(n_schema, schema, 1);
! 33834: xmlResetLastError();
! 33835: if (mem_base != xmlMemBlocks()) {
! 33836: printf("Leak of %d blocks found in xmlSchemaDump",
! 33837: xmlMemBlocks() - mem_base);
! 33838: test_ret++;
! 33839: printf(" %d", n_output);
! 33840: printf(" %d", n_schema);
! 33841: printf("\n");
! 33842: }
! 33843: }
! 33844: }
! 33845: function_tests++;
! 33846: #endif
! 33847:
! 33848: return(test_ret);
! 33849: }
! 33850:
! 33851: #ifdef LIBXML_SCHEMAS_ENABLED
! 33852:
! 33853: #define gen_nb_xmlSchemaParserCtxtPtr 1
! 33854: static xmlSchemaParserCtxtPtr gen_xmlSchemaParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 33855: return(NULL);
! 33856: }
! 33857: static void des_xmlSchemaParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchemaParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 33858: }
! 33859: #endif
! 33860:
! 33861: #ifdef LIBXML_SCHEMAS_ENABLED
! 33862:
! 33863: #define gen_nb_xmlSchemaValidityErrorFunc_ptr 1
! 33864: static xmlSchemaValidityErrorFunc * gen_xmlSchemaValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 33865: return(NULL);
! 33866: }
! 33867: static void des_xmlSchemaValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlSchemaValidityErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 33868: }
! 33869: #endif
! 33870:
! 33871: #ifdef LIBXML_SCHEMAS_ENABLED
! 33872:
! 33873: #define gen_nb_xmlSchemaValidityWarningFunc_ptr 1
! 33874: static xmlSchemaValidityWarningFunc * gen_xmlSchemaValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 33875: return(NULL);
! 33876: }
! 33877: static void des_xmlSchemaValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, xmlSchemaValidityWarningFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 33878: }
! 33879: #endif
! 33880:
! 33881:
! 33882: static int
! 33883: test_xmlSchemaGetParserErrors(void) {
! 33884: int test_ret = 0;
! 33885:
! 33886: #if defined(LIBXML_SCHEMAS_ENABLED)
! 33887: int mem_base;
! 33888: int ret_val;
! 33889: xmlSchemaParserCtxtPtr ctxt; /* a XMl-Schema parser context */
! 33890: int n_ctxt;
! 33891: xmlSchemaValidityErrorFunc * err; /* the error callback result */
! 33892: int n_err;
! 33893: xmlSchemaValidityWarningFunc * warn; /* the warning callback result */
! 33894: int n_warn;
! 33895: void ** ctx; /* contextual data for the callbacks result */
! 33896: int n_ctx;
! 33897:
! 33898: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaParserCtxtPtr;n_ctxt++) {
! 33899: for (n_err = 0;n_err < gen_nb_xmlSchemaValidityErrorFunc_ptr;n_err++) {
! 33900: for (n_warn = 0;n_warn < gen_nb_xmlSchemaValidityWarningFunc_ptr;n_warn++) {
! 33901: for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
! 33902: mem_base = xmlMemBlocks();
! 33903: ctxt = gen_xmlSchemaParserCtxtPtr(n_ctxt, 0);
! 33904: err = gen_xmlSchemaValidityErrorFunc_ptr(n_err, 1);
! 33905: warn = gen_xmlSchemaValidityWarningFunc_ptr(n_warn, 2);
! 33906: ctx = gen_void_ptr_ptr(n_ctx, 3);
! 33907:
! 33908: ret_val = xmlSchemaGetParserErrors(ctxt, err, warn, ctx);
! 33909: desret_int(ret_val);
! 33910: call_tests++;
! 33911: des_xmlSchemaParserCtxtPtr(n_ctxt, ctxt, 0);
! 33912: des_xmlSchemaValidityErrorFunc_ptr(n_err, err, 1);
! 33913: des_xmlSchemaValidityWarningFunc_ptr(n_warn, warn, 2);
! 33914: des_void_ptr_ptr(n_ctx, ctx, 3);
! 33915: xmlResetLastError();
! 33916: if (mem_base != xmlMemBlocks()) {
! 33917: printf("Leak of %d blocks found in xmlSchemaGetParserErrors",
! 33918: xmlMemBlocks() - mem_base);
! 33919: test_ret++;
! 33920: printf(" %d", n_ctxt);
! 33921: printf(" %d", n_err);
! 33922: printf(" %d", n_warn);
! 33923: printf(" %d", n_ctx);
! 33924: printf("\n");
! 33925: }
! 33926: }
! 33927: }
! 33928: }
! 33929: }
! 33930: function_tests++;
! 33931: #endif
! 33932:
! 33933: return(test_ret);
! 33934: }
! 33935:
! 33936:
! 33937: static int
! 33938: test_xmlSchemaGetValidErrors(void) {
! 33939: int test_ret = 0;
! 33940:
! 33941: #if defined(LIBXML_SCHEMAS_ENABLED)
! 33942: int mem_base;
! 33943: int ret_val;
! 33944: xmlSchemaValidCtxtPtr ctxt; /* a XML-Schema validation context */
! 33945: int n_ctxt;
! 33946: xmlSchemaValidityErrorFunc * err; /* the error function result */
! 33947: int n_err;
! 33948: xmlSchemaValidityWarningFunc * warn; /* the warning function result */
! 33949: int n_warn;
! 33950: void ** ctx; /* the functions context result */
! 33951: int n_ctx;
! 33952:
! 33953: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
! 33954: for (n_err = 0;n_err < gen_nb_xmlSchemaValidityErrorFunc_ptr;n_err++) {
! 33955: for (n_warn = 0;n_warn < gen_nb_xmlSchemaValidityWarningFunc_ptr;n_warn++) {
! 33956: for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
! 33957: mem_base = xmlMemBlocks();
! 33958: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
! 33959: err = gen_xmlSchemaValidityErrorFunc_ptr(n_err, 1);
! 33960: warn = gen_xmlSchemaValidityWarningFunc_ptr(n_warn, 2);
! 33961: ctx = gen_void_ptr_ptr(n_ctx, 3);
! 33962:
! 33963: ret_val = xmlSchemaGetValidErrors(ctxt, err, warn, ctx);
! 33964: desret_int(ret_val);
! 33965: call_tests++;
! 33966: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
! 33967: des_xmlSchemaValidityErrorFunc_ptr(n_err, err, 1);
! 33968: des_xmlSchemaValidityWarningFunc_ptr(n_warn, warn, 2);
! 33969: des_void_ptr_ptr(n_ctx, ctx, 3);
! 33970: xmlResetLastError();
! 33971: if (mem_base != xmlMemBlocks()) {
! 33972: printf("Leak of %d blocks found in xmlSchemaGetValidErrors",
! 33973: xmlMemBlocks() - mem_base);
! 33974: test_ret++;
! 33975: printf(" %d", n_ctxt);
! 33976: printf(" %d", n_err);
! 33977: printf(" %d", n_warn);
! 33978: printf(" %d", n_ctx);
! 33979: printf("\n");
! 33980: }
! 33981: }
! 33982: }
! 33983: }
! 33984: }
! 33985: function_tests++;
! 33986: #endif
! 33987:
! 33988: return(test_ret);
! 33989: }
! 33990:
! 33991:
! 33992: static int
! 33993: test_xmlSchemaIsValid(void) {
! 33994: int test_ret = 0;
! 33995:
! 33996: #if defined(LIBXML_SCHEMAS_ENABLED)
! 33997: int mem_base;
! 33998: int ret_val;
! 33999: xmlSchemaValidCtxtPtr ctxt; /* the schema validation context */
! 34000: int n_ctxt;
! 34001:
! 34002: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
! 34003: mem_base = xmlMemBlocks();
! 34004: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
! 34005:
! 34006: ret_val = xmlSchemaIsValid(ctxt);
! 34007: desret_int(ret_val);
! 34008: call_tests++;
! 34009: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
! 34010: xmlResetLastError();
! 34011: if (mem_base != xmlMemBlocks()) {
! 34012: printf("Leak of %d blocks found in xmlSchemaIsValid",
! 34013: xmlMemBlocks() - mem_base);
! 34014: test_ret++;
! 34015: printf(" %d", n_ctxt);
! 34016: printf("\n");
! 34017: }
! 34018: }
! 34019: function_tests++;
! 34020: #endif
! 34021:
! 34022: return(test_ret);
! 34023: }
! 34024:
! 34025:
! 34026: static int
! 34027: test_xmlSchemaNewDocParserCtxt(void) {
! 34028: int test_ret = 0;
! 34029:
! 34030: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34031: int mem_base;
! 34032: xmlSchemaParserCtxtPtr ret_val;
! 34033: xmlDocPtr doc; /* a preparsed document tree */
! 34034: int n_doc;
! 34035:
! 34036: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 34037: mem_base = xmlMemBlocks();
! 34038: doc = gen_xmlDocPtr(n_doc, 0);
! 34039:
! 34040: ret_val = xmlSchemaNewDocParserCtxt(doc);
! 34041: desret_xmlSchemaParserCtxtPtr(ret_val);
! 34042: call_tests++;
! 34043: des_xmlDocPtr(n_doc, doc, 0);
! 34044: xmlResetLastError();
! 34045: if (mem_base != xmlMemBlocks()) {
! 34046: printf("Leak of %d blocks found in xmlSchemaNewDocParserCtxt",
! 34047: xmlMemBlocks() - mem_base);
! 34048: test_ret++;
! 34049: printf(" %d", n_doc);
! 34050: printf("\n");
! 34051: }
! 34052: }
! 34053: function_tests++;
! 34054: #endif
! 34055:
! 34056: return(test_ret);
! 34057: }
! 34058:
! 34059:
! 34060: static int
! 34061: test_xmlSchemaNewMemParserCtxt(void) {
! 34062: int test_ret = 0;
! 34063:
! 34064: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34065: int mem_base;
! 34066: xmlSchemaParserCtxtPtr ret_val;
! 34067: char * buffer; /* a pointer to a char array containing the schemas */
! 34068: int n_buffer;
! 34069: int size; /* the size of the array */
! 34070: int n_size;
! 34071:
! 34072: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
! 34073: for (n_size = 0;n_size < gen_nb_int;n_size++) {
! 34074: mem_base = xmlMemBlocks();
! 34075: buffer = gen_const_char_ptr(n_buffer, 0);
! 34076: size = gen_int(n_size, 1);
! 34077:
! 34078: ret_val = xmlSchemaNewMemParserCtxt((const char *)buffer, size);
! 34079: desret_xmlSchemaParserCtxtPtr(ret_val);
! 34080: call_tests++;
! 34081: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
! 34082: des_int(n_size, size, 1);
! 34083: xmlResetLastError();
! 34084: if (mem_base != xmlMemBlocks()) {
! 34085: printf("Leak of %d blocks found in xmlSchemaNewMemParserCtxt",
! 34086: xmlMemBlocks() - mem_base);
! 34087: test_ret++;
! 34088: printf(" %d", n_buffer);
! 34089: printf(" %d", n_size);
! 34090: printf("\n");
! 34091: }
! 34092: }
! 34093: }
! 34094: function_tests++;
! 34095: #endif
! 34096:
! 34097: return(test_ret);
! 34098: }
! 34099:
! 34100:
! 34101: static int
! 34102: test_xmlSchemaNewParserCtxt(void) {
! 34103: int test_ret = 0;
! 34104:
! 34105: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34106: int mem_base;
! 34107: xmlSchemaParserCtxtPtr ret_val;
! 34108: char * URL; /* the location of the schema */
! 34109: int n_URL;
! 34110:
! 34111: for (n_URL = 0;n_URL < gen_nb_const_char_ptr;n_URL++) {
! 34112: mem_base = xmlMemBlocks();
! 34113: URL = gen_const_char_ptr(n_URL, 0);
! 34114:
! 34115: ret_val = xmlSchemaNewParserCtxt((const char *)URL);
! 34116: desret_xmlSchemaParserCtxtPtr(ret_val);
! 34117: call_tests++;
! 34118: des_const_char_ptr(n_URL, (const char *)URL, 0);
! 34119: xmlResetLastError();
! 34120: if (mem_base != xmlMemBlocks()) {
! 34121: printf("Leak of %d blocks found in xmlSchemaNewParserCtxt",
! 34122: xmlMemBlocks() - mem_base);
! 34123: test_ret++;
! 34124: printf(" %d", n_URL);
! 34125: printf("\n");
! 34126: }
! 34127: }
! 34128: function_tests++;
! 34129: #endif
! 34130:
! 34131: return(test_ret);
! 34132: }
! 34133:
! 34134:
! 34135: static int
! 34136: test_xmlSchemaNewValidCtxt(void) {
! 34137: int test_ret = 0;
! 34138:
! 34139:
! 34140: /* missing type support */
! 34141: return(test_ret);
! 34142: }
! 34143:
! 34144:
! 34145: static int
! 34146: test_xmlSchemaParse(void) {
! 34147: int test_ret = 0;
! 34148:
! 34149:
! 34150: /* missing type support */
! 34151: return(test_ret);
! 34152: }
! 34153:
! 34154: #ifdef LIBXML_SCHEMAS_ENABLED
! 34155:
! 34156: #define gen_nb_xmlSAXHandlerPtr_ptr 1
! 34157: static xmlSAXHandlerPtr * gen_xmlSAXHandlerPtr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 34158: return(NULL);
! 34159: }
! 34160: static void des_xmlSAXHandlerPtr_ptr(int no ATTRIBUTE_UNUSED, xmlSAXHandlerPtr * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 34161: }
! 34162: #endif
! 34163:
! 34164:
! 34165: static int
! 34166: test_xmlSchemaSAXPlug(void) {
! 34167: int test_ret = 0;
! 34168:
! 34169:
! 34170: /* missing type support */
! 34171: return(test_ret);
! 34172: }
! 34173:
! 34174: #ifdef LIBXML_SCHEMAS_ENABLED
! 34175:
! 34176: #define gen_nb_xmlSchemaSAXPlugPtr 1
! 34177: static xmlSchemaSAXPlugPtr gen_xmlSchemaSAXPlugPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 34178: return(NULL);
! 34179: }
! 34180: static void des_xmlSchemaSAXPlugPtr(int no ATTRIBUTE_UNUSED, xmlSchemaSAXPlugPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 34181: }
! 34182: #endif
! 34183:
! 34184:
! 34185: static int
! 34186: test_xmlSchemaSAXUnplug(void) {
! 34187: int test_ret = 0;
! 34188:
! 34189: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34190: int mem_base;
! 34191: int ret_val;
! 34192: xmlSchemaSAXPlugPtr plug; /* a data structure returned by xmlSchemaSAXPlug */
! 34193: int n_plug;
! 34194:
! 34195: for (n_plug = 0;n_plug < gen_nb_xmlSchemaSAXPlugPtr;n_plug++) {
! 34196: mem_base = xmlMemBlocks();
! 34197: plug = gen_xmlSchemaSAXPlugPtr(n_plug, 0);
! 34198:
! 34199: ret_val = xmlSchemaSAXUnplug(plug);
! 34200: desret_int(ret_val);
! 34201: call_tests++;
! 34202: des_xmlSchemaSAXPlugPtr(n_plug, plug, 0);
! 34203: xmlResetLastError();
! 34204: if (mem_base != xmlMemBlocks()) {
! 34205: printf("Leak of %d blocks found in xmlSchemaSAXUnplug",
! 34206: xmlMemBlocks() - mem_base);
! 34207: test_ret++;
! 34208: printf(" %d", n_plug);
! 34209: printf("\n");
! 34210: }
! 34211: }
! 34212: function_tests++;
! 34213: #endif
! 34214:
! 34215: return(test_ret);
! 34216: }
! 34217:
! 34218:
! 34219: static int
! 34220: test_xmlSchemaSetParserErrors(void) {
! 34221: int test_ret = 0;
! 34222:
! 34223:
! 34224: /* missing type support */
! 34225: return(test_ret);
! 34226: }
! 34227:
! 34228:
! 34229: static int
! 34230: test_xmlSchemaSetParserStructuredErrors(void) {
! 34231: int test_ret = 0;
! 34232:
! 34233:
! 34234: /* missing type support */
! 34235: return(test_ret);
! 34236: }
! 34237:
! 34238:
! 34239: static int
! 34240: test_xmlSchemaSetValidErrors(void) {
! 34241: int test_ret = 0;
! 34242:
! 34243:
! 34244: /* missing type support */
! 34245: return(test_ret);
! 34246: }
! 34247:
! 34248:
! 34249: static int
! 34250: test_xmlSchemaSetValidOptions(void) {
! 34251: int test_ret = 0;
! 34252:
! 34253: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34254: int mem_base;
! 34255: int ret_val;
! 34256: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
! 34257: int n_ctxt;
! 34258: int options; /* a combination of xmlSchemaValidOption */
! 34259: int n_options;
! 34260:
! 34261: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
! 34262: for (n_options = 0;n_options < gen_nb_int;n_options++) {
! 34263: mem_base = xmlMemBlocks();
! 34264: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
! 34265: options = gen_int(n_options, 1);
! 34266:
! 34267: ret_val = xmlSchemaSetValidOptions(ctxt, options);
! 34268: desret_int(ret_val);
! 34269: call_tests++;
! 34270: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
! 34271: des_int(n_options, options, 1);
! 34272: xmlResetLastError();
! 34273: if (mem_base != xmlMemBlocks()) {
! 34274: printf("Leak of %d blocks found in xmlSchemaSetValidOptions",
! 34275: xmlMemBlocks() - mem_base);
! 34276: test_ret++;
! 34277: printf(" %d", n_ctxt);
! 34278: printf(" %d", n_options);
! 34279: printf("\n");
! 34280: }
! 34281: }
! 34282: }
! 34283: function_tests++;
! 34284: #endif
! 34285:
! 34286: return(test_ret);
! 34287: }
! 34288:
! 34289:
! 34290: static int
! 34291: test_xmlSchemaSetValidStructuredErrors(void) {
! 34292: int test_ret = 0;
! 34293:
! 34294:
! 34295: /* missing type support */
! 34296: return(test_ret);
! 34297: }
! 34298:
! 34299:
! 34300: static int
! 34301: test_xmlSchemaValidCtxtGetOptions(void) {
! 34302: int test_ret = 0;
! 34303:
! 34304: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34305: int mem_base;
! 34306: int ret_val;
! 34307: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
! 34308: int n_ctxt;
! 34309:
! 34310: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
! 34311: mem_base = xmlMemBlocks();
! 34312: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
! 34313:
! 34314: ret_val = xmlSchemaValidCtxtGetOptions(ctxt);
! 34315: desret_int(ret_val);
! 34316: call_tests++;
! 34317: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
! 34318: xmlResetLastError();
! 34319: if (mem_base != xmlMemBlocks()) {
! 34320: printf("Leak of %d blocks found in xmlSchemaValidCtxtGetOptions",
! 34321: xmlMemBlocks() - mem_base);
! 34322: test_ret++;
! 34323: printf(" %d", n_ctxt);
! 34324: printf("\n");
! 34325: }
! 34326: }
! 34327: function_tests++;
! 34328: #endif
! 34329:
! 34330: return(test_ret);
! 34331: }
! 34332:
! 34333:
! 34334: static int
! 34335: test_xmlSchemaValidCtxtGetParserCtxt(void) {
! 34336: int test_ret = 0;
! 34337:
! 34338: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34339: int mem_base;
! 34340: xmlParserCtxtPtr ret_val;
! 34341: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
! 34342: int n_ctxt;
! 34343:
! 34344: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
! 34345: mem_base = xmlMemBlocks();
! 34346: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
! 34347:
! 34348: ret_val = xmlSchemaValidCtxtGetParserCtxt(ctxt);
! 34349: desret_xmlParserCtxtPtr(ret_val);
! 34350: call_tests++;
! 34351: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
! 34352: xmlResetLastError();
! 34353: if (mem_base != xmlMemBlocks()) {
! 34354: printf("Leak of %d blocks found in xmlSchemaValidCtxtGetParserCtxt",
! 34355: xmlMemBlocks() - mem_base);
! 34356: test_ret++;
! 34357: printf(" %d", n_ctxt);
! 34358: printf("\n");
! 34359: }
! 34360: }
! 34361: function_tests++;
! 34362: #endif
! 34363:
! 34364: return(test_ret);
! 34365: }
! 34366:
! 34367:
! 34368: static int
! 34369: test_xmlSchemaValidateDoc(void) {
! 34370: int test_ret = 0;
! 34371:
! 34372: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34373: int mem_base;
! 34374: int ret_val;
! 34375: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
! 34376: int n_ctxt;
! 34377: xmlDocPtr doc; /* a parsed document tree */
! 34378: int n_doc;
! 34379:
! 34380: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
! 34381: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 34382: mem_base = xmlMemBlocks();
! 34383: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
! 34384: doc = gen_xmlDocPtr(n_doc, 1);
! 34385:
! 34386: ret_val = xmlSchemaValidateDoc(ctxt, doc);
! 34387: desret_int(ret_val);
! 34388: call_tests++;
! 34389: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
! 34390: des_xmlDocPtr(n_doc, doc, 1);
! 34391: xmlResetLastError();
! 34392: if (mem_base != xmlMemBlocks()) {
! 34393: printf("Leak of %d blocks found in xmlSchemaValidateDoc",
! 34394: xmlMemBlocks() - mem_base);
! 34395: test_ret++;
! 34396: printf(" %d", n_ctxt);
! 34397: printf(" %d", n_doc);
! 34398: printf("\n");
! 34399: }
! 34400: }
! 34401: }
! 34402: function_tests++;
! 34403: #endif
! 34404:
! 34405: return(test_ret);
! 34406: }
! 34407:
! 34408:
! 34409: static int
! 34410: test_xmlSchemaValidateFile(void) {
! 34411: int test_ret = 0;
! 34412:
! 34413: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34414: int mem_base;
! 34415: int ret_val;
! 34416: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
! 34417: int n_ctxt;
! 34418: const char * filename; /* the URI of the instance */
! 34419: int n_filename;
! 34420: int options; /* a future set of options, currently unused */
! 34421: int n_options;
! 34422:
! 34423: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
! 34424: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 34425: for (n_options = 0;n_options < gen_nb_int;n_options++) {
! 34426: mem_base = xmlMemBlocks();
! 34427: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
! 34428: filename = gen_filepath(n_filename, 1);
! 34429: options = gen_int(n_options, 2);
! 34430:
! 34431: ret_val = xmlSchemaValidateFile(ctxt, filename, options);
! 34432: desret_int(ret_val);
! 34433: call_tests++;
! 34434: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
! 34435: des_filepath(n_filename, filename, 1);
! 34436: des_int(n_options, options, 2);
! 34437: xmlResetLastError();
! 34438: if (mem_base != xmlMemBlocks()) {
! 34439: printf("Leak of %d blocks found in xmlSchemaValidateFile",
! 34440: xmlMemBlocks() - mem_base);
! 34441: test_ret++;
! 34442: printf(" %d", n_ctxt);
! 34443: printf(" %d", n_filename);
! 34444: printf(" %d", n_options);
! 34445: printf("\n");
! 34446: }
! 34447: }
! 34448: }
! 34449: }
! 34450: function_tests++;
! 34451: #endif
! 34452:
! 34453: return(test_ret);
! 34454: }
! 34455:
! 34456:
! 34457: static int
! 34458: test_xmlSchemaValidateOneElement(void) {
! 34459: int test_ret = 0;
! 34460:
! 34461: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34462: int mem_base;
! 34463: int ret_val;
! 34464: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
! 34465: int n_ctxt;
! 34466: xmlNodePtr elem; /* an element node */
! 34467: int n_elem;
! 34468:
! 34469: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
! 34470: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
! 34471: mem_base = xmlMemBlocks();
! 34472: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
! 34473: elem = gen_xmlNodePtr(n_elem, 1);
! 34474:
! 34475: ret_val = xmlSchemaValidateOneElement(ctxt, elem);
! 34476: desret_int(ret_val);
! 34477: call_tests++;
! 34478: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
! 34479: des_xmlNodePtr(n_elem, elem, 1);
! 34480: xmlResetLastError();
! 34481: if (mem_base != xmlMemBlocks()) {
! 34482: printf("Leak of %d blocks found in xmlSchemaValidateOneElement",
! 34483: xmlMemBlocks() - mem_base);
! 34484: test_ret++;
! 34485: printf(" %d", n_ctxt);
! 34486: printf(" %d", n_elem);
! 34487: printf("\n");
! 34488: }
! 34489: }
! 34490: }
! 34491: function_tests++;
! 34492: #endif
! 34493:
! 34494: return(test_ret);
! 34495: }
! 34496:
! 34497:
! 34498: static int
! 34499: test_xmlSchemaValidateStream(void) {
! 34500: int test_ret = 0;
! 34501:
! 34502: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34503: int mem_base;
! 34504: int ret_val;
! 34505: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
! 34506: int n_ctxt;
! 34507: xmlParserInputBufferPtr input; /* the input to use for reading the data */
! 34508: int n_input;
! 34509: xmlCharEncoding enc; /* an optional encoding information */
! 34510: int n_enc;
! 34511: xmlSAXHandlerPtr sax; /* a SAX handler for the resulting events */
! 34512: int n_sax;
! 34513: void * user_data; /* the context to provide to the SAX handler. */
! 34514: int n_user_data;
! 34515:
! 34516: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
! 34517: for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
! 34518: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
! 34519: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
! 34520: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
! 34521: mem_base = xmlMemBlocks();
! 34522: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
! 34523: input = gen_xmlParserInputBufferPtr(n_input, 1);
! 34524: enc = gen_xmlCharEncoding(n_enc, 2);
! 34525: sax = gen_xmlSAXHandlerPtr(n_sax, 3);
! 34526: user_data = gen_userdata(n_user_data, 4);
! 34527:
! 34528: ret_val = xmlSchemaValidateStream(ctxt, input, enc, sax, user_data);
! 34529: desret_int(ret_val);
! 34530: call_tests++;
! 34531: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
! 34532: des_xmlParserInputBufferPtr(n_input, input, 1);
! 34533: des_xmlCharEncoding(n_enc, enc, 2);
! 34534: des_xmlSAXHandlerPtr(n_sax, sax, 3);
! 34535: des_userdata(n_user_data, user_data, 4);
! 34536: xmlResetLastError();
! 34537: if (mem_base != xmlMemBlocks()) {
! 34538: printf("Leak of %d blocks found in xmlSchemaValidateStream",
! 34539: xmlMemBlocks() - mem_base);
! 34540: test_ret++;
! 34541: printf(" %d", n_ctxt);
! 34542: printf(" %d", n_input);
! 34543: printf(" %d", n_enc);
! 34544: printf(" %d", n_sax);
! 34545: printf(" %d", n_user_data);
! 34546: printf("\n");
! 34547: }
! 34548: }
! 34549: }
! 34550: }
! 34551: }
! 34552: }
! 34553: function_tests++;
! 34554: #endif
! 34555:
! 34556: return(test_ret);
! 34557: }
! 34558:
! 34559: static int
! 34560: test_xmlschemas(void) {
! 34561: int test_ret = 0;
! 34562:
! 34563: if (quiet == 0) printf("Testing xmlschemas : 15 of 25 functions ...\n");
! 34564: test_ret += test_xmlSchemaDump();
! 34565: test_ret += test_xmlSchemaGetParserErrors();
! 34566: test_ret += test_xmlSchemaGetValidErrors();
! 34567: test_ret += test_xmlSchemaIsValid();
! 34568: test_ret += test_xmlSchemaNewDocParserCtxt();
! 34569: test_ret += test_xmlSchemaNewMemParserCtxt();
! 34570: test_ret += test_xmlSchemaNewParserCtxt();
! 34571: test_ret += test_xmlSchemaNewValidCtxt();
! 34572: test_ret += test_xmlSchemaParse();
! 34573: test_ret += test_xmlSchemaSAXPlug();
! 34574: test_ret += test_xmlSchemaSAXUnplug();
! 34575: test_ret += test_xmlSchemaSetParserErrors();
! 34576: test_ret += test_xmlSchemaSetParserStructuredErrors();
! 34577: test_ret += test_xmlSchemaSetValidErrors();
! 34578: test_ret += test_xmlSchemaSetValidOptions();
! 34579: test_ret += test_xmlSchemaSetValidStructuredErrors();
! 34580: test_ret += test_xmlSchemaValidCtxtGetOptions();
! 34581: test_ret += test_xmlSchemaValidCtxtGetParserCtxt();
! 34582: test_ret += test_xmlSchemaValidateDoc();
! 34583: test_ret += test_xmlSchemaValidateFile();
! 34584: test_ret += test_xmlSchemaValidateOneElement();
! 34585: test_ret += test_xmlSchemaValidateStream();
! 34586:
! 34587: if (test_ret != 0)
! 34588: printf("Module xmlschemas: %d errors\n", test_ret);
! 34589: return(test_ret);
! 34590: }
! 34591: #ifdef LIBXML_SCHEMAS_ENABLED
! 34592:
! 34593: #define gen_nb_xmlSchemaFacetPtr 1
! 34594: static xmlSchemaFacetPtr gen_xmlSchemaFacetPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 34595: return(NULL);
! 34596: }
! 34597: static void des_xmlSchemaFacetPtr(int no ATTRIBUTE_UNUSED, xmlSchemaFacetPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 34598: }
! 34599: #endif
! 34600:
! 34601: #ifdef LIBXML_SCHEMAS_ENABLED
! 34602:
! 34603: #define gen_nb_xmlSchemaTypePtr 1
! 34604: static xmlSchemaTypePtr gen_xmlSchemaTypePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 34605: return(NULL);
! 34606: }
! 34607: static void des_xmlSchemaTypePtr(int no ATTRIBUTE_UNUSED, xmlSchemaTypePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 34608: }
! 34609: #endif
! 34610:
! 34611:
! 34612: static int
! 34613: test_xmlSchemaCheckFacet(void) {
! 34614: int test_ret = 0;
! 34615:
! 34616: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34617: int mem_base;
! 34618: int ret_val;
! 34619: xmlSchemaFacetPtr facet; /* the facet */
! 34620: int n_facet;
! 34621: xmlSchemaTypePtr typeDecl; /* the schema type definition */
! 34622: int n_typeDecl;
! 34623: xmlSchemaParserCtxtPtr pctxt; /* the schema parser context or NULL */
! 34624: int n_pctxt;
! 34625: xmlChar * name; /* the optional name of the type */
! 34626: int n_name;
! 34627:
! 34628: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
! 34629: for (n_typeDecl = 0;n_typeDecl < gen_nb_xmlSchemaTypePtr;n_typeDecl++) {
! 34630: for (n_pctxt = 0;n_pctxt < gen_nb_xmlSchemaParserCtxtPtr;n_pctxt++) {
! 34631: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 34632: mem_base = xmlMemBlocks();
! 34633: facet = gen_xmlSchemaFacetPtr(n_facet, 0);
! 34634: typeDecl = gen_xmlSchemaTypePtr(n_typeDecl, 1);
! 34635: pctxt = gen_xmlSchemaParserCtxtPtr(n_pctxt, 2);
! 34636: name = gen_const_xmlChar_ptr(n_name, 3);
! 34637:
! 34638: ret_val = xmlSchemaCheckFacet(facet, typeDecl, pctxt, (const xmlChar *)name);
! 34639: desret_int(ret_val);
! 34640: call_tests++;
! 34641: des_xmlSchemaFacetPtr(n_facet, facet, 0);
! 34642: des_xmlSchemaTypePtr(n_typeDecl, typeDecl, 1);
! 34643: des_xmlSchemaParserCtxtPtr(n_pctxt, pctxt, 2);
! 34644: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 3);
! 34645: xmlResetLastError();
! 34646: if (mem_base != xmlMemBlocks()) {
! 34647: printf("Leak of %d blocks found in xmlSchemaCheckFacet",
! 34648: xmlMemBlocks() - mem_base);
! 34649: test_ret++;
! 34650: printf(" %d", n_facet);
! 34651: printf(" %d", n_typeDecl);
! 34652: printf(" %d", n_pctxt);
! 34653: printf(" %d", n_name);
! 34654: printf("\n");
! 34655: }
! 34656: }
! 34657: }
! 34658: }
! 34659: }
! 34660: function_tests++;
! 34661: #endif
! 34662:
! 34663: return(test_ret);
! 34664: }
! 34665:
! 34666:
! 34667: static int
! 34668: test_xmlSchemaCleanupTypes(void) {
! 34669: int test_ret = 0;
! 34670:
! 34671: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34672:
! 34673:
! 34674: xmlSchemaCleanupTypes();
! 34675: call_tests++;
! 34676: xmlResetLastError();
! 34677: function_tests++;
! 34678: #endif
! 34679:
! 34680: return(test_ret);
! 34681: }
! 34682:
! 34683:
! 34684: static int
! 34685: test_xmlSchemaCollapseString(void) {
! 34686: int test_ret = 0;
! 34687:
! 34688: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34689: int mem_base;
! 34690: xmlChar * ret_val;
! 34691: xmlChar * value; /* a value */
! 34692: int n_value;
! 34693:
! 34694: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 34695: mem_base = xmlMemBlocks();
! 34696: value = gen_const_xmlChar_ptr(n_value, 0);
! 34697:
! 34698: ret_val = xmlSchemaCollapseString((const xmlChar *)value);
! 34699: desret_xmlChar_ptr(ret_val);
! 34700: call_tests++;
! 34701: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
! 34702: xmlResetLastError();
! 34703: if (mem_base != xmlMemBlocks()) {
! 34704: printf("Leak of %d blocks found in xmlSchemaCollapseString",
! 34705: xmlMemBlocks() - mem_base);
! 34706: test_ret++;
! 34707: printf(" %d", n_value);
! 34708: printf("\n");
! 34709: }
! 34710: }
! 34711: function_tests++;
! 34712: #endif
! 34713:
! 34714: return(test_ret);
! 34715: }
! 34716:
! 34717: #ifdef LIBXML_SCHEMAS_ENABLED
! 34718:
! 34719: #define gen_nb_xmlSchemaValPtr 1
! 34720: static xmlSchemaValPtr gen_xmlSchemaValPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 34721: return(NULL);
! 34722: }
! 34723: static void des_xmlSchemaValPtr(int no ATTRIBUTE_UNUSED, xmlSchemaValPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 34724: }
! 34725: #endif
! 34726:
! 34727:
! 34728: static int
! 34729: test_xmlSchemaCompareValues(void) {
! 34730: int test_ret = 0;
! 34731:
! 34732: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34733: int mem_base;
! 34734: int ret_val;
! 34735: xmlSchemaValPtr x; /* a first value */
! 34736: int n_x;
! 34737: xmlSchemaValPtr y; /* a second value */
! 34738: int n_y;
! 34739:
! 34740: for (n_x = 0;n_x < gen_nb_xmlSchemaValPtr;n_x++) {
! 34741: for (n_y = 0;n_y < gen_nb_xmlSchemaValPtr;n_y++) {
! 34742: mem_base = xmlMemBlocks();
! 34743: x = gen_xmlSchemaValPtr(n_x, 0);
! 34744: y = gen_xmlSchemaValPtr(n_y, 1);
! 34745:
! 34746: ret_val = xmlSchemaCompareValues(x, y);
! 34747: desret_int(ret_val);
! 34748: call_tests++;
! 34749: des_xmlSchemaValPtr(n_x, x, 0);
! 34750: des_xmlSchemaValPtr(n_y, y, 1);
! 34751: xmlResetLastError();
! 34752: if (mem_base != xmlMemBlocks()) {
! 34753: printf("Leak of %d blocks found in xmlSchemaCompareValues",
! 34754: xmlMemBlocks() - mem_base);
! 34755: test_ret++;
! 34756: printf(" %d", n_x);
! 34757: printf(" %d", n_y);
! 34758: printf("\n");
! 34759: }
! 34760: }
! 34761: }
! 34762: function_tests++;
! 34763: #endif
! 34764:
! 34765: return(test_ret);
! 34766: }
! 34767:
! 34768:
! 34769: static int
! 34770: test_xmlSchemaCompareValuesWhtsp(void) {
! 34771: int test_ret = 0;
! 34772:
! 34773: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34774: int mem_base;
! 34775: int ret_val;
! 34776: xmlSchemaValPtr x; /* a first value */
! 34777: int n_x;
! 34778: xmlSchemaWhitespaceValueType xws; /* the whitespace value of x */
! 34779: int n_xws;
! 34780: xmlSchemaValPtr y; /* a second value */
! 34781: int n_y;
! 34782: xmlSchemaWhitespaceValueType yws; /* the whitespace value of y */
! 34783: int n_yws;
! 34784:
! 34785: for (n_x = 0;n_x < gen_nb_xmlSchemaValPtr;n_x++) {
! 34786: for (n_xws = 0;n_xws < gen_nb_xmlSchemaWhitespaceValueType;n_xws++) {
! 34787: for (n_y = 0;n_y < gen_nb_xmlSchemaValPtr;n_y++) {
! 34788: for (n_yws = 0;n_yws < gen_nb_xmlSchemaWhitespaceValueType;n_yws++) {
! 34789: mem_base = xmlMemBlocks();
! 34790: x = gen_xmlSchemaValPtr(n_x, 0);
! 34791: xws = gen_xmlSchemaWhitespaceValueType(n_xws, 1);
! 34792: y = gen_xmlSchemaValPtr(n_y, 2);
! 34793: yws = gen_xmlSchemaWhitespaceValueType(n_yws, 3);
! 34794:
! 34795: ret_val = xmlSchemaCompareValuesWhtsp(x, xws, y, yws);
! 34796: desret_int(ret_val);
! 34797: call_tests++;
! 34798: des_xmlSchemaValPtr(n_x, x, 0);
! 34799: des_xmlSchemaWhitespaceValueType(n_xws, xws, 1);
! 34800: des_xmlSchemaValPtr(n_y, y, 2);
! 34801: des_xmlSchemaWhitespaceValueType(n_yws, yws, 3);
! 34802: xmlResetLastError();
! 34803: if (mem_base != xmlMemBlocks()) {
! 34804: printf("Leak of %d blocks found in xmlSchemaCompareValuesWhtsp",
! 34805: xmlMemBlocks() - mem_base);
! 34806: test_ret++;
! 34807: printf(" %d", n_x);
! 34808: printf(" %d", n_xws);
! 34809: printf(" %d", n_y);
! 34810: printf(" %d", n_yws);
! 34811: printf("\n");
! 34812: }
! 34813: }
! 34814: }
! 34815: }
! 34816: }
! 34817: function_tests++;
! 34818: #endif
! 34819:
! 34820: return(test_ret);
! 34821: }
! 34822:
! 34823:
! 34824: static int
! 34825: test_xmlSchemaCopyValue(void) {
! 34826: int test_ret = 0;
! 34827:
! 34828:
! 34829: /* missing type support */
! 34830: return(test_ret);
! 34831: }
! 34832:
! 34833:
! 34834: static int
! 34835: test_xmlSchemaGetBuiltInListSimpleTypeItemType(void) {
! 34836: int test_ret = 0;
! 34837:
! 34838: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34839: int mem_base;
! 34840: xmlSchemaTypePtr ret_val;
! 34841: xmlSchemaTypePtr type; /* the built-in simple type. */
! 34842: int n_type;
! 34843:
! 34844: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
! 34845: mem_base = xmlMemBlocks();
! 34846: type = gen_xmlSchemaTypePtr(n_type, 0);
! 34847:
! 34848: ret_val = xmlSchemaGetBuiltInListSimpleTypeItemType(type);
! 34849: desret_xmlSchemaTypePtr(ret_val);
! 34850: call_tests++;
! 34851: des_xmlSchemaTypePtr(n_type, type, 0);
! 34852: xmlResetLastError();
! 34853: if (mem_base != xmlMemBlocks()) {
! 34854: printf("Leak of %d blocks found in xmlSchemaGetBuiltInListSimpleTypeItemType",
! 34855: xmlMemBlocks() - mem_base);
! 34856: test_ret++;
! 34857: printf(" %d", n_type);
! 34858: printf("\n");
! 34859: }
! 34860: }
! 34861: function_tests++;
! 34862: #endif
! 34863:
! 34864: return(test_ret);
! 34865: }
! 34866:
! 34867:
! 34868: static int
! 34869: test_xmlSchemaGetBuiltInType(void) {
! 34870: int test_ret = 0;
! 34871:
! 34872: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34873: xmlSchemaTypePtr ret_val;
! 34874: xmlSchemaValType type; /* the type of the built in type */
! 34875: int n_type;
! 34876:
! 34877: for (n_type = 0;n_type < gen_nb_xmlSchemaValType;n_type++) {
! 34878: type = gen_xmlSchemaValType(n_type, 0);
! 34879:
! 34880: ret_val = xmlSchemaGetBuiltInType(type);
! 34881: desret_xmlSchemaTypePtr(ret_val);
! 34882: call_tests++;
! 34883: des_xmlSchemaValType(n_type, type, 0);
! 34884: xmlResetLastError();
! 34885: }
! 34886: function_tests++;
! 34887: #endif
! 34888:
! 34889: return(test_ret);
! 34890: }
! 34891:
! 34892:
! 34893: static int
! 34894: test_xmlSchemaGetCanonValue(void) {
! 34895: int test_ret = 0;
! 34896:
! 34897: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34898: int mem_base;
! 34899: int ret_val;
! 34900: xmlSchemaValPtr val; /* the precomputed value */
! 34901: int n_val;
! 34902: xmlChar ** retValue; /* the returned value */
! 34903: int n_retValue;
! 34904:
! 34905: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
! 34906: for (n_retValue = 0;n_retValue < gen_nb_const_xmlChar_ptr_ptr;n_retValue++) {
! 34907: mem_base = xmlMemBlocks();
! 34908: val = gen_xmlSchemaValPtr(n_val, 0);
! 34909: retValue = gen_const_xmlChar_ptr_ptr(n_retValue, 1);
! 34910:
! 34911: ret_val = xmlSchemaGetCanonValue(val, (const xmlChar **)retValue);
! 34912: desret_int(ret_val);
! 34913: call_tests++;
! 34914: des_xmlSchemaValPtr(n_val, val, 0);
! 34915: des_const_xmlChar_ptr_ptr(n_retValue, (const xmlChar **)retValue, 1);
! 34916: xmlResetLastError();
! 34917: if (mem_base != xmlMemBlocks()) {
! 34918: printf("Leak of %d blocks found in xmlSchemaGetCanonValue",
! 34919: xmlMemBlocks() - mem_base);
! 34920: test_ret++;
! 34921: printf(" %d", n_val);
! 34922: printf(" %d", n_retValue);
! 34923: printf("\n");
! 34924: }
! 34925: }
! 34926: }
! 34927: function_tests++;
! 34928: #endif
! 34929:
! 34930: return(test_ret);
! 34931: }
! 34932:
! 34933:
! 34934: static int
! 34935: test_xmlSchemaGetCanonValueWhtsp(void) {
! 34936: int test_ret = 0;
! 34937:
! 34938: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34939: int mem_base;
! 34940: int ret_val;
! 34941: xmlSchemaValPtr val; /* the precomputed value */
! 34942: int n_val;
! 34943: xmlChar ** retValue; /* the returned value */
! 34944: int n_retValue;
! 34945: xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */
! 34946: int n_ws;
! 34947:
! 34948: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
! 34949: for (n_retValue = 0;n_retValue < gen_nb_const_xmlChar_ptr_ptr;n_retValue++) {
! 34950: for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) {
! 34951: mem_base = xmlMemBlocks();
! 34952: val = gen_xmlSchemaValPtr(n_val, 0);
! 34953: retValue = gen_const_xmlChar_ptr_ptr(n_retValue, 1);
! 34954: ws = gen_xmlSchemaWhitespaceValueType(n_ws, 2);
! 34955:
! 34956: ret_val = xmlSchemaGetCanonValueWhtsp(val, (const xmlChar **)retValue, ws);
! 34957: desret_int(ret_val);
! 34958: call_tests++;
! 34959: des_xmlSchemaValPtr(n_val, val, 0);
! 34960: des_const_xmlChar_ptr_ptr(n_retValue, (const xmlChar **)retValue, 1);
! 34961: des_xmlSchemaWhitespaceValueType(n_ws, ws, 2);
! 34962: xmlResetLastError();
! 34963: if (mem_base != xmlMemBlocks()) {
! 34964: printf("Leak of %d blocks found in xmlSchemaGetCanonValueWhtsp",
! 34965: xmlMemBlocks() - mem_base);
! 34966: test_ret++;
! 34967: printf(" %d", n_val);
! 34968: printf(" %d", n_retValue);
! 34969: printf(" %d", n_ws);
! 34970: printf("\n");
! 34971: }
! 34972: }
! 34973: }
! 34974: }
! 34975: function_tests++;
! 34976: #endif
! 34977:
! 34978: return(test_ret);
! 34979: }
! 34980:
! 34981:
! 34982: static int
! 34983: test_xmlSchemaGetFacetValueAsULong(void) {
! 34984: int test_ret = 0;
! 34985:
! 34986: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34987: int mem_base;
! 34988: unsigned long ret_val;
! 34989: xmlSchemaFacetPtr facet; /* an schemas type facet */
! 34990: int n_facet;
! 34991:
! 34992: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
! 34993: mem_base = xmlMemBlocks();
! 34994: facet = gen_xmlSchemaFacetPtr(n_facet, 0);
! 34995:
! 34996: ret_val = xmlSchemaGetFacetValueAsULong(facet);
! 34997: desret_unsigned_long(ret_val);
! 34998: call_tests++;
! 34999: des_xmlSchemaFacetPtr(n_facet, facet, 0);
! 35000: xmlResetLastError();
! 35001: if (mem_base != xmlMemBlocks()) {
! 35002: printf("Leak of %d blocks found in xmlSchemaGetFacetValueAsULong",
! 35003: xmlMemBlocks() - mem_base);
! 35004: test_ret++;
! 35005: printf(" %d", n_facet);
! 35006: printf("\n");
! 35007: }
! 35008: }
! 35009: function_tests++;
! 35010: #endif
! 35011:
! 35012: return(test_ret);
! 35013: }
! 35014:
! 35015:
! 35016: static int
! 35017: test_xmlSchemaGetPredefinedType(void) {
! 35018: int test_ret = 0;
! 35019:
! 35020: #if defined(LIBXML_SCHEMAS_ENABLED)
! 35021: int mem_base;
! 35022: xmlSchemaTypePtr ret_val;
! 35023: xmlChar * name; /* the type name */
! 35024: int n_name;
! 35025: xmlChar * ns; /* the URI of the namespace usually "http://www.w3.org/2001/XMLSchema" */
! 35026: int n_ns;
! 35027:
! 35028: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 35029: for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
! 35030: mem_base = xmlMemBlocks();
! 35031: name = gen_const_xmlChar_ptr(n_name, 0);
! 35032: ns = gen_const_xmlChar_ptr(n_ns, 1);
! 35033:
! 35034: ret_val = xmlSchemaGetPredefinedType((const xmlChar *)name, (const xmlChar *)ns);
! 35035: desret_xmlSchemaTypePtr(ret_val);
! 35036: call_tests++;
! 35037: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
! 35038: des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 1);
! 35039: xmlResetLastError();
! 35040: if (mem_base != xmlMemBlocks()) {
! 35041: printf("Leak of %d blocks found in xmlSchemaGetPredefinedType",
! 35042: xmlMemBlocks() - mem_base);
! 35043: test_ret++;
! 35044: printf(" %d", n_name);
! 35045: printf(" %d", n_ns);
! 35046: printf("\n");
! 35047: }
! 35048: }
! 35049: }
! 35050: function_tests++;
! 35051: #endif
! 35052:
! 35053: return(test_ret);
! 35054: }
! 35055:
! 35056:
! 35057: static int
! 35058: test_xmlSchemaGetValType(void) {
! 35059: int test_ret = 0;
! 35060:
! 35061: #if defined(LIBXML_SCHEMAS_ENABLED)
! 35062: int mem_base;
! 35063: xmlSchemaValType ret_val;
! 35064: xmlSchemaValPtr val; /* a schemas value */
! 35065: int n_val;
! 35066:
! 35067: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
! 35068: mem_base = xmlMemBlocks();
! 35069: val = gen_xmlSchemaValPtr(n_val, 0);
! 35070:
! 35071: ret_val = xmlSchemaGetValType(val);
! 35072: desret_xmlSchemaValType(ret_val);
! 35073: call_tests++;
! 35074: des_xmlSchemaValPtr(n_val, val, 0);
! 35075: xmlResetLastError();
! 35076: if (mem_base != xmlMemBlocks()) {
! 35077: printf("Leak of %d blocks found in xmlSchemaGetValType",
! 35078: xmlMemBlocks() - mem_base);
! 35079: test_ret++;
! 35080: printf(" %d", n_val);
! 35081: printf("\n");
! 35082: }
! 35083: }
! 35084: function_tests++;
! 35085: #endif
! 35086:
! 35087: return(test_ret);
! 35088: }
! 35089:
! 35090:
! 35091: static int
! 35092: test_xmlSchemaInitTypes(void) {
! 35093: int test_ret = 0;
! 35094:
! 35095: #if defined(LIBXML_SCHEMAS_ENABLED)
! 35096:
! 35097:
! 35098: xmlSchemaInitTypes();
! 35099: call_tests++;
! 35100: xmlResetLastError();
! 35101: function_tests++;
! 35102: #endif
! 35103:
! 35104: return(test_ret);
! 35105: }
! 35106:
! 35107:
! 35108: static int
! 35109: test_xmlSchemaIsBuiltInTypeFacet(void) {
! 35110: int test_ret = 0;
! 35111:
! 35112: #if defined(LIBXML_SCHEMAS_ENABLED)
! 35113: int mem_base;
! 35114: int ret_val;
! 35115: xmlSchemaTypePtr type; /* the built-in type */
! 35116: int n_type;
! 35117: int facetType; /* the facet type */
! 35118: int n_facetType;
! 35119:
! 35120: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
! 35121: for (n_facetType = 0;n_facetType < gen_nb_int;n_facetType++) {
! 35122: mem_base = xmlMemBlocks();
! 35123: type = gen_xmlSchemaTypePtr(n_type, 0);
! 35124: facetType = gen_int(n_facetType, 1);
! 35125:
! 35126: ret_val = xmlSchemaIsBuiltInTypeFacet(type, facetType);
! 35127: desret_int(ret_val);
! 35128: call_tests++;
! 35129: des_xmlSchemaTypePtr(n_type, type, 0);
! 35130: des_int(n_facetType, facetType, 1);
! 35131: xmlResetLastError();
! 35132: if (mem_base != xmlMemBlocks()) {
! 35133: printf("Leak of %d blocks found in xmlSchemaIsBuiltInTypeFacet",
! 35134: xmlMemBlocks() - mem_base);
! 35135: test_ret++;
! 35136: printf(" %d", n_type);
! 35137: printf(" %d", n_facetType);
! 35138: printf("\n");
! 35139: }
! 35140: }
! 35141: }
! 35142: function_tests++;
! 35143: #endif
! 35144:
! 35145: return(test_ret);
! 35146: }
! 35147:
! 35148:
! 35149: static int
! 35150: test_xmlSchemaNewFacet(void) {
! 35151: int test_ret = 0;
! 35152:
! 35153:
! 35154: /* missing type support */
! 35155: return(test_ret);
! 35156: }
! 35157:
! 35158:
! 35159: static int
! 35160: test_xmlSchemaNewNOTATIONValue(void) {
! 35161: int test_ret = 0;
! 35162:
! 35163:
! 35164: /* missing type support */
! 35165: return(test_ret);
! 35166: }
! 35167:
! 35168:
! 35169: static int
! 35170: test_xmlSchemaNewQNameValue(void) {
! 35171: int test_ret = 0;
! 35172:
! 35173:
! 35174: /* missing type support */
! 35175: return(test_ret);
! 35176: }
! 35177:
! 35178:
! 35179: static int
! 35180: test_xmlSchemaNewStringValue(void) {
! 35181: int test_ret = 0;
! 35182:
! 35183:
! 35184: /* missing type support */
! 35185: return(test_ret);
! 35186: }
! 35187:
! 35188: #ifdef LIBXML_SCHEMAS_ENABLED
! 35189:
! 35190: #define gen_nb_xmlSchemaValPtr_ptr 1
! 35191: static xmlSchemaValPtr * gen_xmlSchemaValPtr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 35192: return(NULL);
! 35193: }
! 35194: static void des_xmlSchemaValPtr_ptr(int no ATTRIBUTE_UNUSED, xmlSchemaValPtr * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 35195: }
! 35196: #endif
! 35197:
! 35198:
! 35199: static int
! 35200: test_xmlSchemaValPredefTypeNode(void) {
! 35201: int test_ret = 0;
! 35202:
! 35203: #if defined(LIBXML_SCHEMAS_ENABLED)
! 35204: int mem_base;
! 35205: int ret_val;
! 35206: xmlSchemaTypePtr type; /* the predefined type */
! 35207: int n_type;
! 35208: xmlChar * value; /* the value to check */
! 35209: int n_value;
! 35210: xmlSchemaValPtr * val; /* the return computed value */
! 35211: int n_val;
! 35212: xmlNodePtr node; /* the node containing the value */
! 35213: int n_node;
! 35214:
! 35215: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
! 35216: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 35217: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) {
! 35218: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 35219: mem_base = xmlMemBlocks();
! 35220: type = gen_xmlSchemaTypePtr(n_type, 0);
! 35221: value = gen_const_xmlChar_ptr(n_value, 1);
! 35222: val = gen_xmlSchemaValPtr_ptr(n_val, 2);
! 35223: node = gen_xmlNodePtr(n_node, 3);
! 35224:
! 35225: ret_val = xmlSchemaValPredefTypeNode(type, (const xmlChar *)value, val, node);
! 35226: desret_int(ret_val);
! 35227: call_tests++;
! 35228: des_xmlSchemaTypePtr(n_type, type, 0);
! 35229: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
! 35230: des_xmlSchemaValPtr_ptr(n_val, val, 2);
! 35231: des_xmlNodePtr(n_node, node, 3);
! 35232: xmlResetLastError();
! 35233: if (mem_base != xmlMemBlocks()) {
! 35234: printf("Leak of %d blocks found in xmlSchemaValPredefTypeNode",
! 35235: xmlMemBlocks() - mem_base);
! 35236: test_ret++;
! 35237: printf(" %d", n_type);
! 35238: printf(" %d", n_value);
! 35239: printf(" %d", n_val);
! 35240: printf(" %d", n_node);
! 35241: printf("\n");
! 35242: }
! 35243: }
! 35244: }
! 35245: }
! 35246: }
! 35247: function_tests++;
! 35248: #endif
! 35249:
! 35250: return(test_ret);
! 35251: }
! 35252:
! 35253:
! 35254: static int
! 35255: test_xmlSchemaValPredefTypeNodeNoNorm(void) {
! 35256: int test_ret = 0;
! 35257:
! 35258: #if defined(LIBXML_SCHEMAS_ENABLED)
! 35259: int mem_base;
! 35260: int ret_val;
! 35261: xmlSchemaTypePtr type; /* the predefined type */
! 35262: int n_type;
! 35263: xmlChar * value; /* the value to check */
! 35264: int n_value;
! 35265: xmlSchemaValPtr * val; /* the return computed value */
! 35266: int n_val;
! 35267: xmlNodePtr node; /* the node containing the value */
! 35268: int n_node;
! 35269:
! 35270: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
! 35271: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 35272: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) {
! 35273: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 35274: mem_base = xmlMemBlocks();
! 35275: type = gen_xmlSchemaTypePtr(n_type, 0);
! 35276: value = gen_const_xmlChar_ptr(n_value, 1);
! 35277: val = gen_xmlSchemaValPtr_ptr(n_val, 2);
! 35278: node = gen_xmlNodePtr(n_node, 3);
! 35279:
! 35280: ret_val = xmlSchemaValPredefTypeNodeNoNorm(type, (const xmlChar *)value, val, node);
! 35281: desret_int(ret_val);
! 35282: call_tests++;
! 35283: des_xmlSchemaTypePtr(n_type, type, 0);
! 35284: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
! 35285: des_xmlSchemaValPtr_ptr(n_val, val, 2);
! 35286: des_xmlNodePtr(n_node, node, 3);
! 35287: xmlResetLastError();
! 35288: if (mem_base != xmlMemBlocks()) {
! 35289: printf("Leak of %d blocks found in xmlSchemaValPredefTypeNodeNoNorm",
! 35290: xmlMemBlocks() - mem_base);
! 35291: test_ret++;
! 35292: printf(" %d", n_type);
! 35293: printf(" %d", n_value);
! 35294: printf(" %d", n_val);
! 35295: printf(" %d", n_node);
! 35296: printf("\n");
! 35297: }
! 35298: }
! 35299: }
! 35300: }
! 35301: }
! 35302: function_tests++;
! 35303: #endif
! 35304:
! 35305: return(test_ret);
! 35306: }
! 35307:
! 35308:
! 35309: static int
! 35310: test_xmlSchemaValidateFacet(void) {
! 35311: int test_ret = 0;
! 35312:
! 35313: #if defined(LIBXML_SCHEMAS_ENABLED)
! 35314: int mem_base;
! 35315: int ret_val;
! 35316: xmlSchemaTypePtr base; /* the base type */
! 35317: int n_base;
! 35318: xmlSchemaFacetPtr facet; /* the facet to check */
! 35319: int n_facet;
! 35320: xmlChar * value; /* the lexical repr of the value to validate */
! 35321: int n_value;
! 35322: xmlSchemaValPtr val; /* the precomputed value */
! 35323: int n_val;
! 35324:
! 35325: for (n_base = 0;n_base < gen_nb_xmlSchemaTypePtr;n_base++) {
! 35326: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
! 35327: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 35328: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
! 35329: mem_base = xmlMemBlocks();
! 35330: base = gen_xmlSchemaTypePtr(n_base, 0);
! 35331: facet = gen_xmlSchemaFacetPtr(n_facet, 1);
! 35332: value = gen_const_xmlChar_ptr(n_value, 2);
! 35333: val = gen_xmlSchemaValPtr(n_val, 3);
! 35334:
! 35335: ret_val = xmlSchemaValidateFacet(base, facet, (const xmlChar *)value, val);
! 35336: desret_int(ret_val);
! 35337: call_tests++;
! 35338: des_xmlSchemaTypePtr(n_base, base, 0);
! 35339: des_xmlSchemaFacetPtr(n_facet, facet, 1);
! 35340: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
! 35341: des_xmlSchemaValPtr(n_val, val, 3);
! 35342: xmlResetLastError();
! 35343: if (mem_base != xmlMemBlocks()) {
! 35344: printf("Leak of %d blocks found in xmlSchemaValidateFacet",
! 35345: xmlMemBlocks() - mem_base);
! 35346: test_ret++;
! 35347: printf(" %d", n_base);
! 35348: printf(" %d", n_facet);
! 35349: printf(" %d", n_value);
! 35350: printf(" %d", n_val);
! 35351: printf("\n");
! 35352: }
! 35353: }
! 35354: }
! 35355: }
! 35356: }
! 35357: function_tests++;
! 35358: #endif
! 35359:
! 35360: return(test_ret);
! 35361: }
! 35362:
! 35363:
! 35364: static int
! 35365: test_xmlSchemaValidateFacetWhtsp(void) {
! 35366: int test_ret = 0;
! 35367:
! 35368: #if defined(LIBXML_SCHEMAS_ENABLED)
! 35369: int mem_base;
! 35370: int ret_val;
! 35371: xmlSchemaFacetPtr facet; /* the facet to check */
! 35372: int n_facet;
! 35373: xmlSchemaWhitespaceValueType fws; /* the whitespace type of the facet's value */
! 35374: int n_fws;
! 35375: xmlSchemaValType valType; /* the built-in type of the value */
! 35376: int n_valType;
! 35377: xmlChar * value; /* the lexical (or normalized for pattern) repr of the value to validate */
! 35378: int n_value;
! 35379: xmlSchemaValPtr val; /* the precomputed value */
! 35380: int n_val;
! 35381: xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */
! 35382: int n_ws;
! 35383:
! 35384: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
! 35385: for (n_fws = 0;n_fws < gen_nb_xmlSchemaWhitespaceValueType;n_fws++) {
! 35386: for (n_valType = 0;n_valType < gen_nb_xmlSchemaValType;n_valType++) {
! 35387: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 35388: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
! 35389: for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) {
! 35390: mem_base = xmlMemBlocks();
! 35391: facet = gen_xmlSchemaFacetPtr(n_facet, 0);
! 35392: fws = gen_xmlSchemaWhitespaceValueType(n_fws, 1);
! 35393: valType = gen_xmlSchemaValType(n_valType, 2);
! 35394: value = gen_const_xmlChar_ptr(n_value, 3);
! 35395: val = gen_xmlSchemaValPtr(n_val, 4);
! 35396: ws = gen_xmlSchemaWhitespaceValueType(n_ws, 5);
! 35397:
! 35398: ret_val = xmlSchemaValidateFacetWhtsp(facet, fws, valType, (const xmlChar *)value, val, ws);
! 35399: desret_int(ret_val);
! 35400: call_tests++;
! 35401: des_xmlSchemaFacetPtr(n_facet, facet, 0);
! 35402: des_xmlSchemaWhitespaceValueType(n_fws, fws, 1);
! 35403: des_xmlSchemaValType(n_valType, valType, 2);
! 35404: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
! 35405: des_xmlSchemaValPtr(n_val, val, 4);
! 35406: des_xmlSchemaWhitespaceValueType(n_ws, ws, 5);
! 35407: xmlResetLastError();
! 35408: if (mem_base != xmlMemBlocks()) {
! 35409: printf("Leak of %d blocks found in xmlSchemaValidateFacetWhtsp",
! 35410: xmlMemBlocks() - mem_base);
! 35411: test_ret++;
! 35412: printf(" %d", n_facet);
! 35413: printf(" %d", n_fws);
! 35414: printf(" %d", n_valType);
! 35415: printf(" %d", n_value);
! 35416: printf(" %d", n_val);
! 35417: printf(" %d", n_ws);
! 35418: printf("\n");
! 35419: }
! 35420: }
! 35421: }
! 35422: }
! 35423: }
! 35424: }
! 35425: }
! 35426: function_tests++;
! 35427: #endif
! 35428:
! 35429: return(test_ret);
! 35430: }
! 35431:
! 35432:
! 35433: static int
! 35434: test_xmlSchemaValidateLengthFacet(void) {
! 35435: int test_ret = 0;
! 35436:
! 35437: #if defined(LIBXML_SCHEMAS_ENABLED)
! 35438: int mem_base;
! 35439: int ret_val;
! 35440: xmlSchemaTypePtr type; /* the built-in type */
! 35441: int n_type;
! 35442: xmlSchemaFacetPtr facet; /* the facet to check */
! 35443: int n_facet;
! 35444: xmlChar * value; /* the lexical repr. of the value to be validated */
! 35445: int n_value;
! 35446: xmlSchemaValPtr val; /* the precomputed value */
! 35447: int n_val;
! 35448: unsigned long * length; /* the actual length of the value */
! 35449: int n_length;
! 35450:
! 35451: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
! 35452: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
! 35453: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 35454: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
! 35455: for (n_length = 0;n_length < gen_nb_unsigned_long_ptr;n_length++) {
! 35456: mem_base = xmlMemBlocks();
! 35457: type = gen_xmlSchemaTypePtr(n_type, 0);
! 35458: facet = gen_xmlSchemaFacetPtr(n_facet, 1);
! 35459: value = gen_const_xmlChar_ptr(n_value, 2);
! 35460: val = gen_xmlSchemaValPtr(n_val, 3);
! 35461: length = gen_unsigned_long_ptr(n_length, 4);
! 35462:
! 35463: ret_val = xmlSchemaValidateLengthFacet(type, facet, (const xmlChar *)value, val, length);
! 35464: desret_int(ret_val);
! 35465: call_tests++;
! 35466: des_xmlSchemaTypePtr(n_type, type, 0);
! 35467: des_xmlSchemaFacetPtr(n_facet, facet, 1);
! 35468: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
! 35469: des_xmlSchemaValPtr(n_val, val, 3);
! 35470: des_unsigned_long_ptr(n_length, length, 4);
! 35471: xmlResetLastError();
! 35472: if (mem_base != xmlMemBlocks()) {
! 35473: printf("Leak of %d blocks found in xmlSchemaValidateLengthFacet",
! 35474: xmlMemBlocks() - mem_base);
! 35475: test_ret++;
! 35476: printf(" %d", n_type);
! 35477: printf(" %d", n_facet);
! 35478: printf(" %d", n_value);
! 35479: printf(" %d", n_val);
! 35480: printf(" %d", n_length);
! 35481: printf("\n");
! 35482: }
! 35483: }
! 35484: }
! 35485: }
! 35486: }
! 35487: }
! 35488: function_tests++;
! 35489: #endif
! 35490:
! 35491: return(test_ret);
! 35492: }
! 35493:
! 35494:
! 35495: static int
! 35496: test_xmlSchemaValidateLengthFacetWhtsp(void) {
! 35497: int test_ret = 0;
! 35498:
! 35499: #if defined(LIBXML_SCHEMAS_ENABLED)
! 35500: int mem_base;
! 35501: int ret_val;
! 35502: xmlSchemaFacetPtr facet; /* the facet to check */
! 35503: int n_facet;
! 35504: xmlSchemaValType valType; /* the built-in type */
! 35505: int n_valType;
! 35506: xmlChar * value; /* the lexical repr. of the value to be validated */
! 35507: int n_value;
! 35508: xmlSchemaValPtr val; /* the precomputed value */
! 35509: int n_val;
! 35510: unsigned long * length; /* the actual length of the value */
! 35511: int n_length;
! 35512: xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */
! 35513: int n_ws;
! 35514:
! 35515: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
! 35516: for (n_valType = 0;n_valType < gen_nb_xmlSchemaValType;n_valType++) {
! 35517: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 35518: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
! 35519: for (n_length = 0;n_length < gen_nb_unsigned_long_ptr;n_length++) {
! 35520: for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) {
! 35521: mem_base = xmlMemBlocks();
! 35522: facet = gen_xmlSchemaFacetPtr(n_facet, 0);
! 35523: valType = gen_xmlSchemaValType(n_valType, 1);
! 35524: value = gen_const_xmlChar_ptr(n_value, 2);
! 35525: val = gen_xmlSchemaValPtr(n_val, 3);
! 35526: length = gen_unsigned_long_ptr(n_length, 4);
! 35527: ws = gen_xmlSchemaWhitespaceValueType(n_ws, 5);
! 35528:
! 35529: ret_val = xmlSchemaValidateLengthFacetWhtsp(facet, valType, (const xmlChar *)value, val, length, ws);
! 35530: desret_int(ret_val);
! 35531: call_tests++;
! 35532: des_xmlSchemaFacetPtr(n_facet, facet, 0);
! 35533: des_xmlSchemaValType(n_valType, valType, 1);
! 35534: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
! 35535: des_xmlSchemaValPtr(n_val, val, 3);
! 35536: des_unsigned_long_ptr(n_length, length, 4);
! 35537: des_xmlSchemaWhitespaceValueType(n_ws, ws, 5);
! 35538: xmlResetLastError();
! 35539: if (mem_base != xmlMemBlocks()) {
! 35540: printf("Leak of %d blocks found in xmlSchemaValidateLengthFacetWhtsp",
! 35541: xmlMemBlocks() - mem_base);
! 35542: test_ret++;
! 35543: printf(" %d", n_facet);
! 35544: printf(" %d", n_valType);
! 35545: printf(" %d", n_value);
! 35546: printf(" %d", n_val);
! 35547: printf(" %d", n_length);
! 35548: printf(" %d", n_ws);
! 35549: printf("\n");
! 35550: }
! 35551: }
! 35552: }
! 35553: }
! 35554: }
! 35555: }
! 35556: }
! 35557: function_tests++;
! 35558: #endif
! 35559:
! 35560: return(test_ret);
! 35561: }
! 35562:
! 35563:
! 35564: static int
! 35565: test_xmlSchemaValidateListSimpleTypeFacet(void) {
! 35566: int test_ret = 0;
! 35567:
! 35568: #if defined(LIBXML_SCHEMAS_ENABLED)
! 35569: int mem_base;
! 35570: int ret_val;
! 35571: xmlSchemaFacetPtr facet; /* the facet to check */
! 35572: int n_facet;
! 35573: xmlChar * value; /* the lexical repr of the value to validate */
! 35574: int n_value;
! 35575: unsigned long actualLen; /* the number of list items */
! 35576: int n_actualLen;
! 35577: unsigned long * expectedLen; /* the resulting expected number of list items */
! 35578: int n_expectedLen;
! 35579:
! 35580: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
! 35581: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 35582: for (n_actualLen = 0;n_actualLen < gen_nb_unsigned_long;n_actualLen++) {
! 35583: for (n_expectedLen = 0;n_expectedLen < gen_nb_unsigned_long_ptr;n_expectedLen++) {
! 35584: mem_base = xmlMemBlocks();
! 35585: facet = gen_xmlSchemaFacetPtr(n_facet, 0);
! 35586: value = gen_const_xmlChar_ptr(n_value, 1);
! 35587: actualLen = gen_unsigned_long(n_actualLen, 2);
! 35588: expectedLen = gen_unsigned_long_ptr(n_expectedLen, 3);
! 35589:
! 35590: ret_val = xmlSchemaValidateListSimpleTypeFacet(facet, (const xmlChar *)value, actualLen, expectedLen);
! 35591: desret_int(ret_val);
! 35592: call_tests++;
! 35593: des_xmlSchemaFacetPtr(n_facet, facet, 0);
! 35594: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
! 35595: des_unsigned_long(n_actualLen, actualLen, 2);
! 35596: des_unsigned_long_ptr(n_expectedLen, expectedLen, 3);
! 35597: xmlResetLastError();
! 35598: if (mem_base != xmlMemBlocks()) {
! 35599: printf("Leak of %d blocks found in xmlSchemaValidateListSimpleTypeFacet",
! 35600: xmlMemBlocks() - mem_base);
! 35601: test_ret++;
! 35602: printf(" %d", n_facet);
! 35603: printf(" %d", n_value);
! 35604: printf(" %d", n_actualLen);
! 35605: printf(" %d", n_expectedLen);
! 35606: printf("\n");
! 35607: }
! 35608: }
! 35609: }
! 35610: }
! 35611: }
! 35612: function_tests++;
! 35613: #endif
! 35614:
! 35615: return(test_ret);
! 35616: }
! 35617:
! 35618:
! 35619: static int
! 35620: test_xmlSchemaValidatePredefinedType(void) {
! 35621: int test_ret = 0;
! 35622:
! 35623: #if defined(LIBXML_SCHEMAS_ENABLED)
! 35624: int mem_base;
! 35625: int ret_val;
! 35626: xmlSchemaTypePtr type; /* the predefined type */
! 35627: int n_type;
! 35628: xmlChar * value; /* the value to check */
! 35629: int n_value;
! 35630: xmlSchemaValPtr * val; /* the return computed value */
! 35631: int n_val;
! 35632:
! 35633: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
! 35634: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 35635: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) {
! 35636: mem_base = xmlMemBlocks();
! 35637: type = gen_xmlSchemaTypePtr(n_type, 0);
! 35638: value = gen_const_xmlChar_ptr(n_value, 1);
! 35639: val = gen_xmlSchemaValPtr_ptr(n_val, 2);
! 35640:
! 35641: ret_val = xmlSchemaValidatePredefinedType(type, (const xmlChar *)value, val);
! 35642: desret_int(ret_val);
! 35643: call_tests++;
! 35644: des_xmlSchemaTypePtr(n_type, type, 0);
! 35645: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
! 35646: des_xmlSchemaValPtr_ptr(n_val, val, 2);
! 35647: xmlResetLastError();
! 35648: if (mem_base != xmlMemBlocks()) {
! 35649: printf("Leak of %d blocks found in xmlSchemaValidatePredefinedType",
! 35650: xmlMemBlocks() - mem_base);
! 35651: test_ret++;
! 35652: printf(" %d", n_type);
! 35653: printf(" %d", n_value);
! 35654: printf(" %d", n_val);
! 35655: printf("\n");
! 35656: }
! 35657: }
! 35658: }
! 35659: }
! 35660: function_tests++;
! 35661: #endif
! 35662:
! 35663: return(test_ret);
! 35664: }
! 35665:
! 35666:
! 35667: static int
! 35668: test_xmlSchemaValueAppend(void) {
! 35669: int test_ret = 0;
! 35670:
! 35671: #if defined(LIBXML_SCHEMAS_ENABLED)
! 35672: int mem_base;
! 35673: int ret_val;
! 35674: xmlSchemaValPtr prev; /* the value */
! 35675: int n_prev;
! 35676: xmlSchemaValPtr cur; /* the value to be appended */
! 35677: int n_cur;
! 35678:
! 35679: for (n_prev = 0;n_prev < gen_nb_xmlSchemaValPtr;n_prev++) {
! 35680: for (n_cur = 0;n_cur < gen_nb_xmlSchemaValPtr;n_cur++) {
! 35681: mem_base = xmlMemBlocks();
! 35682: prev = gen_xmlSchemaValPtr(n_prev, 0);
! 35683: cur = gen_xmlSchemaValPtr(n_cur, 1);
! 35684:
! 35685: ret_val = xmlSchemaValueAppend(prev, cur);
! 35686: desret_int(ret_val);
! 35687: call_tests++;
! 35688: des_xmlSchemaValPtr(n_prev, prev, 0);
! 35689: des_xmlSchemaValPtr(n_cur, cur, 1);
! 35690: xmlResetLastError();
! 35691: if (mem_base != xmlMemBlocks()) {
! 35692: printf("Leak of %d blocks found in xmlSchemaValueAppend",
! 35693: xmlMemBlocks() - mem_base);
! 35694: test_ret++;
! 35695: printf(" %d", n_prev);
! 35696: printf(" %d", n_cur);
! 35697: printf("\n");
! 35698: }
! 35699: }
! 35700: }
! 35701: function_tests++;
! 35702: #endif
! 35703:
! 35704: return(test_ret);
! 35705: }
! 35706:
! 35707:
! 35708: static int
! 35709: test_xmlSchemaValueGetAsBoolean(void) {
! 35710: int test_ret = 0;
! 35711:
! 35712: #if defined(LIBXML_SCHEMAS_ENABLED)
! 35713: int mem_base;
! 35714: int ret_val;
! 35715: xmlSchemaValPtr val; /* the value */
! 35716: int n_val;
! 35717:
! 35718: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
! 35719: mem_base = xmlMemBlocks();
! 35720: val = gen_xmlSchemaValPtr(n_val, 0);
! 35721:
! 35722: ret_val = xmlSchemaValueGetAsBoolean(val);
! 35723: desret_int(ret_val);
! 35724: call_tests++;
! 35725: des_xmlSchemaValPtr(n_val, val, 0);
! 35726: xmlResetLastError();
! 35727: if (mem_base != xmlMemBlocks()) {
! 35728: printf("Leak of %d blocks found in xmlSchemaValueGetAsBoolean",
! 35729: xmlMemBlocks() - mem_base);
! 35730: test_ret++;
! 35731: printf(" %d", n_val);
! 35732: printf("\n");
! 35733: }
! 35734: }
! 35735: function_tests++;
! 35736: #endif
! 35737:
! 35738: return(test_ret);
! 35739: }
! 35740:
! 35741:
! 35742: static int
! 35743: test_xmlSchemaValueGetAsString(void) {
! 35744: int test_ret = 0;
! 35745:
! 35746: #if defined(LIBXML_SCHEMAS_ENABLED)
! 35747: int mem_base;
! 35748: const xmlChar * ret_val;
! 35749: xmlSchemaValPtr val; /* the value */
! 35750: int n_val;
! 35751:
! 35752: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
! 35753: mem_base = xmlMemBlocks();
! 35754: val = gen_xmlSchemaValPtr(n_val, 0);
! 35755:
! 35756: ret_val = xmlSchemaValueGetAsString(val);
! 35757: desret_const_xmlChar_ptr(ret_val);
! 35758: call_tests++;
! 35759: des_xmlSchemaValPtr(n_val, val, 0);
! 35760: xmlResetLastError();
! 35761: if (mem_base != xmlMemBlocks()) {
! 35762: printf("Leak of %d blocks found in xmlSchemaValueGetAsString",
! 35763: xmlMemBlocks() - mem_base);
! 35764: test_ret++;
! 35765: printf(" %d", n_val);
! 35766: printf("\n");
! 35767: }
! 35768: }
! 35769: function_tests++;
! 35770: #endif
! 35771:
! 35772: return(test_ret);
! 35773: }
! 35774:
! 35775:
! 35776: static int
! 35777: test_xmlSchemaValueGetNext(void) {
! 35778: int test_ret = 0;
! 35779:
! 35780:
! 35781: /* missing type support */
! 35782: return(test_ret);
! 35783: }
! 35784:
! 35785:
! 35786: static int
! 35787: test_xmlSchemaWhiteSpaceReplace(void) {
! 35788: int test_ret = 0;
! 35789:
! 35790: #if defined(LIBXML_SCHEMAS_ENABLED)
! 35791: int mem_base;
! 35792: xmlChar * ret_val;
! 35793: xmlChar * value; /* a value */
! 35794: int n_value;
! 35795:
! 35796: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
! 35797: mem_base = xmlMemBlocks();
! 35798: value = gen_const_xmlChar_ptr(n_value, 0);
! 35799:
! 35800: ret_val = xmlSchemaWhiteSpaceReplace((const xmlChar *)value);
! 35801: desret_xmlChar_ptr(ret_val);
! 35802: call_tests++;
! 35803: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
! 35804: xmlResetLastError();
! 35805: if (mem_base != xmlMemBlocks()) {
! 35806: printf("Leak of %d blocks found in xmlSchemaWhiteSpaceReplace",
! 35807: xmlMemBlocks() - mem_base);
! 35808: test_ret++;
! 35809: printf(" %d", n_value);
! 35810: printf("\n");
! 35811: }
! 35812: }
! 35813: function_tests++;
! 35814: #endif
! 35815:
! 35816: return(test_ret);
! 35817: }
! 35818:
! 35819: static int
! 35820: test_xmlschemastypes(void) {
! 35821: int test_ret = 0;
! 35822:
! 35823: if (quiet == 0) printf("Testing xmlschemastypes : 26 of 34 functions ...\n");
! 35824: test_ret += test_xmlSchemaCheckFacet();
! 35825: test_ret += test_xmlSchemaCleanupTypes();
! 35826: test_ret += test_xmlSchemaCollapseString();
! 35827: test_ret += test_xmlSchemaCompareValues();
! 35828: test_ret += test_xmlSchemaCompareValuesWhtsp();
! 35829: test_ret += test_xmlSchemaCopyValue();
! 35830: test_ret += test_xmlSchemaGetBuiltInListSimpleTypeItemType();
! 35831: test_ret += test_xmlSchemaGetBuiltInType();
! 35832: test_ret += test_xmlSchemaGetCanonValue();
! 35833: test_ret += test_xmlSchemaGetCanonValueWhtsp();
! 35834: test_ret += test_xmlSchemaGetFacetValueAsULong();
! 35835: test_ret += test_xmlSchemaGetPredefinedType();
! 35836: test_ret += test_xmlSchemaGetValType();
! 35837: test_ret += test_xmlSchemaInitTypes();
! 35838: test_ret += test_xmlSchemaIsBuiltInTypeFacet();
! 35839: test_ret += test_xmlSchemaNewFacet();
! 35840: test_ret += test_xmlSchemaNewNOTATIONValue();
! 35841: test_ret += test_xmlSchemaNewQNameValue();
! 35842: test_ret += test_xmlSchemaNewStringValue();
! 35843: test_ret += test_xmlSchemaValPredefTypeNode();
! 35844: test_ret += test_xmlSchemaValPredefTypeNodeNoNorm();
! 35845: test_ret += test_xmlSchemaValidateFacet();
! 35846: test_ret += test_xmlSchemaValidateFacetWhtsp();
! 35847: test_ret += test_xmlSchemaValidateLengthFacet();
! 35848: test_ret += test_xmlSchemaValidateLengthFacetWhtsp();
! 35849: test_ret += test_xmlSchemaValidateListSimpleTypeFacet();
! 35850: test_ret += test_xmlSchemaValidatePredefinedType();
! 35851: test_ret += test_xmlSchemaValueAppend();
! 35852: test_ret += test_xmlSchemaValueGetAsBoolean();
! 35853: test_ret += test_xmlSchemaValueGetAsString();
! 35854: test_ret += test_xmlSchemaValueGetNext();
! 35855: test_ret += test_xmlSchemaWhiteSpaceReplace();
! 35856:
! 35857: if (test_ret != 0)
! 35858: printf("Module xmlschemastypes: %d errors\n", test_ret);
! 35859: return(test_ret);
! 35860: }
! 35861:
! 35862: static int
! 35863: test_xmlCharStrdup(void) {
! 35864: int test_ret = 0;
! 35865:
! 35866: int mem_base;
! 35867: xmlChar * ret_val;
! 35868: char * cur; /* the input char * */
! 35869: int n_cur;
! 35870:
! 35871: for (n_cur = 0;n_cur < gen_nb_const_char_ptr;n_cur++) {
! 35872: mem_base = xmlMemBlocks();
! 35873: cur = gen_const_char_ptr(n_cur, 0);
! 35874:
! 35875: ret_val = xmlCharStrdup((const char *)cur);
! 35876: desret_xmlChar_ptr(ret_val);
! 35877: call_tests++;
! 35878: des_const_char_ptr(n_cur, (const char *)cur, 0);
! 35879: xmlResetLastError();
! 35880: if (mem_base != xmlMemBlocks()) {
! 35881: printf("Leak of %d blocks found in xmlCharStrdup",
! 35882: xmlMemBlocks() - mem_base);
! 35883: test_ret++;
! 35884: printf(" %d", n_cur);
! 35885: printf("\n");
! 35886: }
! 35887: }
! 35888: function_tests++;
! 35889:
! 35890: return(test_ret);
! 35891: }
! 35892:
! 35893:
! 35894: static int
! 35895: test_xmlCharStrndup(void) {
! 35896: int test_ret = 0;
! 35897:
! 35898: int mem_base;
! 35899: xmlChar * ret_val;
! 35900: char * cur; /* the input char * */
! 35901: int n_cur;
! 35902: int len; /* the len of @cur */
! 35903: int n_len;
! 35904:
! 35905: for (n_cur = 0;n_cur < gen_nb_const_char_ptr;n_cur++) {
! 35906: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 35907: mem_base = xmlMemBlocks();
! 35908: cur = gen_const_char_ptr(n_cur, 0);
! 35909: len = gen_int(n_len, 1);
! 35910:
! 35911: ret_val = xmlCharStrndup((const char *)cur, len);
! 35912: desret_xmlChar_ptr(ret_val);
! 35913: call_tests++;
! 35914: des_const_char_ptr(n_cur, (const char *)cur, 0);
! 35915: des_int(n_len, len, 1);
! 35916: xmlResetLastError();
! 35917: if (mem_base != xmlMemBlocks()) {
! 35918: printf("Leak of %d blocks found in xmlCharStrndup",
! 35919: xmlMemBlocks() - mem_base);
! 35920: test_ret++;
! 35921: printf(" %d", n_cur);
! 35922: printf(" %d", n_len);
! 35923: printf("\n");
! 35924: }
! 35925: }
! 35926: }
! 35927: function_tests++;
! 35928:
! 35929: return(test_ret);
! 35930: }
! 35931:
! 35932:
! 35933: static int
! 35934: test_xmlCheckUTF8(void) {
! 35935: int test_ret = 0;
! 35936:
! 35937: int mem_base;
! 35938: int ret_val;
! 35939: unsigned char * utf; /* Pointer to putative UTF-8 encoded string. */
! 35940: int n_utf;
! 35941:
! 35942: for (n_utf = 0;n_utf < gen_nb_const_unsigned_char_ptr;n_utf++) {
! 35943: mem_base = xmlMemBlocks();
! 35944: utf = gen_const_unsigned_char_ptr(n_utf, 0);
! 35945:
! 35946: ret_val = xmlCheckUTF8((const unsigned char *)utf);
! 35947: desret_int(ret_val);
! 35948: call_tests++;
! 35949: des_const_unsigned_char_ptr(n_utf, (const unsigned char *)utf, 0);
! 35950: xmlResetLastError();
! 35951: if (mem_base != xmlMemBlocks()) {
! 35952: printf("Leak of %d blocks found in xmlCheckUTF8",
! 35953: xmlMemBlocks() - mem_base);
! 35954: test_ret++;
! 35955: printf(" %d", n_utf);
! 35956: printf("\n");
! 35957: }
! 35958: }
! 35959: function_tests++;
! 35960:
! 35961: return(test_ret);
! 35962: }
! 35963:
! 35964:
! 35965: static int
! 35966: test_xmlGetUTF8Char(void) {
! 35967: int test_ret = 0;
! 35968:
! 35969: int mem_base;
! 35970: int ret_val;
! 35971: unsigned char * utf; /* a sequence of UTF-8 encoded bytes */
! 35972: int n_utf;
! 35973: 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. */
! 35974: int n_len;
! 35975:
! 35976: for (n_utf = 0;n_utf < gen_nb_const_unsigned_char_ptr;n_utf++) {
! 35977: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
! 35978: mem_base = xmlMemBlocks();
! 35979: utf = gen_const_unsigned_char_ptr(n_utf, 0);
! 35980: len = gen_int_ptr(n_len, 1);
! 35981:
! 35982: ret_val = xmlGetUTF8Char((const unsigned char *)utf, len);
! 35983: desret_int(ret_val);
! 35984: call_tests++;
! 35985: des_const_unsigned_char_ptr(n_utf, (const unsigned char *)utf, 0);
! 35986: des_int_ptr(n_len, len, 1);
! 35987: xmlResetLastError();
! 35988: if (mem_base != xmlMemBlocks()) {
! 35989: printf("Leak of %d blocks found in xmlGetUTF8Char",
! 35990: xmlMemBlocks() - mem_base);
! 35991: test_ret++;
! 35992: printf(" %d", n_utf);
! 35993: printf(" %d", n_len);
! 35994: printf("\n");
! 35995: }
! 35996: }
! 35997: }
! 35998: function_tests++;
! 35999:
! 36000: return(test_ret);
! 36001: }
! 36002:
! 36003:
! 36004: static int
! 36005: test_xmlStrEqual(void) {
! 36006: int test_ret = 0;
! 36007:
! 36008: int mem_base;
! 36009: int ret_val;
! 36010: xmlChar * str1; /* the first xmlChar * */
! 36011: int n_str1;
! 36012: xmlChar * str2; /* the second xmlChar * */
! 36013: int n_str2;
! 36014:
! 36015: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
! 36016: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
! 36017: mem_base = xmlMemBlocks();
! 36018: str1 = gen_const_xmlChar_ptr(n_str1, 0);
! 36019: str2 = gen_const_xmlChar_ptr(n_str2, 1);
! 36020:
! 36021: ret_val = xmlStrEqual((const xmlChar *)str1, (const xmlChar *)str2);
! 36022: desret_int(ret_val);
! 36023: call_tests++;
! 36024: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
! 36025: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
! 36026: xmlResetLastError();
! 36027: if (mem_base != xmlMemBlocks()) {
! 36028: printf("Leak of %d blocks found in xmlStrEqual",
! 36029: xmlMemBlocks() - mem_base);
! 36030: test_ret++;
! 36031: printf(" %d", n_str1);
! 36032: printf(" %d", n_str2);
! 36033: printf("\n");
! 36034: }
! 36035: }
! 36036: }
! 36037: function_tests++;
! 36038:
! 36039: return(test_ret);
! 36040: }
! 36041:
! 36042:
! 36043: static int
! 36044: test_xmlStrPrintf(void) {
! 36045: int test_ret = 0;
! 36046:
! 36047:
! 36048: /* missing type support */
! 36049: return(test_ret);
! 36050: }
! 36051:
! 36052:
! 36053: static int
! 36054: test_xmlStrQEqual(void) {
! 36055: int test_ret = 0;
! 36056:
! 36057: int mem_base;
! 36058: int ret_val;
! 36059: xmlChar * pref; /* the prefix of the QName */
! 36060: int n_pref;
! 36061: xmlChar * name; /* the localname of the QName */
! 36062: int n_name;
! 36063: xmlChar * str; /* the second xmlChar * */
! 36064: int n_str;
! 36065:
! 36066: for (n_pref = 0;n_pref < gen_nb_const_xmlChar_ptr;n_pref++) {
! 36067: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 36068: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 36069: mem_base = xmlMemBlocks();
! 36070: pref = gen_const_xmlChar_ptr(n_pref, 0);
! 36071: name = gen_const_xmlChar_ptr(n_name, 1);
! 36072: str = gen_const_xmlChar_ptr(n_str, 2);
! 36073:
! 36074: ret_val = xmlStrQEqual((const xmlChar *)pref, (const xmlChar *)name, (const xmlChar *)str);
! 36075: desret_int(ret_val);
! 36076: call_tests++;
! 36077: des_const_xmlChar_ptr(n_pref, (const xmlChar *)pref, 0);
! 36078: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 36079: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 2);
! 36080: xmlResetLastError();
! 36081: if (mem_base != xmlMemBlocks()) {
! 36082: printf("Leak of %d blocks found in xmlStrQEqual",
! 36083: xmlMemBlocks() - mem_base);
! 36084: test_ret++;
! 36085: printf(" %d", n_pref);
! 36086: printf(" %d", n_name);
! 36087: printf(" %d", n_str);
! 36088: printf("\n");
! 36089: }
! 36090: }
! 36091: }
! 36092: }
! 36093: function_tests++;
! 36094:
! 36095: return(test_ret);
! 36096: }
! 36097:
! 36098:
! 36099: static int
! 36100: test_xmlStrVPrintf(void) {
! 36101: int test_ret = 0;
! 36102:
! 36103:
! 36104: /* missing type support */
! 36105: return(test_ret);
! 36106: }
! 36107:
! 36108:
! 36109: static int
! 36110: test_xmlStrcasecmp(void) {
! 36111: int test_ret = 0;
! 36112:
! 36113: int mem_base;
! 36114: int ret_val;
! 36115: xmlChar * str1; /* the first xmlChar * */
! 36116: int n_str1;
! 36117: xmlChar * str2; /* the second xmlChar * */
! 36118: int n_str2;
! 36119:
! 36120: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
! 36121: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
! 36122: mem_base = xmlMemBlocks();
! 36123: str1 = gen_const_xmlChar_ptr(n_str1, 0);
! 36124: str2 = gen_const_xmlChar_ptr(n_str2, 1);
! 36125:
! 36126: ret_val = xmlStrcasecmp((const xmlChar *)str1, (const xmlChar *)str2);
! 36127: desret_int(ret_val);
! 36128: call_tests++;
! 36129: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
! 36130: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
! 36131: xmlResetLastError();
! 36132: if (mem_base != xmlMemBlocks()) {
! 36133: printf("Leak of %d blocks found in xmlStrcasecmp",
! 36134: xmlMemBlocks() - mem_base);
! 36135: test_ret++;
! 36136: printf(" %d", n_str1);
! 36137: printf(" %d", n_str2);
! 36138: printf("\n");
! 36139: }
! 36140: }
! 36141: }
! 36142: function_tests++;
! 36143:
! 36144: return(test_ret);
! 36145: }
! 36146:
! 36147:
! 36148: static int
! 36149: test_xmlStrcasestr(void) {
! 36150: int test_ret = 0;
! 36151:
! 36152: int mem_base;
! 36153: const xmlChar * ret_val;
! 36154: xmlChar * str; /* the xmlChar * array (haystack) */
! 36155: int n_str;
! 36156: xmlChar * val; /* the xmlChar to search (needle) */
! 36157: int n_val;
! 36158:
! 36159: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 36160: for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
! 36161: mem_base = xmlMemBlocks();
! 36162: str = gen_const_xmlChar_ptr(n_str, 0);
! 36163: val = gen_const_xmlChar_ptr(n_val, 1);
! 36164:
! 36165: ret_val = xmlStrcasestr((const xmlChar *)str, (const xmlChar *)val);
! 36166: desret_const_xmlChar_ptr(ret_val);
! 36167: call_tests++;
! 36168: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
! 36169: des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 1);
! 36170: xmlResetLastError();
! 36171: if (mem_base != xmlMemBlocks()) {
! 36172: printf("Leak of %d blocks found in xmlStrcasestr",
! 36173: xmlMemBlocks() - mem_base);
! 36174: test_ret++;
! 36175: printf(" %d", n_str);
! 36176: printf(" %d", n_val);
! 36177: printf("\n");
! 36178: }
! 36179: }
! 36180: }
! 36181: function_tests++;
! 36182:
! 36183: return(test_ret);
! 36184: }
! 36185:
! 36186:
! 36187: static int
! 36188: test_xmlStrchr(void) {
! 36189: int test_ret = 0;
! 36190:
! 36191: int mem_base;
! 36192: const xmlChar * ret_val;
! 36193: xmlChar * str; /* the xmlChar * array */
! 36194: int n_str;
! 36195: xmlChar val; /* the xmlChar to search */
! 36196: int n_val;
! 36197:
! 36198: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 36199: for (n_val = 0;n_val < gen_nb_xmlChar;n_val++) {
! 36200: mem_base = xmlMemBlocks();
! 36201: str = gen_const_xmlChar_ptr(n_str, 0);
! 36202: val = gen_xmlChar(n_val, 1);
! 36203:
! 36204: ret_val = xmlStrchr((const xmlChar *)str, val);
! 36205: desret_const_xmlChar_ptr(ret_val);
! 36206: call_tests++;
! 36207: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
! 36208: des_xmlChar(n_val, val, 1);
! 36209: xmlResetLastError();
! 36210: if (mem_base != xmlMemBlocks()) {
! 36211: printf("Leak of %d blocks found in xmlStrchr",
! 36212: xmlMemBlocks() - mem_base);
! 36213: test_ret++;
! 36214: printf(" %d", n_str);
! 36215: printf(" %d", n_val);
! 36216: printf("\n");
! 36217: }
! 36218: }
! 36219: }
! 36220: function_tests++;
! 36221:
! 36222: return(test_ret);
! 36223: }
! 36224:
! 36225:
! 36226: static int
! 36227: test_xmlStrcmp(void) {
! 36228: int test_ret = 0;
! 36229:
! 36230: int mem_base;
! 36231: int ret_val;
! 36232: xmlChar * str1; /* the first xmlChar * */
! 36233: int n_str1;
! 36234: xmlChar * str2; /* the second xmlChar * */
! 36235: int n_str2;
! 36236:
! 36237: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
! 36238: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
! 36239: mem_base = xmlMemBlocks();
! 36240: str1 = gen_const_xmlChar_ptr(n_str1, 0);
! 36241: str2 = gen_const_xmlChar_ptr(n_str2, 1);
! 36242:
! 36243: ret_val = xmlStrcmp((const xmlChar *)str1, (const xmlChar *)str2);
! 36244: desret_int(ret_val);
! 36245: call_tests++;
! 36246: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
! 36247: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
! 36248: xmlResetLastError();
! 36249: if (mem_base != xmlMemBlocks()) {
! 36250: printf("Leak of %d blocks found in xmlStrcmp",
! 36251: xmlMemBlocks() - mem_base);
! 36252: test_ret++;
! 36253: printf(" %d", n_str1);
! 36254: printf(" %d", n_str2);
! 36255: printf("\n");
! 36256: }
! 36257: }
! 36258: }
! 36259: function_tests++;
! 36260:
! 36261: return(test_ret);
! 36262: }
! 36263:
! 36264:
! 36265: static int
! 36266: test_xmlStrdup(void) {
! 36267: int test_ret = 0;
! 36268:
! 36269: int mem_base;
! 36270: xmlChar * ret_val;
! 36271: xmlChar * cur; /* the input xmlChar * */
! 36272: int n_cur;
! 36273:
! 36274: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
! 36275: mem_base = xmlMemBlocks();
! 36276: cur = gen_const_xmlChar_ptr(n_cur, 0);
! 36277:
! 36278: ret_val = xmlStrdup((const xmlChar *)cur);
! 36279: desret_xmlChar_ptr(ret_val);
! 36280: call_tests++;
! 36281: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
! 36282: xmlResetLastError();
! 36283: if (mem_base != xmlMemBlocks()) {
! 36284: printf("Leak of %d blocks found in xmlStrdup",
! 36285: xmlMemBlocks() - mem_base);
! 36286: test_ret++;
! 36287: printf(" %d", n_cur);
! 36288: printf("\n");
! 36289: }
! 36290: }
! 36291: function_tests++;
! 36292:
! 36293: return(test_ret);
! 36294: }
! 36295:
! 36296:
! 36297: static int
! 36298: test_xmlStrlen(void) {
! 36299: int test_ret = 0;
! 36300:
! 36301: int mem_base;
! 36302: int ret_val;
! 36303: xmlChar * str; /* the xmlChar * array */
! 36304: int n_str;
! 36305:
! 36306: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 36307: mem_base = xmlMemBlocks();
! 36308: str = gen_const_xmlChar_ptr(n_str, 0);
! 36309:
! 36310: ret_val = xmlStrlen((const xmlChar *)str);
! 36311: desret_int(ret_val);
! 36312: call_tests++;
! 36313: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
! 36314: xmlResetLastError();
! 36315: if (mem_base != xmlMemBlocks()) {
! 36316: printf("Leak of %d blocks found in xmlStrlen",
! 36317: xmlMemBlocks() - mem_base);
! 36318: test_ret++;
! 36319: printf(" %d", n_str);
! 36320: printf("\n");
! 36321: }
! 36322: }
! 36323: function_tests++;
! 36324:
! 36325: return(test_ret);
! 36326: }
! 36327:
! 36328:
! 36329: static int
! 36330: test_xmlStrncasecmp(void) {
! 36331: int test_ret = 0;
! 36332:
! 36333: int mem_base;
! 36334: int ret_val;
! 36335: xmlChar * str1; /* the first xmlChar * */
! 36336: int n_str1;
! 36337: xmlChar * str2; /* the second xmlChar * */
! 36338: int n_str2;
! 36339: int len; /* the max comparison length */
! 36340: int n_len;
! 36341:
! 36342: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
! 36343: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
! 36344: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 36345: mem_base = xmlMemBlocks();
! 36346: str1 = gen_const_xmlChar_ptr(n_str1, 0);
! 36347: str2 = gen_const_xmlChar_ptr(n_str2, 1);
! 36348: len = gen_int(n_len, 2);
! 36349:
! 36350: ret_val = xmlStrncasecmp((const xmlChar *)str1, (const xmlChar *)str2, len);
! 36351: desret_int(ret_val);
! 36352: call_tests++;
! 36353: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
! 36354: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
! 36355: des_int(n_len, len, 2);
! 36356: xmlResetLastError();
! 36357: if (mem_base != xmlMemBlocks()) {
! 36358: printf("Leak of %d blocks found in xmlStrncasecmp",
! 36359: xmlMemBlocks() - mem_base);
! 36360: test_ret++;
! 36361: printf(" %d", n_str1);
! 36362: printf(" %d", n_str2);
! 36363: printf(" %d", n_len);
! 36364: printf("\n");
! 36365: }
! 36366: }
! 36367: }
! 36368: }
! 36369: function_tests++;
! 36370:
! 36371: return(test_ret);
! 36372: }
! 36373:
! 36374:
! 36375: static int
! 36376: test_xmlStrncatNew(void) {
! 36377: int test_ret = 0;
! 36378:
! 36379: int mem_base;
! 36380: xmlChar * ret_val;
! 36381: xmlChar * str1; /* first xmlChar string */
! 36382: int n_str1;
! 36383: xmlChar * str2; /* second xmlChar string */
! 36384: int n_str2;
! 36385: int len; /* the len of @str2 or < 0 */
! 36386: int n_len;
! 36387:
! 36388: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
! 36389: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
! 36390: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 36391: mem_base = xmlMemBlocks();
! 36392: str1 = gen_const_xmlChar_ptr(n_str1, 0);
! 36393: str2 = gen_const_xmlChar_ptr(n_str2, 1);
! 36394: len = gen_int(n_len, 2);
! 36395:
! 36396: ret_val = xmlStrncatNew((const xmlChar *)str1, (const xmlChar *)str2, len);
! 36397: desret_xmlChar_ptr(ret_val);
! 36398: call_tests++;
! 36399: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
! 36400: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
! 36401: des_int(n_len, len, 2);
! 36402: xmlResetLastError();
! 36403: if (mem_base != xmlMemBlocks()) {
! 36404: printf("Leak of %d blocks found in xmlStrncatNew",
! 36405: xmlMemBlocks() - mem_base);
! 36406: test_ret++;
! 36407: printf(" %d", n_str1);
! 36408: printf(" %d", n_str2);
! 36409: printf(" %d", n_len);
! 36410: printf("\n");
! 36411: }
! 36412: }
! 36413: }
! 36414: }
! 36415: function_tests++;
! 36416:
! 36417: return(test_ret);
! 36418: }
! 36419:
! 36420:
! 36421: static int
! 36422: test_xmlStrncmp(void) {
! 36423: int test_ret = 0;
! 36424:
! 36425: int mem_base;
! 36426: int ret_val;
! 36427: xmlChar * str1; /* the first xmlChar * */
! 36428: int n_str1;
! 36429: xmlChar * str2; /* the second xmlChar * */
! 36430: int n_str2;
! 36431: int len; /* the max comparison length */
! 36432: int n_len;
! 36433:
! 36434: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
! 36435: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
! 36436: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 36437: mem_base = xmlMemBlocks();
! 36438: str1 = gen_const_xmlChar_ptr(n_str1, 0);
! 36439: str2 = gen_const_xmlChar_ptr(n_str2, 1);
! 36440: len = gen_int(n_len, 2);
! 36441:
! 36442: ret_val = xmlStrncmp((const xmlChar *)str1, (const xmlChar *)str2, len);
! 36443: desret_int(ret_val);
! 36444: call_tests++;
! 36445: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
! 36446: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
! 36447: des_int(n_len, len, 2);
! 36448: xmlResetLastError();
! 36449: if (mem_base != xmlMemBlocks()) {
! 36450: printf("Leak of %d blocks found in xmlStrncmp",
! 36451: xmlMemBlocks() - mem_base);
! 36452: test_ret++;
! 36453: printf(" %d", n_str1);
! 36454: printf(" %d", n_str2);
! 36455: printf(" %d", n_len);
! 36456: printf("\n");
! 36457: }
! 36458: }
! 36459: }
! 36460: }
! 36461: function_tests++;
! 36462:
! 36463: return(test_ret);
! 36464: }
! 36465:
! 36466:
! 36467: static int
! 36468: test_xmlStrndup(void) {
! 36469: int test_ret = 0;
! 36470:
! 36471: int mem_base;
! 36472: xmlChar * ret_val;
! 36473: xmlChar * cur; /* the input xmlChar * */
! 36474: int n_cur;
! 36475: int len; /* the len of @cur */
! 36476: int n_len;
! 36477:
! 36478: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
! 36479: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 36480: mem_base = xmlMemBlocks();
! 36481: cur = gen_const_xmlChar_ptr(n_cur, 0);
! 36482: len = gen_int(n_len, 1);
! 36483:
! 36484: ret_val = xmlStrndup((const xmlChar *)cur, len);
! 36485: desret_xmlChar_ptr(ret_val);
! 36486: call_tests++;
! 36487: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
! 36488: des_int(n_len, len, 1);
! 36489: xmlResetLastError();
! 36490: if (mem_base != xmlMemBlocks()) {
! 36491: printf("Leak of %d blocks found in xmlStrndup",
! 36492: xmlMemBlocks() - mem_base);
! 36493: test_ret++;
! 36494: printf(" %d", n_cur);
! 36495: printf(" %d", n_len);
! 36496: printf("\n");
! 36497: }
! 36498: }
! 36499: }
! 36500: function_tests++;
! 36501:
! 36502: return(test_ret);
! 36503: }
! 36504:
! 36505:
! 36506: static int
! 36507: test_xmlStrstr(void) {
! 36508: int test_ret = 0;
! 36509:
! 36510: int mem_base;
! 36511: const xmlChar * ret_val;
! 36512: xmlChar * str; /* the xmlChar * array (haystack) */
! 36513: int n_str;
! 36514: xmlChar * val; /* the xmlChar to search (needle) */
! 36515: int n_val;
! 36516:
! 36517: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 36518: for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
! 36519: mem_base = xmlMemBlocks();
! 36520: str = gen_const_xmlChar_ptr(n_str, 0);
! 36521: val = gen_const_xmlChar_ptr(n_val, 1);
! 36522:
! 36523: ret_val = xmlStrstr((const xmlChar *)str, (const xmlChar *)val);
! 36524: desret_const_xmlChar_ptr(ret_val);
! 36525: call_tests++;
! 36526: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
! 36527: des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 1);
! 36528: xmlResetLastError();
! 36529: if (mem_base != xmlMemBlocks()) {
! 36530: printf("Leak of %d blocks found in xmlStrstr",
! 36531: xmlMemBlocks() - mem_base);
! 36532: test_ret++;
! 36533: printf(" %d", n_str);
! 36534: printf(" %d", n_val);
! 36535: printf("\n");
! 36536: }
! 36537: }
! 36538: }
! 36539: function_tests++;
! 36540:
! 36541: return(test_ret);
! 36542: }
! 36543:
! 36544:
! 36545: static int
! 36546: test_xmlStrsub(void) {
! 36547: int test_ret = 0;
! 36548:
! 36549: int mem_base;
! 36550: xmlChar * ret_val;
! 36551: xmlChar * str; /* the xmlChar * array (haystack) */
! 36552: int n_str;
! 36553: int start; /* the index of the first char (zero based) */
! 36554: int n_start;
! 36555: int len; /* the length of the substring */
! 36556: int n_len;
! 36557:
! 36558: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 36559: for (n_start = 0;n_start < gen_nb_int;n_start++) {
! 36560: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 36561: mem_base = xmlMemBlocks();
! 36562: str = gen_const_xmlChar_ptr(n_str, 0);
! 36563: start = gen_int(n_start, 1);
! 36564: len = gen_int(n_len, 2);
! 36565:
! 36566: ret_val = xmlStrsub((const xmlChar *)str, start, len);
! 36567: desret_xmlChar_ptr(ret_val);
! 36568: call_tests++;
! 36569: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
! 36570: des_int(n_start, start, 1);
! 36571: des_int(n_len, len, 2);
! 36572: xmlResetLastError();
! 36573: if (mem_base != xmlMemBlocks()) {
! 36574: printf("Leak of %d blocks found in xmlStrsub",
! 36575: xmlMemBlocks() - mem_base);
! 36576: test_ret++;
! 36577: printf(" %d", n_str);
! 36578: printf(" %d", n_start);
! 36579: printf(" %d", n_len);
! 36580: printf("\n");
! 36581: }
! 36582: }
! 36583: }
! 36584: }
! 36585: function_tests++;
! 36586:
! 36587: return(test_ret);
! 36588: }
! 36589:
! 36590:
! 36591: static int
! 36592: test_xmlUTF8Charcmp(void) {
! 36593: int test_ret = 0;
! 36594:
! 36595: int mem_base;
! 36596: int ret_val;
! 36597: xmlChar * utf1; /* pointer to first UTF8 char */
! 36598: int n_utf1;
! 36599: xmlChar * utf2; /* pointer to second UTF8 char */
! 36600: int n_utf2;
! 36601:
! 36602: for (n_utf1 = 0;n_utf1 < gen_nb_const_xmlChar_ptr;n_utf1++) {
! 36603: for (n_utf2 = 0;n_utf2 < gen_nb_const_xmlChar_ptr;n_utf2++) {
! 36604: mem_base = xmlMemBlocks();
! 36605: utf1 = gen_const_xmlChar_ptr(n_utf1, 0);
! 36606: utf2 = gen_const_xmlChar_ptr(n_utf2, 1);
! 36607:
! 36608: ret_val = xmlUTF8Charcmp((const xmlChar *)utf1, (const xmlChar *)utf2);
! 36609: desret_int(ret_val);
! 36610: call_tests++;
! 36611: des_const_xmlChar_ptr(n_utf1, (const xmlChar *)utf1, 0);
! 36612: des_const_xmlChar_ptr(n_utf2, (const xmlChar *)utf2, 1);
! 36613: xmlResetLastError();
! 36614: if (mem_base != xmlMemBlocks()) {
! 36615: printf("Leak of %d blocks found in xmlUTF8Charcmp",
! 36616: xmlMemBlocks() - mem_base);
! 36617: test_ret++;
! 36618: printf(" %d", n_utf1);
! 36619: printf(" %d", n_utf2);
! 36620: printf("\n");
! 36621: }
! 36622: }
! 36623: }
! 36624: function_tests++;
! 36625:
! 36626: return(test_ret);
! 36627: }
! 36628:
! 36629:
! 36630: static int
! 36631: test_xmlUTF8Size(void) {
! 36632: int test_ret = 0;
! 36633:
! 36634: int mem_base;
! 36635: int ret_val;
! 36636: xmlChar * utf; /* pointer to the UTF8 character */
! 36637: int n_utf;
! 36638:
! 36639: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
! 36640: mem_base = xmlMemBlocks();
! 36641: utf = gen_const_xmlChar_ptr(n_utf, 0);
! 36642:
! 36643: ret_val = xmlUTF8Size((const xmlChar *)utf);
! 36644: desret_int(ret_val);
! 36645: call_tests++;
! 36646: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
! 36647: xmlResetLastError();
! 36648: if (mem_base != xmlMemBlocks()) {
! 36649: printf("Leak of %d blocks found in xmlUTF8Size",
! 36650: xmlMemBlocks() - mem_base);
! 36651: test_ret++;
! 36652: printf(" %d", n_utf);
! 36653: printf("\n");
! 36654: }
! 36655: }
! 36656: function_tests++;
! 36657:
! 36658: return(test_ret);
! 36659: }
! 36660:
! 36661:
! 36662: static int
! 36663: test_xmlUTF8Strlen(void) {
! 36664: int test_ret = 0;
! 36665:
! 36666: int mem_base;
! 36667: int ret_val;
! 36668: xmlChar * utf; /* a sequence of UTF-8 encoded bytes */
! 36669: int n_utf;
! 36670:
! 36671: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
! 36672: mem_base = xmlMemBlocks();
! 36673: utf = gen_const_xmlChar_ptr(n_utf, 0);
! 36674:
! 36675: ret_val = xmlUTF8Strlen((const xmlChar *)utf);
! 36676: desret_int(ret_val);
! 36677: call_tests++;
! 36678: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
! 36679: xmlResetLastError();
! 36680: if (mem_base != xmlMemBlocks()) {
! 36681: printf("Leak of %d blocks found in xmlUTF8Strlen",
! 36682: xmlMemBlocks() - mem_base);
! 36683: test_ret++;
! 36684: printf(" %d", n_utf);
! 36685: printf("\n");
! 36686: }
! 36687: }
! 36688: function_tests++;
! 36689:
! 36690: return(test_ret);
! 36691: }
! 36692:
! 36693:
! 36694: static int
! 36695: test_xmlUTF8Strloc(void) {
! 36696: int test_ret = 0;
! 36697:
! 36698: int mem_base;
! 36699: int ret_val;
! 36700: xmlChar * utf; /* the input UTF8 * */
! 36701: int n_utf;
! 36702: xmlChar * utfchar; /* the UTF8 character to be found */
! 36703: int n_utfchar;
! 36704:
! 36705: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
! 36706: for (n_utfchar = 0;n_utfchar < gen_nb_const_xmlChar_ptr;n_utfchar++) {
! 36707: mem_base = xmlMemBlocks();
! 36708: utf = gen_const_xmlChar_ptr(n_utf, 0);
! 36709: utfchar = gen_const_xmlChar_ptr(n_utfchar, 1);
! 36710:
! 36711: ret_val = xmlUTF8Strloc((const xmlChar *)utf, (const xmlChar *)utfchar);
! 36712: desret_int(ret_val);
! 36713: call_tests++;
! 36714: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
! 36715: des_const_xmlChar_ptr(n_utfchar, (const xmlChar *)utfchar, 1);
! 36716: xmlResetLastError();
! 36717: if (mem_base != xmlMemBlocks()) {
! 36718: printf("Leak of %d blocks found in xmlUTF8Strloc",
! 36719: xmlMemBlocks() - mem_base);
! 36720: test_ret++;
! 36721: printf(" %d", n_utf);
! 36722: printf(" %d", n_utfchar);
! 36723: printf("\n");
! 36724: }
! 36725: }
! 36726: }
! 36727: function_tests++;
! 36728:
! 36729: return(test_ret);
! 36730: }
! 36731:
! 36732:
! 36733: static int
! 36734: test_xmlUTF8Strndup(void) {
! 36735: int test_ret = 0;
! 36736:
! 36737: int mem_base;
! 36738: xmlChar * ret_val;
! 36739: xmlChar * utf; /* the input UTF8 * */
! 36740: int n_utf;
! 36741: int len; /* the len of @utf (in chars) */
! 36742: int n_len;
! 36743:
! 36744: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
! 36745: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 36746: mem_base = xmlMemBlocks();
! 36747: utf = gen_const_xmlChar_ptr(n_utf, 0);
! 36748: len = gen_int(n_len, 1);
! 36749:
! 36750: ret_val = xmlUTF8Strndup((const xmlChar *)utf, len);
! 36751: desret_xmlChar_ptr(ret_val);
! 36752: call_tests++;
! 36753: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
! 36754: des_int(n_len, len, 1);
! 36755: xmlResetLastError();
! 36756: if (mem_base != xmlMemBlocks()) {
! 36757: printf("Leak of %d blocks found in xmlUTF8Strndup",
! 36758: xmlMemBlocks() - mem_base);
! 36759: test_ret++;
! 36760: printf(" %d", n_utf);
! 36761: printf(" %d", n_len);
! 36762: printf("\n");
! 36763: }
! 36764: }
! 36765: }
! 36766: function_tests++;
! 36767:
! 36768: return(test_ret);
! 36769: }
! 36770:
! 36771:
! 36772: static int
! 36773: test_xmlUTF8Strpos(void) {
! 36774: int test_ret = 0;
! 36775:
! 36776: int mem_base;
! 36777: const xmlChar * ret_val;
! 36778: xmlChar * utf; /* the input UTF8 * */
! 36779: int n_utf;
! 36780: int pos; /* the position of the desired UTF8 char (in chars) */
! 36781: int n_pos;
! 36782:
! 36783: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
! 36784: for (n_pos = 0;n_pos < gen_nb_int;n_pos++) {
! 36785: mem_base = xmlMemBlocks();
! 36786: utf = gen_const_xmlChar_ptr(n_utf, 0);
! 36787: pos = gen_int(n_pos, 1);
! 36788:
! 36789: ret_val = xmlUTF8Strpos((const xmlChar *)utf, pos);
! 36790: desret_const_xmlChar_ptr(ret_val);
! 36791: call_tests++;
! 36792: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
! 36793: des_int(n_pos, pos, 1);
! 36794: xmlResetLastError();
! 36795: if (mem_base != xmlMemBlocks()) {
! 36796: printf("Leak of %d blocks found in xmlUTF8Strpos",
! 36797: xmlMemBlocks() - mem_base);
! 36798: test_ret++;
! 36799: printf(" %d", n_utf);
! 36800: printf(" %d", n_pos);
! 36801: printf("\n");
! 36802: }
! 36803: }
! 36804: }
! 36805: function_tests++;
! 36806:
! 36807: return(test_ret);
! 36808: }
! 36809:
! 36810:
! 36811: static int
! 36812: test_xmlUTF8Strsize(void) {
! 36813: int test_ret = 0;
! 36814:
! 36815: int mem_base;
! 36816: int ret_val;
! 36817: xmlChar * utf; /* a sequence of UTF-8 encoded bytes */
! 36818: int n_utf;
! 36819: int len; /* the number of characters in the array */
! 36820: int n_len;
! 36821:
! 36822: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
! 36823: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 36824: mem_base = xmlMemBlocks();
! 36825: utf = gen_const_xmlChar_ptr(n_utf, 0);
! 36826: len = gen_int(n_len, 1);
! 36827:
! 36828: ret_val = xmlUTF8Strsize((const xmlChar *)utf, len);
! 36829: desret_int(ret_val);
! 36830: call_tests++;
! 36831: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
! 36832: des_int(n_len, len, 1);
! 36833: xmlResetLastError();
! 36834: if (mem_base != xmlMemBlocks()) {
! 36835: printf("Leak of %d blocks found in xmlUTF8Strsize",
! 36836: xmlMemBlocks() - mem_base);
! 36837: test_ret++;
! 36838: printf(" %d", n_utf);
! 36839: printf(" %d", n_len);
! 36840: printf("\n");
! 36841: }
! 36842: }
! 36843: }
! 36844: function_tests++;
! 36845:
! 36846: return(test_ret);
! 36847: }
! 36848:
! 36849:
! 36850: static int
! 36851: test_xmlUTF8Strsub(void) {
! 36852: int test_ret = 0;
! 36853:
! 36854: int mem_base;
! 36855: xmlChar * ret_val;
! 36856: xmlChar * utf; /* a sequence of UTF-8 encoded bytes */
! 36857: int n_utf;
! 36858: int start; /* relative pos of first char */
! 36859: int n_start;
! 36860: int len; /* total number to copy */
! 36861: int n_len;
! 36862:
! 36863: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
! 36864: for (n_start = 0;n_start < gen_nb_int;n_start++) {
! 36865: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 36866: mem_base = xmlMemBlocks();
! 36867: utf = gen_const_xmlChar_ptr(n_utf, 0);
! 36868: start = gen_int(n_start, 1);
! 36869: len = gen_int(n_len, 2);
! 36870:
! 36871: ret_val = xmlUTF8Strsub((const xmlChar *)utf, start, len);
! 36872: desret_xmlChar_ptr(ret_val);
! 36873: call_tests++;
! 36874: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
! 36875: des_int(n_start, start, 1);
! 36876: des_int(n_len, len, 2);
! 36877: xmlResetLastError();
! 36878: if (mem_base != xmlMemBlocks()) {
! 36879: printf("Leak of %d blocks found in xmlUTF8Strsub",
! 36880: xmlMemBlocks() - mem_base);
! 36881: test_ret++;
! 36882: printf(" %d", n_utf);
! 36883: printf(" %d", n_start);
! 36884: printf(" %d", n_len);
! 36885: printf("\n");
! 36886: }
! 36887: }
! 36888: }
! 36889: }
! 36890: function_tests++;
! 36891:
! 36892: return(test_ret);
! 36893: }
! 36894:
! 36895: static int
! 36896: test_xmlstring(void) {
! 36897: int test_ret = 0;
! 36898:
! 36899: if (quiet == 0) printf("Testing xmlstring : 26 of 30 functions ...\n");
! 36900: test_ret += test_xmlCharStrdup();
! 36901: test_ret += test_xmlCharStrndup();
! 36902: test_ret += test_xmlCheckUTF8();
! 36903: test_ret += test_xmlGetUTF8Char();
! 36904: test_ret += test_xmlStrEqual();
! 36905: test_ret += test_xmlStrPrintf();
! 36906: test_ret += test_xmlStrQEqual();
! 36907: test_ret += test_xmlStrVPrintf();
! 36908: test_ret += test_xmlStrcasecmp();
! 36909: test_ret += test_xmlStrcasestr();
! 36910: test_ret += test_xmlStrchr();
! 36911: test_ret += test_xmlStrcmp();
! 36912: test_ret += test_xmlStrdup();
! 36913: test_ret += test_xmlStrlen();
! 36914: test_ret += test_xmlStrncasecmp();
! 36915: test_ret += test_xmlStrncatNew();
! 36916: test_ret += test_xmlStrncmp();
! 36917: test_ret += test_xmlStrndup();
! 36918: test_ret += test_xmlStrstr();
! 36919: test_ret += test_xmlStrsub();
! 36920: test_ret += test_xmlUTF8Charcmp();
! 36921: test_ret += test_xmlUTF8Size();
! 36922: test_ret += test_xmlUTF8Strlen();
! 36923: test_ret += test_xmlUTF8Strloc();
! 36924: test_ret += test_xmlUTF8Strndup();
! 36925: test_ret += test_xmlUTF8Strpos();
! 36926: test_ret += test_xmlUTF8Strsize();
! 36927: test_ret += test_xmlUTF8Strsub();
! 36928:
! 36929: if (test_ret != 0)
! 36930: printf("Module xmlstring: %d errors\n", test_ret);
! 36931: return(test_ret);
! 36932: }
! 36933:
! 36934: static int
! 36935: test_xmlUCSIsAegeanNumbers(void) {
! 36936: int test_ret = 0;
! 36937:
! 36938: #if defined(LIBXML_UNICODE_ENABLED)
! 36939: int mem_base;
! 36940: int ret_val;
! 36941: int code; /* UCS code point */
! 36942: int n_code;
! 36943:
! 36944: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 36945: mem_base = xmlMemBlocks();
! 36946: code = gen_int(n_code, 0);
! 36947:
! 36948: ret_val = xmlUCSIsAegeanNumbers(code);
! 36949: desret_int(ret_val);
! 36950: call_tests++;
! 36951: des_int(n_code, code, 0);
! 36952: xmlResetLastError();
! 36953: if (mem_base != xmlMemBlocks()) {
! 36954: printf("Leak of %d blocks found in xmlUCSIsAegeanNumbers",
! 36955: xmlMemBlocks() - mem_base);
! 36956: test_ret++;
! 36957: printf(" %d", n_code);
! 36958: printf("\n");
! 36959: }
! 36960: }
! 36961: function_tests++;
! 36962: #endif
! 36963:
! 36964: return(test_ret);
! 36965: }
! 36966:
! 36967:
! 36968: static int
! 36969: test_xmlUCSIsAlphabeticPresentationForms(void) {
! 36970: int test_ret = 0;
! 36971:
! 36972: #if defined(LIBXML_UNICODE_ENABLED)
! 36973: int mem_base;
! 36974: int ret_val;
! 36975: int code; /* UCS code point */
! 36976: int n_code;
! 36977:
! 36978: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 36979: mem_base = xmlMemBlocks();
! 36980: code = gen_int(n_code, 0);
! 36981:
! 36982: ret_val = xmlUCSIsAlphabeticPresentationForms(code);
! 36983: desret_int(ret_val);
! 36984: call_tests++;
! 36985: des_int(n_code, code, 0);
! 36986: xmlResetLastError();
! 36987: if (mem_base != xmlMemBlocks()) {
! 36988: printf("Leak of %d blocks found in xmlUCSIsAlphabeticPresentationForms",
! 36989: xmlMemBlocks() - mem_base);
! 36990: test_ret++;
! 36991: printf(" %d", n_code);
! 36992: printf("\n");
! 36993: }
! 36994: }
! 36995: function_tests++;
! 36996: #endif
! 36997:
! 36998: return(test_ret);
! 36999: }
! 37000:
! 37001:
! 37002: static int
! 37003: test_xmlUCSIsArabic(void) {
! 37004: int test_ret = 0;
! 37005:
! 37006: #if defined(LIBXML_UNICODE_ENABLED)
! 37007: int mem_base;
! 37008: int ret_val;
! 37009: int code; /* UCS code point */
! 37010: int n_code;
! 37011:
! 37012: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37013: mem_base = xmlMemBlocks();
! 37014: code = gen_int(n_code, 0);
! 37015:
! 37016: ret_val = xmlUCSIsArabic(code);
! 37017: desret_int(ret_val);
! 37018: call_tests++;
! 37019: des_int(n_code, code, 0);
! 37020: xmlResetLastError();
! 37021: if (mem_base != xmlMemBlocks()) {
! 37022: printf("Leak of %d blocks found in xmlUCSIsArabic",
! 37023: xmlMemBlocks() - mem_base);
! 37024: test_ret++;
! 37025: printf(" %d", n_code);
! 37026: printf("\n");
! 37027: }
! 37028: }
! 37029: function_tests++;
! 37030: #endif
! 37031:
! 37032: return(test_ret);
! 37033: }
! 37034:
! 37035:
! 37036: static int
! 37037: test_xmlUCSIsArabicPresentationFormsA(void) {
! 37038: int test_ret = 0;
! 37039:
! 37040: #if defined(LIBXML_UNICODE_ENABLED)
! 37041: int mem_base;
! 37042: int ret_val;
! 37043: int code; /* UCS code point */
! 37044: int n_code;
! 37045:
! 37046: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37047: mem_base = xmlMemBlocks();
! 37048: code = gen_int(n_code, 0);
! 37049:
! 37050: ret_val = xmlUCSIsArabicPresentationFormsA(code);
! 37051: desret_int(ret_val);
! 37052: call_tests++;
! 37053: des_int(n_code, code, 0);
! 37054: xmlResetLastError();
! 37055: if (mem_base != xmlMemBlocks()) {
! 37056: printf("Leak of %d blocks found in xmlUCSIsArabicPresentationFormsA",
! 37057: xmlMemBlocks() - mem_base);
! 37058: test_ret++;
! 37059: printf(" %d", n_code);
! 37060: printf("\n");
! 37061: }
! 37062: }
! 37063: function_tests++;
! 37064: #endif
! 37065:
! 37066: return(test_ret);
! 37067: }
! 37068:
! 37069:
! 37070: static int
! 37071: test_xmlUCSIsArabicPresentationFormsB(void) {
! 37072: int test_ret = 0;
! 37073:
! 37074: #if defined(LIBXML_UNICODE_ENABLED)
! 37075: int mem_base;
! 37076: int ret_val;
! 37077: int code; /* UCS code point */
! 37078: int n_code;
! 37079:
! 37080: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37081: mem_base = xmlMemBlocks();
! 37082: code = gen_int(n_code, 0);
! 37083:
! 37084: ret_val = xmlUCSIsArabicPresentationFormsB(code);
! 37085: desret_int(ret_val);
! 37086: call_tests++;
! 37087: des_int(n_code, code, 0);
! 37088: xmlResetLastError();
! 37089: if (mem_base != xmlMemBlocks()) {
! 37090: printf("Leak of %d blocks found in xmlUCSIsArabicPresentationFormsB",
! 37091: xmlMemBlocks() - mem_base);
! 37092: test_ret++;
! 37093: printf(" %d", n_code);
! 37094: printf("\n");
! 37095: }
! 37096: }
! 37097: function_tests++;
! 37098: #endif
! 37099:
! 37100: return(test_ret);
! 37101: }
! 37102:
! 37103:
! 37104: static int
! 37105: test_xmlUCSIsArmenian(void) {
! 37106: int test_ret = 0;
! 37107:
! 37108: #if defined(LIBXML_UNICODE_ENABLED)
! 37109: int mem_base;
! 37110: int ret_val;
! 37111: int code; /* UCS code point */
! 37112: int n_code;
! 37113:
! 37114: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37115: mem_base = xmlMemBlocks();
! 37116: code = gen_int(n_code, 0);
! 37117:
! 37118: ret_val = xmlUCSIsArmenian(code);
! 37119: desret_int(ret_val);
! 37120: call_tests++;
! 37121: des_int(n_code, code, 0);
! 37122: xmlResetLastError();
! 37123: if (mem_base != xmlMemBlocks()) {
! 37124: printf("Leak of %d blocks found in xmlUCSIsArmenian",
! 37125: xmlMemBlocks() - mem_base);
! 37126: test_ret++;
! 37127: printf(" %d", n_code);
! 37128: printf("\n");
! 37129: }
! 37130: }
! 37131: function_tests++;
! 37132: #endif
! 37133:
! 37134: return(test_ret);
! 37135: }
! 37136:
! 37137:
! 37138: static int
! 37139: test_xmlUCSIsArrows(void) {
! 37140: int test_ret = 0;
! 37141:
! 37142: #if defined(LIBXML_UNICODE_ENABLED)
! 37143: int mem_base;
! 37144: int ret_val;
! 37145: int code; /* UCS code point */
! 37146: int n_code;
! 37147:
! 37148: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37149: mem_base = xmlMemBlocks();
! 37150: code = gen_int(n_code, 0);
! 37151:
! 37152: ret_val = xmlUCSIsArrows(code);
! 37153: desret_int(ret_val);
! 37154: call_tests++;
! 37155: des_int(n_code, code, 0);
! 37156: xmlResetLastError();
! 37157: if (mem_base != xmlMemBlocks()) {
! 37158: printf("Leak of %d blocks found in xmlUCSIsArrows",
! 37159: xmlMemBlocks() - mem_base);
! 37160: test_ret++;
! 37161: printf(" %d", n_code);
! 37162: printf("\n");
! 37163: }
! 37164: }
! 37165: function_tests++;
! 37166: #endif
! 37167:
! 37168: return(test_ret);
! 37169: }
! 37170:
! 37171:
! 37172: static int
! 37173: test_xmlUCSIsBasicLatin(void) {
! 37174: int test_ret = 0;
! 37175:
! 37176: #if defined(LIBXML_UNICODE_ENABLED)
! 37177: int mem_base;
! 37178: int ret_val;
! 37179: int code; /* UCS code point */
! 37180: int n_code;
! 37181:
! 37182: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37183: mem_base = xmlMemBlocks();
! 37184: code = gen_int(n_code, 0);
! 37185:
! 37186: ret_val = xmlUCSIsBasicLatin(code);
! 37187: desret_int(ret_val);
! 37188: call_tests++;
! 37189: des_int(n_code, code, 0);
! 37190: xmlResetLastError();
! 37191: if (mem_base != xmlMemBlocks()) {
! 37192: printf("Leak of %d blocks found in xmlUCSIsBasicLatin",
! 37193: xmlMemBlocks() - mem_base);
! 37194: test_ret++;
! 37195: printf(" %d", n_code);
! 37196: printf("\n");
! 37197: }
! 37198: }
! 37199: function_tests++;
! 37200: #endif
! 37201:
! 37202: return(test_ret);
! 37203: }
! 37204:
! 37205:
! 37206: static int
! 37207: test_xmlUCSIsBengali(void) {
! 37208: int test_ret = 0;
! 37209:
! 37210: #if defined(LIBXML_UNICODE_ENABLED)
! 37211: int mem_base;
! 37212: int ret_val;
! 37213: int code; /* UCS code point */
! 37214: int n_code;
! 37215:
! 37216: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37217: mem_base = xmlMemBlocks();
! 37218: code = gen_int(n_code, 0);
! 37219:
! 37220: ret_val = xmlUCSIsBengali(code);
! 37221: desret_int(ret_val);
! 37222: call_tests++;
! 37223: des_int(n_code, code, 0);
! 37224: xmlResetLastError();
! 37225: if (mem_base != xmlMemBlocks()) {
! 37226: printf("Leak of %d blocks found in xmlUCSIsBengali",
! 37227: xmlMemBlocks() - mem_base);
! 37228: test_ret++;
! 37229: printf(" %d", n_code);
! 37230: printf("\n");
! 37231: }
! 37232: }
! 37233: function_tests++;
! 37234: #endif
! 37235:
! 37236: return(test_ret);
! 37237: }
! 37238:
! 37239:
! 37240: static int
! 37241: test_xmlUCSIsBlock(void) {
! 37242: int test_ret = 0;
! 37243:
! 37244: #if defined(LIBXML_UNICODE_ENABLED)
! 37245: int mem_base;
! 37246: int ret_val;
! 37247: int code; /* UCS code point */
! 37248: int n_code;
! 37249: char * block; /* UCS block name */
! 37250: int n_block;
! 37251:
! 37252: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37253: for (n_block = 0;n_block < gen_nb_const_char_ptr;n_block++) {
! 37254: mem_base = xmlMemBlocks();
! 37255: code = gen_int(n_code, 0);
! 37256: block = gen_const_char_ptr(n_block, 1);
! 37257:
! 37258: ret_val = xmlUCSIsBlock(code, (const char *)block);
! 37259: desret_int(ret_val);
! 37260: call_tests++;
! 37261: des_int(n_code, code, 0);
! 37262: des_const_char_ptr(n_block, (const char *)block, 1);
! 37263: xmlResetLastError();
! 37264: if (mem_base != xmlMemBlocks()) {
! 37265: printf("Leak of %d blocks found in xmlUCSIsBlock",
! 37266: xmlMemBlocks() - mem_base);
! 37267: test_ret++;
! 37268: printf(" %d", n_code);
! 37269: printf(" %d", n_block);
! 37270: printf("\n");
! 37271: }
! 37272: }
! 37273: }
! 37274: function_tests++;
! 37275: #endif
! 37276:
! 37277: return(test_ret);
! 37278: }
! 37279:
! 37280:
! 37281: static int
! 37282: test_xmlUCSIsBlockElements(void) {
! 37283: int test_ret = 0;
! 37284:
! 37285: #if defined(LIBXML_UNICODE_ENABLED)
! 37286: int mem_base;
! 37287: int ret_val;
! 37288: int code; /* UCS code point */
! 37289: int n_code;
! 37290:
! 37291: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37292: mem_base = xmlMemBlocks();
! 37293: code = gen_int(n_code, 0);
! 37294:
! 37295: ret_val = xmlUCSIsBlockElements(code);
! 37296: desret_int(ret_val);
! 37297: call_tests++;
! 37298: des_int(n_code, code, 0);
! 37299: xmlResetLastError();
! 37300: if (mem_base != xmlMemBlocks()) {
! 37301: printf("Leak of %d blocks found in xmlUCSIsBlockElements",
! 37302: xmlMemBlocks() - mem_base);
! 37303: test_ret++;
! 37304: printf(" %d", n_code);
! 37305: printf("\n");
! 37306: }
! 37307: }
! 37308: function_tests++;
! 37309: #endif
! 37310:
! 37311: return(test_ret);
! 37312: }
! 37313:
! 37314:
! 37315: static int
! 37316: test_xmlUCSIsBopomofo(void) {
! 37317: int test_ret = 0;
! 37318:
! 37319: #if defined(LIBXML_UNICODE_ENABLED)
! 37320: int mem_base;
! 37321: int ret_val;
! 37322: int code; /* UCS code point */
! 37323: int n_code;
! 37324:
! 37325: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37326: mem_base = xmlMemBlocks();
! 37327: code = gen_int(n_code, 0);
! 37328:
! 37329: ret_val = xmlUCSIsBopomofo(code);
! 37330: desret_int(ret_val);
! 37331: call_tests++;
! 37332: des_int(n_code, code, 0);
! 37333: xmlResetLastError();
! 37334: if (mem_base != xmlMemBlocks()) {
! 37335: printf("Leak of %d blocks found in xmlUCSIsBopomofo",
! 37336: xmlMemBlocks() - mem_base);
! 37337: test_ret++;
! 37338: printf(" %d", n_code);
! 37339: printf("\n");
! 37340: }
! 37341: }
! 37342: function_tests++;
! 37343: #endif
! 37344:
! 37345: return(test_ret);
! 37346: }
! 37347:
! 37348:
! 37349: static int
! 37350: test_xmlUCSIsBopomofoExtended(void) {
! 37351: int test_ret = 0;
! 37352:
! 37353: #if defined(LIBXML_UNICODE_ENABLED)
! 37354: int mem_base;
! 37355: int ret_val;
! 37356: int code; /* UCS code point */
! 37357: int n_code;
! 37358:
! 37359: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37360: mem_base = xmlMemBlocks();
! 37361: code = gen_int(n_code, 0);
! 37362:
! 37363: ret_val = xmlUCSIsBopomofoExtended(code);
! 37364: desret_int(ret_val);
! 37365: call_tests++;
! 37366: des_int(n_code, code, 0);
! 37367: xmlResetLastError();
! 37368: if (mem_base != xmlMemBlocks()) {
! 37369: printf("Leak of %d blocks found in xmlUCSIsBopomofoExtended",
! 37370: xmlMemBlocks() - mem_base);
! 37371: test_ret++;
! 37372: printf(" %d", n_code);
! 37373: printf("\n");
! 37374: }
! 37375: }
! 37376: function_tests++;
! 37377: #endif
! 37378:
! 37379: return(test_ret);
! 37380: }
! 37381:
! 37382:
! 37383: static int
! 37384: test_xmlUCSIsBoxDrawing(void) {
! 37385: int test_ret = 0;
! 37386:
! 37387: #if defined(LIBXML_UNICODE_ENABLED)
! 37388: int mem_base;
! 37389: int ret_val;
! 37390: int code; /* UCS code point */
! 37391: int n_code;
! 37392:
! 37393: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37394: mem_base = xmlMemBlocks();
! 37395: code = gen_int(n_code, 0);
! 37396:
! 37397: ret_val = xmlUCSIsBoxDrawing(code);
! 37398: desret_int(ret_val);
! 37399: call_tests++;
! 37400: des_int(n_code, code, 0);
! 37401: xmlResetLastError();
! 37402: if (mem_base != xmlMemBlocks()) {
! 37403: printf("Leak of %d blocks found in xmlUCSIsBoxDrawing",
! 37404: xmlMemBlocks() - mem_base);
! 37405: test_ret++;
! 37406: printf(" %d", n_code);
! 37407: printf("\n");
! 37408: }
! 37409: }
! 37410: function_tests++;
! 37411: #endif
! 37412:
! 37413: return(test_ret);
! 37414: }
! 37415:
! 37416:
! 37417: static int
! 37418: test_xmlUCSIsBraillePatterns(void) {
! 37419: int test_ret = 0;
! 37420:
! 37421: #if defined(LIBXML_UNICODE_ENABLED)
! 37422: int mem_base;
! 37423: int ret_val;
! 37424: int code; /* UCS code point */
! 37425: int n_code;
! 37426:
! 37427: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37428: mem_base = xmlMemBlocks();
! 37429: code = gen_int(n_code, 0);
! 37430:
! 37431: ret_val = xmlUCSIsBraillePatterns(code);
! 37432: desret_int(ret_val);
! 37433: call_tests++;
! 37434: des_int(n_code, code, 0);
! 37435: xmlResetLastError();
! 37436: if (mem_base != xmlMemBlocks()) {
! 37437: printf("Leak of %d blocks found in xmlUCSIsBraillePatterns",
! 37438: xmlMemBlocks() - mem_base);
! 37439: test_ret++;
! 37440: printf(" %d", n_code);
! 37441: printf("\n");
! 37442: }
! 37443: }
! 37444: function_tests++;
! 37445: #endif
! 37446:
! 37447: return(test_ret);
! 37448: }
! 37449:
! 37450:
! 37451: static int
! 37452: test_xmlUCSIsBuhid(void) {
! 37453: int test_ret = 0;
! 37454:
! 37455: #if defined(LIBXML_UNICODE_ENABLED)
! 37456: int mem_base;
! 37457: int ret_val;
! 37458: int code; /* UCS code point */
! 37459: int n_code;
! 37460:
! 37461: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37462: mem_base = xmlMemBlocks();
! 37463: code = gen_int(n_code, 0);
! 37464:
! 37465: ret_val = xmlUCSIsBuhid(code);
! 37466: desret_int(ret_val);
! 37467: call_tests++;
! 37468: des_int(n_code, code, 0);
! 37469: xmlResetLastError();
! 37470: if (mem_base != xmlMemBlocks()) {
! 37471: printf("Leak of %d blocks found in xmlUCSIsBuhid",
! 37472: xmlMemBlocks() - mem_base);
! 37473: test_ret++;
! 37474: printf(" %d", n_code);
! 37475: printf("\n");
! 37476: }
! 37477: }
! 37478: function_tests++;
! 37479: #endif
! 37480:
! 37481: return(test_ret);
! 37482: }
! 37483:
! 37484:
! 37485: static int
! 37486: test_xmlUCSIsByzantineMusicalSymbols(void) {
! 37487: int test_ret = 0;
! 37488:
! 37489: #if defined(LIBXML_UNICODE_ENABLED)
! 37490: int mem_base;
! 37491: int ret_val;
! 37492: int code; /* UCS code point */
! 37493: int n_code;
! 37494:
! 37495: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37496: mem_base = xmlMemBlocks();
! 37497: code = gen_int(n_code, 0);
! 37498:
! 37499: ret_val = xmlUCSIsByzantineMusicalSymbols(code);
! 37500: desret_int(ret_val);
! 37501: call_tests++;
! 37502: des_int(n_code, code, 0);
! 37503: xmlResetLastError();
! 37504: if (mem_base != xmlMemBlocks()) {
! 37505: printf("Leak of %d blocks found in xmlUCSIsByzantineMusicalSymbols",
! 37506: xmlMemBlocks() - mem_base);
! 37507: test_ret++;
! 37508: printf(" %d", n_code);
! 37509: printf("\n");
! 37510: }
! 37511: }
! 37512: function_tests++;
! 37513: #endif
! 37514:
! 37515: return(test_ret);
! 37516: }
! 37517:
! 37518:
! 37519: static int
! 37520: test_xmlUCSIsCJKCompatibility(void) {
! 37521: int test_ret = 0;
! 37522:
! 37523: #if defined(LIBXML_UNICODE_ENABLED)
! 37524: int mem_base;
! 37525: int ret_val;
! 37526: int code; /* UCS code point */
! 37527: int n_code;
! 37528:
! 37529: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37530: mem_base = xmlMemBlocks();
! 37531: code = gen_int(n_code, 0);
! 37532:
! 37533: ret_val = xmlUCSIsCJKCompatibility(code);
! 37534: desret_int(ret_val);
! 37535: call_tests++;
! 37536: des_int(n_code, code, 0);
! 37537: xmlResetLastError();
! 37538: if (mem_base != xmlMemBlocks()) {
! 37539: printf("Leak of %d blocks found in xmlUCSIsCJKCompatibility",
! 37540: xmlMemBlocks() - mem_base);
! 37541: test_ret++;
! 37542: printf(" %d", n_code);
! 37543: printf("\n");
! 37544: }
! 37545: }
! 37546: function_tests++;
! 37547: #endif
! 37548:
! 37549: return(test_ret);
! 37550: }
! 37551:
! 37552:
! 37553: static int
! 37554: test_xmlUCSIsCJKCompatibilityForms(void) {
! 37555: int test_ret = 0;
! 37556:
! 37557: #if defined(LIBXML_UNICODE_ENABLED)
! 37558: int mem_base;
! 37559: int ret_val;
! 37560: int code; /* UCS code point */
! 37561: int n_code;
! 37562:
! 37563: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37564: mem_base = xmlMemBlocks();
! 37565: code = gen_int(n_code, 0);
! 37566:
! 37567: ret_val = xmlUCSIsCJKCompatibilityForms(code);
! 37568: desret_int(ret_val);
! 37569: call_tests++;
! 37570: des_int(n_code, code, 0);
! 37571: xmlResetLastError();
! 37572: if (mem_base != xmlMemBlocks()) {
! 37573: printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityForms",
! 37574: xmlMemBlocks() - mem_base);
! 37575: test_ret++;
! 37576: printf(" %d", n_code);
! 37577: printf("\n");
! 37578: }
! 37579: }
! 37580: function_tests++;
! 37581: #endif
! 37582:
! 37583: return(test_ret);
! 37584: }
! 37585:
! 37586:
! 37587: static int
! 37588: test_xmlUCSIsCJKCompatibilityIdeographs(void) {
! 37589: int test_ret = 0;
! 37590:
! 37591: #if defined(LIBXML_UNICODE_ENABLED)
! 37592: int mem_base;
! 37593: int ret_val;
! 37594: int code; /* UCS code point */
! 37595: int n_code;
! 37596:
! 37597: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37598: mem_base = xmlMemBlocks();
! 37599: code = gen_int(n_code, 0);
! 37600:
! 37601: ret_val = xmlUCSIsCJKCompatibilityIdeographs(code);
! 37602: desret_int(ret_val);
! 37603: call_tests++;
! 37604: des_int(n_code, code, 0);
! 37605: xmlResetLastError();
! 37606: if (mem_base != xmlMemBlocks()) {
! 37607: printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityIdeographs",
! 37608: xmlMemBlocks() - mem_base);
! 37609: test_ret++;
! 37610: printf(" %d", n_code);
! 37611: printf("\n");
! 37612: }
! 37613: }
! 37614: function_tests++;
! 37615: #endif
! 37616:
! 37617: return(test_ret);
! 37618: }
! 37619:
! 37620:
! 37621: static int
! 37622: test_xmlUCSIsCJKCompatibilityIdeographsSupplement(void) {
! 37623: int test_ret = 0;
! 37624:
! 37625: #if defined(LIBXML_UNICODE_ENABLED)
! 37626: int mem_base;
! 37627: int ret_val;
! 37628: int code; /* UCS code point */
! 37629: int n_code;
! 37630:
! 37631: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37632: mem_base = xmlMemBlocks();
! 37633: code = gen_int(n_code, 0);
! 37634:
! 37635: ret_val = xmlUCSIsCJKCompatibilityIdeographsSupplement(code);
! 37636: desret_int(ret_val);
! 37637: call_tests++;
! 37638: des_int(n_code, code, 0);
! 37639: xmlResetLastError();
! 37640: if (mem_base != xmlMemBlocks()) {
! 37641: printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityIdeographsSupplement",
! 37642: xmlMemBlocks() - mem_base);
! 37643: test_ret++;
! 37644: printf(" %d", n_code);
! 37645: printf("\n");
! 37646: }
! 37647: }
! 37648: function_tests++;
! 37649: #endif
! 37650:
! 37651: return(test_ret);
! 37652: }
! 37653:
! 37654:
! 37655: static int
! 37656: test_xmlUCSIsCJKRadicalsSupplement(void) {
! 37657: int test_ret = 0;
! 37658:
! 37659: #if defined(LIBXML_UNICODE_ENABLED)
! 37660: int mem_base;
! 37661: int ret_val;
! 37662: int code; /* UCS code point */
! 37663: int n_code;
! 37664:
! 37665: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37666: mem_base = xmlMemBlocks();
! 37667: code = gen_int(n_code, 0);
! 37668:
! 37669: ret_val = xmlUCSIsCJKRadicalsSupplement(code);
! 37670: desret_int(ret_val);
! 37671: call_tests++;
! 37672: des_int(n_code, code, 0);
! 37673: xmlResetLastError();
! 37674: if (mem_base != xmlMemBlocks()) {
! 37675: printf("Leak of %d blocks found in xmlUCSIsCJKRadicalsSupplement",
! 37676: xmlMemBlocks() - mem_base);
! 37677: test_ret++;
! 37678: printf(" %d", n_code);
! 37679: printf("\n");
! 37680: }
! 37681: }
! 37682: function_tests++;
! 37683: #endif
! 37684:
! 37685: return(test_ret);
! 37686: }
! 37687:
! 37688:
! 37689: static int
! 37690: test_xmlUCSIsCJKSymbolsandPunctuation(void) {
! 37691: int test_ret = 0;
! 37692:
! 37693: #if defined(LIBXML_UNICODE_ENABLED)
! 37694: int mem_base;
! 37695: int ret_val;
! 37696: int code; /* UCS code point */
! 37697: int n_code;
! 37698:
! 37699: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37700: mem_base = xmlMemBlocks();
! 37701: code = gen_int(n_code, 0);
! 37702:
! 37703: ret_val = xmlUCSIsCJKSymbolsandPunctuation(code);
! 37704: desret_int(ret_val);
! 37705: call_tests++;
! 37706: des_int(n_code, code, 0);
! 37707: xmlResetLastError();
! 37708: if (mem_base != xmlMemBlocks()) {
! 37709: printf("Leak of %d blocks found in xmlUCSIsCJKSymbolsandPunctuation",
! 37710: xmlMemBlocks() - mem_base);
! 37711: test_ret++;
! 37712: printf(" %d", n_code);
! 37713: printf("\n");
! 37714: }
! 37715: }
! 37716: function_tests++;
! 37717: #endif
! 37718:
! 37719: return(test_ret);
! 37720: }
! 37721:
! 37722:
! 37723: static int
! 37724: test_xmlUCSIsCJKUnifiedIdeographs(void) {
! 37725: int test_ret = 0;
! 37726:
! 37727: #if defined(LIBXML_UNICODE_ENABLED)
! 37728: int mem_base;
! 37729: int ret_val;
! 37730: int code; /* UCS code point */
! 37731: int n_code;
! 37732:
! 37733: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37734: mem_base = xmlMemBlocks();
! 37735: code = gen_int(n_code, 0);
! 37736:
! 37737: ret_val = xmlUCSIsCJKUnifiedIdeographs(code);
! 37738: desret_int(ret_val);
! 37739: call_tests++;
! 37740: des_int(n_code, code, 0);
! 37741: xmlResetLastError();
! 37742: if (mem_base != xmlMemBlocks()) {
! 37743: printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographs",
! 37744: xmlMemBlocks() - mem_base);
! 37745: test_ret++;
! 37746: printf(" %d", n_code);
! 37747: printf("\n");
! 37748: }
! 37749: }
! 37750: function_tests++;
! 37751: #endif
! 37752:
! 37753: return(test_ret);
! 37754: }
! 37755:
! 37756:
! 37757: static int
! 37758: test_xmlUCSIsCJKUnifiedIdeographsExtensionA(void) {
! 37759: int test_ret = 0;
! 37760:
! 37761: #if defined(LIBXML_UNICODE_ENABLED)
! 37762: int mem_base;
! 37763: int ret_val;
! 37764: int code; /* UCS code point */
! 37765: int n_code;
! 37766:
! 37767: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37768: mem_base = xmlMemBlocks();
! 37769: code = gen_int(n_code, 0);
! 37770:
! 37771: ret_val = xmlUCSIsCJKUnifiedIdeographsExtensionA(code);
! 37772: desret_int(ret_val);
! 37773: call_tests++;
! 37774: des_int(n_code, code, 0);
! 37775: xmlResetLastError();
! 37776: if (mem_base != xmlMemBlocks()) {
! 37777: printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographsExtensionA",
! 37778: xmlMemBlocks() - mem_base);
! 37779: test_ret++;
! 37780: printf(" %d", n_code);
! 37781: printf("\n");
! 37782: }
! 37783: }
! 37784: function_tests++;
! 37785: #endif
! 37786:
! 37787: return(test_ret);
! 37788: }
! 37789:
! 37790:
! 37791: static int
! 37792: test_xmlUCSIsCJKUnifiedIdeographsExtensionB(void) {
! 37793: int test_ret = 0;
! 37794:
! 37795: #if defined(LIBXML_UNICODE_ENABLED)
! 37796: int mem_base;
! 37797: int ret_val;
! 37798: int code; /* UCS code point */
! 37799: int n_code;
! 37800:
! 37801: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37802: mem_base = xmlMemBlocks();
! 37803: code = gen_int(n_code, 0);
! 37804:
! 37805: ret_val = xmlUCSIsCJKUnifiedIdeographsExtensionB(code);
! 37806: desret_int(ret_val);
! 37807: call_tests++;
! 37808: des_int(n_code, code, 0);
! 37809: xmlResetLastError();
! 37810: if (mem_base != xmlMemBlocks()) {
! 37811: printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographsExtensionB",
! 37812: xmlMemBlocks() - mem_base);
! 37813: test_ret++;
! 37814: printf(" %d", n_code);
! 37815: printf("\n");
! 37816: }
! 37817: }
! 37818: function_tests++;
! 37819: #endif
! 37820:
! 37821: return(test_ret);
! 37822: }
! 37823:
! 37824:
! 37825: static int
! 37826: test_xmlUCSIsCat(void) {
! 37827: int test_ret = 0;
! 37828:
! 37829: #if defined(LIBXML_UNICODE_ENABLED)
! 37830: int mem_base;
! 37831: int ret_val;
! 37832: int code; /* UCS code point */
! 37833: int n_code;
! 37834: char * cat; /* UCS Category name */
! 37835: int n_cat;
! 37836:
! 37837: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37838: for (n_cat = 0;n_cat < gen_nb_const_char_ptr;n_cat++) {
! 37839: mem_base = xmlMemBlocks();
! 37840: code = gen_int(n_code, 0);
! 37841: cat = gen_const_char_ptr(n_cat, 1);
! 37842:
! 37843: ret_val = xmlUCSIsCat(code, (const char *)cat);
! 37844: desret_int(ret_val);
! 37845: call_tests++;
! 37846: des_int(n_code, code, 0);
! 37847: des_const_char_ptr(n_cat, (const char *)cat, 1);
! 37848: xmlResetLastError();
! 37849: if (mem_base != xmlMemBlocks()) {
! 37850: printf("Leak of %d blocks found in xmlUCSIsCat",
! 37851: xmlMemBlocks() - mem_base);
! 37852: test_ret++;
! 37853: printf(" %d", n_code);
! 37854: printf(" %d", n_cat);
! 37855: printf("\n");
! 37856: }
! 37857: }
! 37858: }
! 37859: function_tests++;
! 37860: #endif
! 37861:
! 37862: return(test_ret);
! 37863: }
! 37864:
! 37865:
! 37866: static int
! 37867: test_xmlUCSIsCatC(void) {
! 37868: int test_ret = 0;
! 37869:
! 37870: #if defined(LIBXML_UNICODE_ENABLED)
! 37871: int mem_base;
! 37872: int ret_val;
! 37873: int code; /* UCS code point */
! 37874: int n_code;
! 37875:
! 37876: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37877: mem_base = xmlMemBlocks();
! 37878: code = gen_int(n_code, 0);
! 37879:
! 37880: ret_val = xmlUCSIsCatC(code);
! 37881: desret_int(ret_val);
! 37882: call_tests++;
! 37883: des_int(n_code, code, 0);
! 37884: xmlResetLastError();
! 37885: if (mem_base != xmlMemBlocks()) {
! 37886: printf("Leak of %d blocks found in xmlUCSIsCatC",
! 37887: xmlMemBlocks() - mem_base);
! 37888: test_ret++;
! 37889: printf(" %d", n_code);
! 37890: printf("\n");
! 37891: }
! 37892: }
! 37893: function_tests++;
! 37894: #endif
! 37895:
! 37896: return(test_ret);
! 37897: }
! 37898:
! 37899:
! 37900: static int
! 37901: test_xmlUCSIsCatCc(void) {
! 37902: int test_ret = 0;
! 37903:
! 37904: #if defined(LIBXML_UNICODE_ENABLED)
! 37905: int mem_base;
! 37906: int ret_val;
! 37907: int code; /* UCS code point */
! 37908: int n_code;
! 37909:
! 37910: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37911: mem_base = xmlMemBlocks();
! 37912: code = gen_int(n_code, 0);
! 37913:
! 37914: ret_val = xmlUCSIsCatCc(code);
! 37915: desret_int(ret_val);
! 37916: call_tests++;
! 37917: des_int(n_code, code, 0);
! 37918: xmlResetLastError();
! 37919: if (mem_base != xmlMemBlocks()) {
! 37920: printf("Leak of %d blocks found in xmlUCSIsCatCc",
! 37921: xmlMemBlocks() - mem_base);
! 37922: test_ret++;
! 37923: printf(" %d", n_code);
! 37924: printf("\n");
! 37925: }
! 37926: }
! 37927: function_tests++;
! 37928: #endif
! 37929:
! 37930: return(test_ret);
! 37931: }
! 37932:
! 37933:
! 37934: static int
! 37935: test_xmlUCSIsCatCf(void) {
! 37936: int test_ret = 0;
! 37937:
! 37938: #if defined(LIBXML_UNICODE_ENABLED)
! 37939: int mem_base;
! 37940: int ret_val;
! 37941: int code; /* UCS code point */
! 37942: int n_code;
! 37943:
! 37944: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37945: mem_base = xmlMemBlocks();
! 37946: code = gen_int(n_code, 0);
! 37947:
! 37948: ret_val = xmlUCSIsCatCf(code);
! 37949: desret_int(ret_val);
! 37950: call_tests++;
! 37951: des_int(n_code, code, 0);
! 37952: xmlResetLastError();
! 37953: if (mem_base != xmlMemBlocks()) {
! 37954: printf("Leak of %d blocks found in xmlUCSIsCatCf",
! 37955: xmlMemBlocks() - mem_base);
! 37956: test_ret++;
! 37957: printf(" %d", n_code);
! 37958: printf("\n");
! 37959: }
! 37960: }
! 37961: function_tests++;
! 37962: #endif
! 37963:
! 37964: return(test_ret);
! 37965: }
! 37966:
! 37967:
! 37968: static int
! 37969: test_xmlUCSIsCatCo(void) {
! 37970: int test_ret = 0;
! 37971:
! 37972: #if defined(LIBXML_UNICODE_ENABLED)
! 37973: int mem_base;
! 37974: int ret_val;
! 37975: int code; /* UCS code point */
! 37976: int n_code;
! 37977:
! 37978: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 37979: mem_base = xmlMemBlocks();
! 37980: code = gen_int(n_code, 0);
! 37981:
! 37982: ret_val = xmlUCSIsCatCo(code);
! 37983: desret_int(ret_val);
! 37984: call_tests++;
! 37985: des_int(n_code, code, 0);
! 37986: xmlResetLastError();
! 37987: if (mem_base != xmlMemBlocks()) {
! 37988: printf("Leak of %d blocks found in xmlUCSIsCatCo",
! 37989: xmlMemBlocks() - mem_base);
! 37990: test_ret++;
! 37991: printf(" %d", n_code);
! 37992: printf("\n");
! 37993: }
! 37994: }
! 37995: function_tests++;
! 37996: #endif
! 37997:
! 37998: return(test_ret);
! 37999: }
! 38000:
! 38001:
! 38002: static int
! 38003: test_xmlUCSIsCatCs(void) {
! 38004: int test_ret = 0;
! 38005:
! 38006: #if defined(LIBXML_UNICODE_ENABLED)
! 38007: int mem_base;
! 38008: int ret_val;
! 38009: int code; /* UCS code point */
! 38010: int n_code;
! 38011:
! 38012: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38013: mem_base = xmlMemBlocks();
! 38014: code = gen_int(n_code, 0);
! 38015:
! 38016: ret_val = xmlUCSIsCatCs(code);
! 38017: desret_int(ret_val);
! 38018: call_tests++;
! 38019: des_int(n_code, code, 0);
! 38020: xmlResetLastError();
! 38021: if (mem_base != xmlMemBlocks()) {
! 38022: printf("Leak of %d blocks found in xmlUCSIsCatCs",
! 38023: xmlMemBlocks() - mem_base);
! 38024: test_ret++;
! 38025: printf(" %d", n_code);
! 38026: printf("\n");
! 38027: }
! 38028: }
! 38029: function_tests++;
! 38030: #endif
! 38031:
! 38032: return(test_ret);
! 38033: }
! 38034:
! 38035:
! 38036: static int
! 38037: test_xmlUCSIsCatL(void) {
! 38038: int test_ret = 0;
! 38039:
! 38040: #if defined(LIBXML_UNICODE_ENABLED)
! 38041: int mem_base;
! 38042: int ret_val;
! 38043: int code; /* UCS code point */
! 38044: int n_code;
! 38045:
! 38046: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38047: mem_base = xmlMemBlocks();
! 38048: code = gen_int(n_code, 0);
! 38049:
! 38050: ret_val = xmlUCSIsCatL(code);
! 38051: desret_int(ret_val);
! 38052: call_tests++;
! 38053: des_int(n_code, code, 0);
! 38054: xmlResetLastError();
! 38055: if (mem_base != xmlMemBlocks()) {
! 38056: printf("Leak of %d blocks found in xmlUCSIsCatL",
! 38057: xmlMemBlocks() - mem_base);
! 38058: test_ret++;
! 38059: printf(" %d", n_code);
! 38060: printf("\n");
! 38061: }
! 38062: }
! 38063: function_tests++;
! 38064: #endif
! 38065:
! 38066: return(test_ret);
! 38067: }
! 38068:
! 38069:
! 38070: static int
! 38071: test_xmlUCSIsCatLl(void) {
! 38072: int test_ret = 0;
! 38073:
! 38074: #if defined(LIBXML_UNICODE_ENABLED)
! 38075: int mem_base;
! 38076: int ret_val;
! 38077: int code; /* UCS code point */
! 38078: int n_code;
! 38079:
! 38080: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38081: mem_base = xmlMemBlocks();
! 38082: code = gen_int(n_code, 0);
! 38083:
! 38084: ret_val = xmlUCSIsCatLl(code);
! 38085: desret_int(ret_val);
! 38086: call_tests++;
! 38087: des_int(n_code, code, 0);
! 38088: xmlResetLastError();
! 38089: if (mem_base != xmlMemBlocks()) {
! 38090: printf("Leak of %d blocks found in xmlUCSIsCatLl",
! 38091: xmlMemBlocks() - mem_base);
! 38092: test_ret++;
! 38093: printf(" %d", n_code);
! 38094: printf("\n");
! 38095: }
! 38096: }
! 38097: function_tests++;
! 38098: #endif
! 38099:
! 38100: return(test_ret);
! 38101: }
! 38102:
! 38103:
! 38104: static int
! 38105: test_xmlUCSIsCatLm(void) {
! 38106: int test_ret = 0;
! 38107:
! 38108: #if defined(LIBXML_UNICODE_ENABLED)
! 38109: int mem_base;
! 38110: int ret_val;
! 38111: int code; /* UCS code point */
! 38112: int n_code;
! 38113:
! 38114: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38115: mem_base = xmlMemBlocks();
! 38116: code = gen_int(n_code, 0);
! 38117:
! 38118: ret_val = xmlUCSIsCatLm(code);
! 38119: desret_int(ret_val);
! 38120: call_tests++;
! 38121: des_int(n_code, code, 0);
! 38122: xmlResetLastError();
! 38123: if (mem_base != xmlMemBlocks()) {
! 38124: printf("Leak of %d blocks found in xmlUCSIsCatLm",
! 38125: xmlMemBlocks() - mem_base);
! 38126: test_ret++;
! 38127: printf(" %d", n_code);
! 38128: printf("\n");
! 38129: }
! 38130: }
! 38131: function_tests++;
! 38132: #endif
! 38133:
! 38134: return(test_ret);
! 38135: }
! 38136:
! 38137:
! 38138: static int
! 38139: test_xmlUCSIsCatLo(void) {
! 38140: int test_ret = 0;
! 38141:
! 38142: #if defined(LIBXML_UNICODE_ENABLED)
! 38143: int mem_base;
! 38144: int ret_val;
! 38145: int code; /* UCS code point */
! 38146: int n_code;
! 38147:
! 38148: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38149: mem_base = xmlMemBlocks();
! 38150: code = gen_int(n_code, 0);
! 38151:
! 38152: ret_val = xmlUCSIsCatLo(code);
! 38153: desret_int(ret_val);
! 38154: call_tests++;
! 38155: des_int(n_code, code, 0);
! 38156: xmlResetLastError();
! 38157: if (mem_base != xmlMemBlocks()) {
! 38158: printf("Leak of %d blocks found in xmlUCSIsCatLo",
! 38159: xmlMemBlocks() - mem_base);
! 38160: test_ret++;
! 38161: printf(" %d", n_code);
! 38162: printf("\n");
! 38163: }
! 38164: }
! 38165: function_tests++;
! 38166: #endif
! 38167:
! 38168: return(test_ret);
! 38169: }
! 38170:
! 38171:
! 38172: static int
! 38173: test_xmlUCSIsCatLt(void) {
! 38174: int test_ret = 0;
! 38175:
! 38176: #if defined(LIBXML_UNICODE_ENABLED)
! 38177: int mem_base;
! 38178: int ret_val;
! 38179: int code; /* UCS code point */
! 38180: int n_code;
! 38181:
! 38182: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38183: mem_base = xmlMemBlocks();
! 38184: code = gen_int(n_code, 0);
! 38185:
! 38186: ret_val = xmlUCSIsCatLt(code);
! 38187: desret_int(ret_val);
! 38188: call_tests++;
! 38189: des_int(n_code, code, 0);
! 38190: xmlResetLastError();
! 38191: if (mem_base != xmlMemBlocks()) {
! 38192: printf("Leak of %d blocks found in xmlUCSIsCatLt",
! 38193: xmlMemBlocks() - mem_base);
! 38194: test_ret++;
! 38195: printf(" %d", n_code);
! 38196: printf("\n");
! 38197: }
! 38198: }
! 38199: function_tests++;
! 38200: #endif
! 38201:
! 38202: return(test_ret);
! 38203: }
! 38204:
! 38205:
! 38206: static int
! 38207: test_xmlUCSIsCatLu(void) {
! 38208: int test_ret = 0;
! 38209:
! 38210: #if defined(LIBXML_UNICODE_ENABLED)
! 38211: int mem_base;
! 38212: int ret_val;
! 38213: int code; /* UCS code point */
! 38214: int n_code;
! 38215:
! 38216: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38217: mem_base = xmlMemBlocks();
! 38218: code = gen_int(n_code, 0);
! 38219:
! 38220: ret_val = xmlUCSIsCatLu(code);
! 38221: desret_int(ret_val);
! 38222: call_tests++;
! 38223: des_int(n_code, code, 0);
! 38224: xmlResetLastError();
! 38225: if (mem_base != xmlMemBlocks()) {
! 38226: printf("Leak of %d blocks found in xmlUCSIsCatLu",
! 38227: xmlMemBlocks() - mem_base);
! 38228: test_ret++;
! 38229: printf(" %d", n_code);
! 38230: printf("\n");
! 38231: }
! 38232: }
! 38233: function_tests++;
! 38234: #endif
! 38235:
! 38236: return(test_ret);
! 38237: }
! 38238:
! 38239:
! 38240: static int
! 38241: test_xmlUCSIsCatM(void) {
! 38242: int test_ret = 0;
! 38243:
! 38244: #if defined(LIBXML_UNICODE_ENABLED)
! 38245: int mem_base;
! 38246: int ret_val;
! 38247: int code; /* UCS code point */
! 38248: int n_code;
! 38249:
! 38250: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38251: mem_base = xmlMemBlocks();
! 38252: code = gen_int(n_code, 0);
! 38253:
! 38254: ret_val = xmlUCSIsCatM(code);
! 38255: desret_int(ret_val);
! 38256: call_tests++;
! 38257: des_int(n_code, code, 0);
! 38258: xmlResetLastError();
! 38259: if (mem_base != xmlMemBlocks()) {
! 38260: printf("Leak of %d blocks found in xmlUCSIsCatM",
! 38261: xmlMemBlocks() - mem_base);
! 38262: test_ret++;
! 38263: printf(" %d", n_code);
! 38264: printf("\n");
! 38265: }
! 38266: }
! 38267: function_tests++;
! 38268: #endif
! 38269:
! 38270: return(test_ret);
! 38271: }
! 38272:
! 38273:
! 38274: static int
! 38275: test_xmlUCSIsCatMc(void) {
! 38276: int test_ret = 0;
! 38277:
! 38278: #if defined(LIBXML_UNICODE_ENABLED)
! 38279: int mem_base;
! 38280: int ret_val;
! 38281: int code; /* UCS code point */
! 38282: int n_code;
! 38283:
! 38284: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38285: mem_base = xmlMemBlocks();
! 38286: code = gen_int(n_code, 0);
! 38287:
! 38288: ret_val = xmlUCSIsCatMc(code);
! 38289: desret_int(ret_val);
! 38290: call_tests++;
! 38291: des_int(n_code, code, 0);
! 38292: xmlResetLastError();
! 38293: if (mem_base != xmlMemBlocks()) {
! 38294: printf("Leak of %d blocks found in xmlUCSIsCatMc",
! 38295: xmlMemBlocks() - mem_base);
! 38296: test_ret++;
! 38297: printf(" %d", n_code);
! 38298: printf("\n");
! 38299: }
! 38300: }
! 38301: function_tests++;
! 38302: #endif
! 38303:
! 38304: return(test_ret);
! 38305: }
! 38306:
! 38307:
! 38308: static int
! 38309: test_xmlUCSIsCatMe(void) {
! 38310: int test_ret = 0;
! 38311:
! 38312: #if defined(LIBXML_UNICODE_ENABLED)
! 38313: int mem_base;
! 38314: int ret_val;
! 38315: int code; /* UCS code point */
! 38316: int n_code;
! 38317:
! 38318: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38319: mem_base = xmlMemBlocks();
! 38320: code = gen_int(n_code, 0);
! 38321:
! 38322: ret_val = xmlUCSIsCatMe(code);
! 38323: desret_int(ret_val);
! 38324: call_tests++;
! 38325: des_int(n_code, code, 0);
! 38326: xmlResetLastError();
! 38327: if (mem_base != xmlMemBlocks()) {
! 38328: printf("Leak of %d blocks found in xmlUCSIsCatMe",
! 38329: xmlMemBlocks() - mem_base);
! 38330: test_ret++;
! 38331: printf(" %d", n_code);
! 38332: printf("\n");
! 38333: }
! 38334: }
! 38335: function_tests++;
! 38336: #endif
! 38337:
! 38338: return(test_ret);
! 38339: }
! 38340:
! 38341:
! 38342: static int
! 38343: test_xmlUCSIsCatMn(void) {
! 38344: int test_ret = 0;
! 38345:
! 38346: #if defined(LIBXML_UNICODE_ENABLED)
! 38347: int mem_base;
! 38348: int ret_val;
! 38349: int code; /* UCS code point */
! 38350: int n_code;
! 38351:
! 38352: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38353: mem_base = xmlMemBlocks();
! 38354: code = gen_int(n_code, 0);
! 38355:
! 38356: ret_val = xmlUCSIsCatMn(code);
! 38357: desret_int(ret_val);
! 38358: call_tests++;
! 38359: des_int(n_code, code, 0);
! 38360: xmlResetLastError();
! 38361: if (mem_base != xmlMemBlocks()) {
! 38362: printf("Leak of %d blocks found in xmlUCSIsCatMn",
! 38363: xmlMemBlocks() - mem_base);
! 38364: test_ret++;
! 38365: printf(" %d", n_code);
! 38366: printf("\n");
! 38367: }
! 38368: }
! 38369: function_tests++;
! 38370: #endif
! 38371:
! 38372: return(test_ret);
! 38373: }
! 38374:
! 38375:
! 38376: static int
! 38377: test_xmlUCSIsCatN(void) {
! 38378: int test_ret = 0;
! 38379:
! 38380: #if defined(LIBXML_UNICODE_ENABLED)
! 38381: int mem_base;
! 38382: int ret_val;
! 38383: int code; /* UCS code point */
! 38384: int n_code;
! 38385:
! 38386: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38387: mem_base = xmlMemBlocks();
! 38388: code = gen_int(n_code, 0);
! 38389:
! 38390: ret_val = xmlUCSIsCatN(code);
! 38391: desret_int(ret_val);
! 38392: call_tests++;
! 38393: des_int(n_code, code, 0);
! 38394: xmlResetLastError();
! 38395: if (mem_base != xmlMemBlocks()) {
! 38396: printf("Leak of %d blocks found in xmlUCSIsCatN",
! 38397: xmlMemBlocks() - mem_base);
! 38398: test_ret++;
! 38399: printf(" %d", n_code);
! 38400: printf("\n");
! 38401: }
! 38402: }
! 38403: function_tests++;
! 38404: #endif
! 38405:
! 38406: return(test_ret);
! 38407: }
! 38408:
! 38409:
! 38410: static int
! 38411: test_xmlUCSIsCatNd(void) {
! 38412: int test_ret = 0;
! 38413:
! 38414: #if defined(LIBXML_UNICODE_ENABLED)
! 38415: int mem_base;
! 38416: int ret_val;
! 38417: int code; /* UCS code point */
! 38418: int n_code;
! 38419:
! 38420: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38421: mem_base = xmlMemBlocks();
! 38422: code = gen_int(n_code, 0);
! 38423:
! 38424: ret_val = xmlUCSIsCatNd(code);
! 38425: desret_int(ret_val);
! 38426: call_tests++;
! 38427: des_int(n_code, code, 0);
! 38428: xmlResetLastError();
! 38429: if (mem_base != xmlMemBlocks()) {
! 38430: printf("Leak of %d blocks found in xmlUCSIsCatNd",
! 38431: xmlMemBlocks() - mem_base);
! 38432: test_ret++;
! 38433: printf(" %d", n_code);
! 38434: printf("\n");
! 38435: }
! 38436: }
! 38437: function_tests++;
! 38438: #endif
! 38439:
! 38440: return(test_ret);
! 38441: }
! 38442:
! 38443:
! 38444: static int
! 38445: test_xmlUCSIsCatNl(void) {
! 38446: int test_ret = 0;
! 38447:
! 38448: #if defined(LIBXML_UNICODE_ENABLED)
! 38449: int mem_base;
! 38450: int ret_val;
! 38451: int code; /* UCS code point */
! 38452: int n_code;
! 38453:
! 38454: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38455: mem_base = xmlMemBlocks();
! 38456: code = gen_int(n_code, 0);
! 38457:
! 38458: ret_val = xmlUCSIsCatNl(code);
! 38459: desret_int(ret_val);
! 38460: call_tests++;
! 38461: des_int(n_code, code, 0);
! 38462: xmlResetLastError();
! 38463: if (mem_base != xmlMemBlocks()) {
! 38464: printf("Leak of %d blocks found in xmlUCSIsCatNl",
! 38465: xmlMemBlocks() - mem_base);
! 38466: test_ret++;
! 38467: printf(" %d", n_code);
! 38468: printf("\n");
! 38469: }
! 38470: }
! 38471: function_tests++;
! 38472: #endif
! 38473:
! 38474: return(test_ret);
! 38475: }
! 38476:
! 38477:
! 38478: static int
! 38479: test_xmlUCSIsCatNo(void) {
! 38480: int test_ret = 0;
! 38481:
! 38482: #if defined(LIBXML_UNICODE_ENABLED)
! 38483: int mem_base;
! 38484: int ret_val;
! 38485: int code; /* UCS code point */
! 38486: int n_code;
! 38487:
! 38488: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38489: mem_base = xmlMemBlocks();
! 38490: code = gen_int(n_code, 0);
! 38491:
! 38492: ret_val = xmlUCSIsCatNo(code);
! 38493: desret_int(ret_val);
! 38494: call_tests++;
! 38495: des_int(n_code, code, 0);
! 38496: xmlResetLastError();
! 38497: if (mem_base != xmlMemBlocks()) {
! 38498: printf("Leak of %d blocks found in xmlUCSIsCatNo",
! 38499: xmlMemBlocks() - mem_base);
! 38500: test_ret++;
! 38501: printf(" %d", n_code);
! 38502: printf("\n");
! 38503: }
! 38504: }
! 38505: function_tests++;
! 38506: #endif
! 38507:
! 38508: return(test_ret);
! 38509: }
! 38510:
! 38511:
! 38512: static int
! 38513: test_xmlUCSIsCatP(void) {
! 38514: int test_ret = 0;
! 38515:
! 38516: #if defined(LIBXML_UNICODE_ENABLED)
! 38517: int mem_base;
! 38518: int ret_val;
! 38519: int code; /* UCS code point */
! 38520: int n_code;
! 38521:
! 38522: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38523: mem_base = xmlMemBlocks();
! 38524: code = gen_int(n_code, 0);
! 38525:
! 38526: ret_val = xmlUCSIsCatP(code);
! 38527: desret_int(ret_val);
! 38528: call_tests++;
! 38529: des_int(n_code, code, 0);
! 38530: xmlResetLastError();
! 38531: if (mem_base != xmlMemBlocks()) {
! 38532: printf("Leak of %d blocks found in xmlUCSIsCatP",
! 38533: xmlMemBlocks() - mem_base);
! 38534: test_ret++;
! 38535: printf(" %d", n_code);
! 38536: printf("\n");
! 38537: }
! 38538: }
! 38539: function_tests++;
! 38540: #endif
! 38541:
! 38542: return(test_ret);
! 38543: }
! 38544:
! 38545:
! 38546: static int
! 38547: test_xmlUCSIsCatPc(void) {
! 38548: int test_ret = 0;
! 38549:
! 38550: #if defined(LIBXML_UNICODE_ENABLED)
! 38551: int mem_base;
! 38552: int ret_val;
! 38553: int code; /* UCS code point */
! 38554: int n_code;
! 38555:
! 38556: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38557: mem_base = xmlMemBlocks();
! 38558: code = gen_int(n_code, 0);
! 38559:
! 38560: ret_val = xmlUCSIsCatPc(code);
! 38561: desret_int(ret_val);
! 38562: call_tests++;
! 38563: des_int(n_code, code, 0);
! 38564: xmlResetLastError();
! 38565: if (mem_base != xmlMemBlocks()) {
! 38566: printf("Leak of %d blocks found in xmlUCSIsCatPc",
! 38567: xmlMemBlocks() - mem_base);
! 38568: test_ret++;
! 38569: printf(" %d", n_code);
! 38570: printf("\n");
! 38571: }
! 38572: }
! 38573: function_tests++;
! 38574: #endif
! 38575:
! 38576: return(test_ret);
! 38577: }
! 38578:
! 38579:
! 38580: static int
! 38581: test_xmlUCSIsCatPd(void) {
! 38582: int test_ret = 0;
! 38583:
! 38584: #if defined(LIBXML_UNICODE_ENABLED)
! 38585: int mem_base;
! 38586: int ret_val;
! 38587: int code; /* UCS code point */
! 38588: int n_code;
! 38589:
! 38590: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38591: mem_base = xmlMemBlocks();
! 38592: code = gen_int(n_code, 0);
! 38593:
! 38594: ret_val = xmlUCSIsCatPd(code);
! 38595: desret_int(ret_val);
! 38596: call_tests++;
! 38597: des_int(n_code, code, 0);
! 38598: xmlResetLastError();
! 38599: if (mem_base != xmlMemBlocks()) {
! 38600: printf("Leak of %d blocks found in xmlUCSIsCatPd",
! 38601: xmlMemBlocks() - mem_base);
! 38602: test_ret++;
! 38603: printf(" %d", n_code);
! 38604: printf("\n");
! 38605: }
! 38606: }
! 38607: function_tests++;
! 38608: #endif
! 38609:
! 38610: return(test_ret);
! 38611: }
! 38612:
! 38613:
! 38614: static int
! 38615: test_xmlUCSIsCatPe(void) {
! 38616: int test_ret = 0;
! 38617:
! 38618: #if defined(LIBXML_UNICODE_ENABLED)
! 38619: int mem_base;
! 38620: int ret_val;
! 38621: int code; /* UCS code point */
! 38622: int n_code;
! 38623:
! 38624: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38625: mem_base = xmlMemBlocks();
! 38626: code = gen_int(n_code, 0);
! 38627:
! 38628: ret_val = xmlUCSIsCatPe(code);
! 38629: desret_int(ret_val);
! 38630: call_tests++;
! 38631: des_int(n_code, code, 0);
! 38632: xmlResetLastError();
! 38633: if (mem_base != xmlMemBlocks()) {
! 38634: printf("Leak of %d blocks found in xmlUCSIsCatPe",
! 38635: xmlMemBlocks() - mem_base);
! 38636: test_ret++;
! 38637: printf(" %d", n_code);
! 38638: printf("\n");
! 38639: }
! 38640: }
! 38641: function_tests++;
! 38642: #endif
! 38643:
! 38644: return(test_ret);
! 38645: }
! 38646:
! 38647:
! 38648: static int
! 38649: test_xmlUCSIsCatPf(void) {
! 38650: int test_ret = 0;
! 38651:
! 38652: #if defined(LIBXML_UNICODE_ENABLED)
! 38653: int mem_base;
! 38654: int ret_val;
! 38655: int code; /* UCS code point */
! 38656: int n_code;
! 38657:
! 38658: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38659: mem_base = xmlMemBlocks();
! 38660: code = gen_int(n_code, 0);
! 38661:
! 38662: ret_val = xmlUCSIsCatPf(code);
! 38663: desret_int(ret_val);
! 38664: call_tests++;
! 38665: des_int(n_code, code, 0);
! 38666: xmlResetLastError();
! 38667: if (mem_base != xmlMemBlocks()) {
! 38668: printf("Leak of %d blocks found in xmlUCSIsCatPf",
! 38669: xmlMemBlocks() - mem_base);
! 38670: test_ret++;
! 38671: printf(" %d", n_code);
! 38672: printf("\n");
! 38673: }
! 38674: }
! 38675: function_tests++;
! 38676: #endif
! 38677:
! 38678: return(test_ret);
! 38679: }
! 38680:
! 38681:
! 38682: static int
! 38683: test_xmlUCSIsCatPi(void) {
! 38684: int test_ret = 0;
! 38685:
! 38686: #if defined(LIBXML_UNICODE_ENABLED)
! 38687: int mem_base;
! 38688: int ret_val;
! 38689: int code; /* UCS code point */
! 38690: int n_code;
! 38691:
! 38692: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38693: mem_base = xmlMemBlocks();
! 38694: code = gen_int(n_code, 0);
! 38695:
! 38696: ret_val = xmlUCSIsCatPi(code);
! 38697: desret_int(ret_val);
! 38698: call_tests++;
! 38699: des_int(n_code, code, 0);
! 38700: xmlResetLastError();
! 38701: if (mem_base != xmlMemBlocks()) {
! 38702: printf("Leak of %d blocks found in xmlUCSIsCatPi",
! 38703: xmlMemBlocks() - mem_base);
! 38704: test_ret++;
! 38705: printf(" %d", n_code);
! 38706: printf("\n");
! 38707: }
! 38708: }
! 38709: function_tests++;
! 38710: #endif
! 38711:
! 38712: return(test_ret);
! 38713: }
! 38714:
! 38715:
! 38716: static int
! 38717: test_xmlUCSIsCatPo(void) {
! 38718: int test_ret = 0;
! 38719:
! 38720: #if defined(LIBXML_UNICODE_ENABLED)
! 38721: int mem_base;
! 38722: int ret_val;
! 38723: int code; /* UCS code point */
! 38724: int n_code;
! 38725:
! 38726: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38727: mem_base = xmlMemBlocks();
! 38728: code = gen_int(n_code, 0);
! 38729:
! 38730: ret_val = xmlUCSIsCatPo(code);
! 38731: desret_int(ret_val);
! 38732: call_tests++;
! 38733: des_int(n_code, code, 0);
! 38734: xmlResetLastError();
! 38735: if (mem_base != xmlMemBlocks()) {
! 38736: printf("Leak of %d blocks found in xmlUCSIsCatPo",
! 38737: xmlMemBlocks() - mem_base);
! 38738: test_ret++;
! 38739: printf(" %d", n_code);
! 38740: printf("\n");
! 38741: }
! 38742: }
! 38743: function_tests++;
! 38744: #endif
! 38745:
! 38746: return(test_ret);
! 38747: }
! 38748:
! 38749:
! 38750: static int
! 38751: test_xmlUCSIsCatPs(void) {
! 38752: int test_ret = 0;
! 38753:
! 38754: #if defined(LIBXML_UNICODE_ENABLED)
! 38755: int mem_base;
! 38756: int ret_val;
! 38757: int code; /* UCS code point */
! 38758: int n_code;
! 38759:
! 38760: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38761: mem_base = xmlMemBlocks();
! 38762: code = gen_int(n_code, 0);
! 38763:
! 38764: ret_val = xmlUCSIsCatPs(code);
! 38765: desret_int(ret_val);
! 38766: call_tests++;
! 38767: des_int(n_code, code, 0);
! 38768: xmlResetLastError();
! 38769: if (mem_base != xmlMemBlocks()) {
! 38770: printf("Leak of %d blocks found in xmlUCSIsCatPs",
! 38771: xmlMemBlocks() - mem_base);
! 38772: test_ret++;
! 38773: printf(" %d", n_code);
! 38774: printf("\n");
! 38775: }
! 38776: }
! 38777: function_tests++;
! 38778: #endif
! 38779:
! 38780: return(test_ret);
! 38781: }
! 38782:
! 38783:
! 38784: static int
! 38785: test_xmlUCSIsCatS(void) {
! 38786: int test_ret = 0;
! 38787:
! 38788: #if defined(LIBXML_UNICODE_ENABLED)
! 38789: int mem_base;
! 38790: int ret_val;
! 38791: int code; /* UCS code point */
! 38792: int n_code;
! 38793:
! 38794: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38795: mem_base = xmlMemBlocks();
! 38796: code = gen_int(n_code, 0);
! 38797:
! 38798: ret_val = xmlUCSIsCatS(code);
! 38799: desret_int(ret_val);
! 38800: call_tests++;
! 38801: des_int(n_code, code, 0);
! 38802: xmlResetLastError();
! 38803: if (mem_base != xmlMemBlocks()) {
! 38804: printf("Leak of %d blocks found in xmlUCSIsCatS",
! 38805: xmlMemBlocks() - mem_base);
! 38806: test_ret++;
! 38807: printf(" %d", n_code);
! 38808: printf("\n");
! 38809: }
! 38810: }
! 38811: function_tests++;
! 38812: #endif
! 38813:
! 38814: return(test_ret);
! 38815: }
! 38816:
! 38817:
! 38818: static int
! 38819: test_xmlUCSIsCatSc(void) {
! 38820: int test_ret = 0;
! 38821:
! 38822: #if defined(LIBXML_UNICODE_ENABLED)
! 38823: int mem_base;
! 38824: int ret_val;
! 38825: int code; /* UCS code point */
! 38826: int n_code;
! 38827:
! 38828: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38829: mem_base = xmlMemBlocks();
! 38830: code = gen_int(n_code, 0);
! 38831:
! 38832: ret_val = xmlUCSIsCatSc(code);
! 38833: desret_int(ret_val);
! 38834: call_tests++;
! 38835: des_int(n_code, code, 0);
! 38836: xmlResetLastError();
! 38837: if (mem_base != xmlMemBlocks()) {
! 38838: printf("Leak of %d blocks found in xmlUCSIsCatSc",
! 38839: xmlMemBlocks() - mem_base);
! 38840: test_ret++;
! 38841: printf(" %d", n_code);
! 38842: printf("\n");
! 38843: }
! 38844: }
! 38845: function_tests++;
! 38846: #endif
! 38847:
! 38848: return(test_ret);
! 38849: }
! 38850:
! 38851:
! 38852: static int
! 38853: test_xmlUCSIsCatSk(void) {
! 38854: int test_ret = 0;
! 38855:
! 38856: #if defined(LIBXML_UNICODE_ENABLED)
! 38857: int mem_base;
! 38858: int ret_val;
! 38859: int code; /* UCS code point */
! 38860: int n_code;
! 38861:
! 38862: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38863: mem_base = xmlMemBlocks();
! 38864: code = gen_int(n_code, 0);
! 38865:
! 38866: ret_val = xmlUCSIsCatSk(code);
! 38867: desret_int(ret_val);
! 38868: call_tests++;
! 38869: des_int(n_code, code, 0);
! 38870: xmlResetLastError();
! 38871: if (mem_base != xmlMemBlocks()) {
! 38872: printf("Leak of %d blocks found in xmlUCSIsCatSk",
! 38873: xmlMemBlocks() - mem_base);
! 38874: test_ret++;
! 38875: printf(" %d", n_code);
! 38876: printf("\n");
! 38877: }
! 38878: }
! 38879: function_tests++;
! 38880: #endif
! 38881:
! 38882: return(test_ret);
! 38883: }
! 38884:
! 38885:
! 38886: static int
! 38887: test_xmlUCSIsCatSm(void) {
! 38888: int test_ret = 0;
! 38889:
! 38890: #if defined(LIBXML_UNICODE_ENABLED)
! 38891: int mem_base;
! 38892: int ret_val;
! 38893: int code; /* UCS code point */
! 38894: int n_code;
! 38895:
! 38896: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38897: mem_base = xmlMemBlocks();
! 38898: code = gen_int(n_code, 0);
! 38899:
! 38900: ret_val = xmlUCSIsCatSm(code);
! 38901: desret_int(ret_val);
! 38902: call_tests++;
! 38903: des_int(n_code, code, 0);
! 38904: xmlResetLastError();
! 38905: if (mem_base != xmlMemBlocks()) {
! 38906: printf("Leak of %d blocks found in xmlUCSIsCatSm",
! 38907: xmlMemBlocks() - mem_base);
! 38908: test_ret++;
! 38909: printf(" %d", n_code);
! 38910: printf("\n");
! 38911: }
! 38912: }
! 38913: function_tests++;
! 38914: #endif
! 38915:
! 38916: return(test_ret);
! 38917: }
! 38918:
! 38919:
! 38920: static int
! 38921: test_xmlUCSIsCatSo(void) {
! 38922: int test_ret = 0;
! 38923:
! 38924: #if defined(LIBXML_UNICODE_ENABLED)
! 38925: int mem_base;
! 38926: int ret_val;
! 38927: int code; /* UCS code point */
! 38928: int n_code;
! 38929:
! 38930: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38931: mem_base = xmlMemBlocks();
! 38932: code = gen_int(n_code, 0);
! 38933:
! 38934: ret_val = xmlUCSIsCatSo(code);
! 38935: desret_int(ret_val);
! 38936: call_tests++;
! 38937: des_int(n_code, code, 0);
! 38938: xmlResetLastError();
! 38939: if (mem_base != xmlMemBlocks()) {
! 38940: printf("Leak of %d blocks found in xmlUCSIsCatSo",
! 38941: xmlMemBlocks() - mem_base);
! 38942: test_ret++;
! 38943: printf(" %d", n_code);
! 38944: printf("\n");
! 38945: }
! 38946: }
! 38947: function_tests++;
! 38948: #endif
! 38949:
! 38950: return(test_ret);
! 38951: }
! 38952:
! 38953:
! 38954: static int
! 38955: test_xmlUCSIsCatZ(void) {
! 38956: int test_ret = 0;
! 38957:
! 38958: #if defined(LIBXML_UNICODE_ENABLED)
! 38959: int mem_base;
! 38960: int ret_val;
! 38961: int code; /* UCS code point */
! 38962: int n_code;
! 38963:
! 38964: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38965: mem_base = xmlMemBlocks();
! 38966: code = gen_int(n_code, 0);
! 38967:
! 38968: ret_val = xmlUCSIsCatZ(code);
! 38969: desret_int(ret_val);
! 38970: call_tests++;
! 38971: des_int(n_code, code, 0);
! 38972: xmlResetLastError();
! 38973: if (mem_base != xmlMemBlocks()) {
! 38974: printf("Leak of %d blocks found in xmlUCSIsCatZ",
! 38975: xmlMemBlocks() - mem_base);
! 38976: test_ret++;
! 38977: printf(" %d", n_code);
! 38978: printf("\n");
! 38979: }
! 38980: }
! 38981: function_tests++;
! 38982: #endif
! 38983:
! 38984: return(test_ret);
! 38985: }
! 38986:
! 38987:
! 38988: static int
! 38989: test_xmlUCSIsCatZl(void) {
! 38990: int test_ret = 0;
! 38991:
! 38992: #if defined(LIBXML_UNICODE_ENABLED)
! 38993: int mem_base;
! 38994: int ret_val;
! 38995: int code; /* UCS code point */
! 38996: int n_code;
! 38997:
! 38998: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 38999: mem_base = xmlMemBlocks();
! 39000: code = gen_int(n_code, 0);
! 39001:
! 39002: ret_val = xmlUCSIsCatZl(code);
! 39003: desret_int(ret_val);
! 39004: call_tests++;
! 39005: des_int(n_code, code, 0);
! 39006: xmlResetLastError();
! 39007: if (mem_base != xmlMemBlocks()) {
! 39008: printf("Leak of %d blocks found in xmlUCSIsCatZl",
! 39009: xmlMemBlocks() - mem_base);
! 39010: test_ret++;
! 39011: printf(" %d", n_code);
! 39012: printf("\n");
! 39013: }
! 39014: }
! 39015: function_tests++;
! 39016: #endif
! 39017:
! 39018: return(test_ret);
! 39019: }
! 39020:
! 39021:
! 39022: static int
! 39023: test_xmlUCSIsCatZp(void) {
! 39024: int test_ret = 0;
! 39025:
! 39026: #if defined(LIBXML_UNICODE_ENABLED)
! 39027: int mem_base;
! 39028: int ret_val;
! 39029: int code; /* UCS code point */
! 39030: int n_code;
! 39031:
! 39032: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39033: mem_base = xmlMemBlocks();
! 39034: code = gen_int(n_code, 0);
! 39035:
! 39036: ret_val = xmlUCSIsCatZp(code);
! 39037: desret_int(ret_val);
! 39038: call_tests++;
! 39039: des_int(n_code, code, 0);
! 39040: xmlResetLastError();
! 39041: if (mem_base != xmlMemBlocks()) {
! 39042: printf("Leak of %d blocks found in xmlUCSIsCatZp",
! 39043: xmlMemBlocks() - mem_base);
! 39044: test_ret++;
! 39045: printf(" %d", n_code);
! 39046: printf("\n");
! 39047: }
! 39048: }
! 39049: function_tests++;
! 39050: #endif
! 39051:
! 39052: return(test_ret);
! 39053: }
! 39054:
! 39055:
! 39056: static int
! 39057: test_xmlUCSIsCatZs(void) {
! 39058: int test_ret = 0;
! 39059:
! 39060: #if defined(LIBXML_UNICODE_ENABLED)
! 39061: int mem_base;
! 39062: int ret_val;
! 39063: int code; /* UCS code point */
! 39064: int n_code;
! 39065:
! 39066: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39067: mem_base = xmlMemBlocks();
! 39068: code = gen_int(n_code, 0);
! 39069:
! 39070: ret_val = xmlUCSIsCatZs(code);
! 39071: desret_int(ret_val);
! 39072: call_tests++;
! 39073: des_int(n_code, code, 0);
! 39074: xmlResetLastError();
! 39075: if (mem_base != xmlMemBlocks()) {
! 39076: printf("Leak of %d blocks found in xmlUCSIsCatZs",
! 39077: xmlMemBlocks() - mem_base);
! 39078: test_ret++;
! 39079: printf(" %d", n_code);
! 39080: printf("\n");
! 39081: }
! 39082: }
! 39083: function_tests++;
! 39084: #endif
! 39085:
! 39086: return(test_ret);
! 39087: }
! 39088:
! 39089:
! 39090: static int
! 39091: test_xmlUCSIsCherokee(void) {
! 39092: int test_ret = 0;
! 39093:
! 39094: #if defined(LIBXML_UNICODE_ENABLED)
! 39095: int mem_base;
! 39096: int ret_val;
! 39097: int code; /* UCS code point */
! 39098: int n_code;
! 39099:
! 39100: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39101: mem_base = xmlMemBlocks();
! 39102: code = gen_int(n_code, 0);
! 39103:
! 39104: ret_val = xmlUCSIsCherokee(code);
! 39105: desret_int(ret_val);
! 39106: call_tests++;
! 39107: des_int(n_code, code, 0);
! 39108: xmlResetLastError();
! 39109: if (mem_base != xmlMemBlocks()) {
! 39110: printf("Leak of %d blocks found in xmlUCSIsCherokee",
! 39111: xmlMemBlocks() - mem_base);
! 39112: test_ret++;
! 39113: printf(" %d", n_code);
! 39114: printf("\n");
! 39115: }
! 39116: }
! 39117: function_tests++;
! 39118: #endif
! 39119:
! 39120: return(test_ret);
! 39121: }
! 39122:
! 39123:
! 39124: static int
! 39125: test_xmlUCSIsCombiningDiacriticalMarks(void) {
! 39126: int test_ret = 0;
! 39127:
! 39128: #if defined(LIBXML_UNICODE_ENABLED)
! 39129: int mem_base;
! 39130: int ret_val;
! 39131: int code; /* UCS code point */
! 39132: int n_code;
! 39133:
! 39134: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39135: mem_base = xmlMemBlocks();
! 39136: code = gen_int(n_code, 0);
! 39137:
! 39138: ret_val = xmlUCSIsCombiningDiacriticalMarks(code);
! 39139: desret_int(ret_val);
! 39140: call_tests++;
! 39141: des_int(n_code, code, 0);
! 39142: xmlResetLastError();
! 39143: if (mem_base != xmlMemBlocks()) {
! 39144: printf("Leak of %d blocks found in xmlUCSIsCombiningDiacriticalMarks",
! 39145: xmlMemBlocks() - mem_base);
! 39146: test_ret++;
! 39147: printf(" %d", n_code);
! 39148: printf("\n");
! 39149: }
! 39150: }
! 39151: function_tests++;
! 39152: #endif
! 39153:
! 39154: return(test_ret);
! 39155: }
! 39156:
! 39157:
! 39158: static int
! 39159: test_xmlUCSIsCombiningDiacriticalMarksforSymbols(void) {
! 39160: int test_ret = 0;
! 39161:
! 39162: #if defined(LIBXML_UNICODE_ENABLED)
! 39163: int mem_base;
! 39164: int ret_val;
! 39165: int code; /* UCS code point */
! 39166: int n_code;
! 39167:
! 39168: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39169: mem_base = xmlMemBlocks();
! 39170: code = gen_int(n_code, 0);
! 39171:
! 39172: ret_val = xmlUCSIsCombiningDiacriticalMarksforSymbols(code);
! 39173: desret_int(ret_val);
! 39174: call_tests++;
! 39175: des_int(n_code, code, 0);
! 39176: xmlResetLastError();
! 39177: if (mem_base != xmlMemBlocks()) {
! 39178: printf("Leak of %d blocks found in xmlUCSIsCombiningDiacriticalMarksforSymbols",
! 39179: xmlMemBlocks() - mem_base);
! 39180: test_ret++;
! 39181: printf(" %d", n_code);
! 39182: printf("\n");
! 39183: }
! 39184: }
! 39185: function_tests++;
! 39186: #endif
! 39187:
! 39188: return(test_ret);
! 39189: }
! 39190:
! 39191:
! 39192: static int
! 39193: test_xmlUCSIsCombiningHalfMarks(void) {
! 39194: int test_ret = 0;
! 39195:
! 39196: #if defined(LIBXML_UNICODE_ENABLED)
! 39197: int mem_base;
! 39198: int ret_val;
! 39199: int code; /* UCS code point */
! 39200: int n_code;
! 39201:
! 39202: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39203: mem_base = xmlMemBlocks();
! 39204: code = gen_int(n_code, 0);
! 39205:
! 39206: ret_val = xmlUCSIsCombiningHalfMarks(code);
! 39207: desret_int(ret_val);
! 39208: call_tests++;
! 39209: des_int(n_code, code, 0);
! 39210: xmlResetLastError();
! 39211: if (mem_base != xmlMemBlocks()) {
! 39212: printf("Leak of %d blocks found in xmlUCSIsCombiningHalfMarks",
! 39213: xmlMemBlocks() - mem_base);
! 39214: test_ret++;
! 39215: printf(" %d", n_code);
! 39216: printf("\n");
! 39217: }
! 39218: }
! 39219: function_tests++;
! 39220: #endif
! 39221:
! 39222: return(test_ret);
! 39223: }
! 39224:
! 39225:
! 39226: static int
! 39227: test_xmlUCSIsCombiningMarksforSymbols(void) {
! 39228: int test_ret = 0;
! 39229:
! 39230: #if defined(LIBXML_UNICODE_ENABLED)
! 39231: int mem_base;
! 39232: int ret_val;
! 39233: int code; /* UCS code point */
! 39234: int n_code;
! 39235:
! 39236: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39237: mem_base = xmlMemBlocks();
! 39238: code = gen_int(n_code, 0);
! 39239:
! 39240: ret_val = xmlUCSIsCombiningMarksforSymbols(code);
! 39241: desret_int(ret_val);
! 39242: call_tests++;
! 39243: des_int(n_code, code, 0);
! 39244: xmlResetLastError();
! 39245: if (mem_base != xmlMemBlocks()) {
! 39246: printf("Leak of %d blocks found in xmlUCSIsCombiningMarksforSymbols",
! 39247: xmlMemBlocks() - mem_base);
! 39248: test_ret++;
! 39249: printf(" %d", n_code);
! 39250: printf("\n");
! 39251: }
! 39252: }
! 39253: function_tests++;
! 39254: #endif
! 39255:
! 39256: return(test_ret);
! 39257: }
! 39258:
! 39259:
! 39260: static int
! 39261: test_xmlUCSIsControlPictures(void) {
! 39262: int test_ret = 0;
! 39263:
! 39264: #if defined(LIBXML_UNICODE_ENABLED)
! 39265: int mem_base;
! 39266: int ret_val;
! 39267: int code; /* UCS code point */
! 39268: int n_code;
! 39269:
! 39270: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39271: mem_base = xmlMemBlocks();
! 39272: code = gen_int(n_code, 0);
! 39273:
! 39274: ret_val = xmlUCSIsControlPictures(code);
! 39275: desret_int(ret_val);
! 39276: call_tests++;
! 39277: des_int(n_code, code, 0);
! 39278: xmlResetLastError();
! 39279: if (mem_base != xmlMemBlocks()) {
! 39280: printf("Leak of %d blocks found in xmlUCSIsControlPictures",
! 39281: xmlMemBlocks() - mem_base);
! 39282: test_ret++;
! 39283: printf(" %d", n_code);
! 39284: printf("\n");
! 39285: }
! 39286: }
! 39287: function_tests++;
! 39288: #endif
! 39289:
! 39290: return(test_ret);
! 39291: }
! 39292:
! 39293:
! 39294: static int
! 39295: test_xmlUCSIsCurrencySymbols(void) {
! 39296: int test_ret = 0;
! 39297:
! 39298: #if defined(LIBXML_UNICODE_ENABLED)
! 39299: int mem_base;
! 39300: int ret_val;
! 39301: int code; /* UCS code point */
! 39302: int n_code;
! 39303:
! 39304: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39305: mem_base = xmlMemBlocks();
! 39306: code = gen_int(n_code, 0);
! 39307:
! 39308: ret_val = xmlUCSIsCurrencySymbols(code);
! 39309: desret_int(ret_val);
! 39310: call_tests++;
! 39311: des_int(n_code, code, 0);
! 39312: xmlResetLastError();
! 39313: if (mem_base != xmlMemBlocks()) {
! 39314: printf("Leak of %d blocks found in xmlUCSIsCurrencySymbols",
! 39315: xmlMemBlocks() - mem_base);
! 39316: test_ret++;
! 39317: printf(" %d", n_code);
! 39318: printf("\n");
! 39319: }
! 39320: }
! 39321: function_tests++;
! 39322: #endif
! 39323:
! 39324: return(test_ret);
! 39325: }
! 39326:
! 39327:
! 39328: static int
! 39329: test_xmlUCSIsCypriotSyllabary(void) {
! 39330: int test_ret = 0;
! 39331:
! 39332: #if defined(LIBXML_UNICODE_ENABLED)
! 39333: int mem_base;
! 39334: int ret_val;
! 39335: int code; /* UCS code point */
! 39336: int n_code;
! 39337:
! 39338: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39339: mem_base = xmlMemBlocks();
! 39340: code = gen_int(n_code, 0);
! 39341:
! 39342: ret_val = xmlUCSIsCypriotSyllabary(code);
! 39343: desret_int(ret_val);
! 39344: call_tests++;
! 39345: des_int(n_code, code, 0);
! 39346: xmlResetLastError();
! 39347: if (mem_base != xmlMemBlocks()) {
! 39348: printf("Leak of %d blocks found in xmlUCSIsCypriotSyllabary",
! 39349: xmlMemBlocks() - mem_base);
! 39350: test_ret++;
! 39351: printf(" %d", n_code);
! 39352: printf("\n");
! 39353: }
! 39354: }
! 39355: function_tests++;
! 39356: #endif
! 39357:
! 39358: return(test_ret);
! 39359: }
! 39360:
! 39361:
! 39362: static int
! 39363: test_xmlUCSIsCyrillic(void) {
! 39364: int test_ret = 0;
! 39365:
! 39366: #if defined(LIBXML_UNICODE_ENABLED)
! 39367: int mem_base;
! 39368: int ret_val;
! 39369: int code; /* UCS code point */
! 39370: int n_code;
! 39371:
! 39372: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39373: mem_base = xmlMemBlocks();
! 39374: code = gen_int(n_code, 0);
! 39375:
! 39376: ret_val = xmlUCSIsCyrillic(code);
! 39377: desret_int(ret_val);
! 39378: call_tests++;
! 39379: des_int(n_code, code, 0);
! 39380: xmlResetLastError();
! 39381: if (mem_base != xmlMemBlocks()) {
! 39382: printf("Leak of %d blocks found in xmlUCSIsCyrillic",
! 39383: xmlMemBlocks() - mem_base);
! 39384: test_ret++;
! 39385: printf(" %d", n_code);
! 39386: printf("\n");
! 39387: }
! 39388: }
! 39389: function_tests++;
! 39390: #endif
! 39391:
! 39392: return(test_ret);
! 39393: }
! 39394:
! 39395:
! 39396: static int
! 39397: test_xmlUCSIsCyrillicSupplement(void) {
! 39398: int test_ret = 0;
! 39399:
! 39400: #if defined(LIBXML_UNICODE_ENABLED)
! 39401: int mem_base;
! 39402: int ret_val;
! 39403: int code; /* UCS code point */
! 39404: int n_code;
! 39405:
! 39406: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39407: mem_base = xmlMemBlocks();
! 39408: code = gen_int(n_code, 0);
! 39409:
! 39410: ret_val = xmlUCSIsCyrillicSupplement(code);
! 39411: desret_int(ret_val);
! 39412: call_tests++;
! 39413: des_int(n_code, code, 0);
! 39414: xmlResetLastError();
! 39415: if (mem_base != xmlMemBlocks()) {
! 39416: printf("Leak of %d blocks found in xmlUCSIsCyrillicSupplement",
! 39417: xmlMemBlocks() - mem_base);
! 39418: test_ret++;
! 39419: printf(" %d", n_code);
! 39420: printf("\n");
! 39421: }
! 39422: }
! 39423: function_tests++;
! 39424: #endif
! 39425:
! 39426: return(test_ret);
! 39427: }
! 39428:
! 39429:
! 39430: static int
! 39431: test_xmlUCSIsDeseret(void) {
! 39432: int test_ret = 0;
! 39433:
! 39434: #if defined(LIBXML_UNICODE_ENABLED)
! 39435: int mem_base;
! 39436: int ret_val;
! 39437: int code; /* UCS code point */
! 39438: int n_code;
! 39439:
! 39440: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39441: mem_base = xmlMemBlocks();
! 39442: code = gen_int(n_code, 0);
! 39443:
! 39444: ret_val = xmlUCSIsDeseret(code);
! 39445: desret_int(ret_val);
! 39446: call_tests++;
! 39447: des_int(n_code, code, 0);
! 39448: xmlResetLastError();
! 39449: if (mem_base != xmlMemBlocks()) {
! 39450: printf("Leak of %d blocks found in xmlUCSIsDeseret",
! 39451: xmlMemBlocks() - mem_base);
! 39452: test_ret++;
! 39453: printf(" %d", n_code);
! 39454: printf("\n");
! 39455: }
! 39456: }
! 39457: function_tests++;
! 39458: #endif
! 39459:
! 39460: return(test_ret);
! 39461: }
! 39462:
! 39463:
! 39464: static int
! 39465: test_xmlUCSIsDevanagari(void) {
! 39466: int test_ret = 0;
! 39467:
! 39468: #if defined(LIBXML_UNICODE_ENABLED)
! 39469: int mem_base;
! 39470: int ret_val;
! 39471: int code; /* UCS code point */
! 39472: int n_code;
! 39473:
! 39474: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39475: mem_base = xmlMemBlocks();
! 39476: code = gen_int(n_code, 0);
! 39477:
! 39478: ret_val = xmlUCSIsDevanagari(code);
! 39479: desret_int(ret_val);
! 39480: call_tests++;
! 39481: des_int(n_code, code, 0);
! 39482: xmlResetLastError();
! 39483: if (mem_base != xmlMemBlocks()) {
! 39484: printf("Leak of %d blocks found in xmlUCSIsDevanagari",
! 39485: xmlMemBlocks() - mem_base);
! 39486: test_ret++;
! 39487: printf(" %d", n_code);
! 39488: printf("\n");
! 39489: }
! 39490: }
! 39491: function_tests++;
! 39492: #endif
! 39493:
! 39494: return(test_ret);
! 39495: }
! 39496:
! 39497:
! 39498: static int
! 39499: test_xmlUCSIsDingbats(void) {
! 39500: int test_ret = 0;
! 39501:
! 39502: #if defined(LIBXML_UNICODE_ENABLED)
! 39503: int mem_base;
! 39504: int ret_val;
! 39505: int code; /* UCS code point */
! 39506: int n_code;
! 39507:
! 39508: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39509: mem_base = xmlMemBlocks();
! 39510: code = gen_int(n_code, 0);
! 39511:
! 39512: ret_val = xmlUCSIsDingbats(code);
! 39513: desret_int(ret_val);
! 39514: call_tests++;
! 39515: des_int(n_code, code, 0);
! 39516: xmlResetLastError();
! 39517: if (mem_base != xmlMemBlocks()) {
! 39518: printf("Leak of %d blocks found in xmlUCSIsDingbats",
! 39519: xmlMemBlocks() - mem_base);
! 39520: test_ret++;
! 39521: printf(" %d", n_code);
! 39522: printf("\n");
! 39523: }
! 39524: }
! 39525: function_tests++;
! 39526: #endif
! 39527:
! 39528: return(test_ret);
! 39529: }
! 39530:
! 39531:
! 39532: static int
! 39533: test_xmlUCSIsEnclosedAlphanumerics(void) {
! 39534: int test_ret = 0;
! 39535:
! 39536: #if defined(LIBXML_UNICODE_ENABLED)
! 39537: int mem_base;
! 39538: int ret_val;
! 39539: int code; /* UCS code point */
! 39540: int n_code;
! 39541:
! 39542: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39543: mem_base = xmlMemBlocks();
! 39544: code = gen_int(n_code, 0);
! 39545:
! 39546: ret_val = xmlUCSIsEnclosedAlphanumerics(code);
! 39547: desret_int(ret_val);
! 39548: call_tests++;
! 39549: des_int(n_code, code, 0);
! 39550: xmlResetLastError();
! 39551: if (mem_base != xmlMemBlocks()) {
! 39552: printf("Leak of %d blocks found in xmlUCSIsEnclosedAlphanumerics",
! 39553: xmlMemBlocks() - mem_base);
! 39554: test_ret++;
! 39555: printf(" %d", n_code);
! 39556: printf("\n");
! 39557: }
! 39558: }
! 39559: function_tests++;
! 39560: #endif
! 39561:
! 39562: return(test_ret);
! 39563: }
! 39564:
! 39565:
! 39566: static int
! 39567: test_xmlUCSIsEnclosedCJKLettersandMonths(void) {
! 39568: int test_ret = 0;
! 39569:
! 39570: #if defined(LIBXML_UNICODE_ENABLED)
! 39571: int mem_base;
! 39572: int ret_val;
! 39573: int code; /* UCS code point */
! 39574: int n_code;
! 39575:
! 39576: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39577: mem_base = xmlMemBlocks();
! 39578: code = gen_int(n_code, 0);
! 39579:
! 39580: ret_val = xmlUCSIsEnclosedCJKLettersandMonths(code);
! 39581: desret_int(ret_val);
! 39582: call_tests++;
! 39583: des_int(n_code, code, 0);
! 39584: xmlResetLastError();
! 39585: if (mem_base != xmlMemBlocks()) {
! 39586: printf("Leak of %d blocks found in xmlUCSIsEnclosedCJKLettersandMonths",
! 39587: xmlMemBlocks() - mem_base);
! 39588: test_ret++;
! 39589: printf(" %d", n_code);
! 39590: printf("\n");
! 39591: }
! 39592: }
! 39593: function_tests++;
! 39594: #endif
! 39595:
! 39596: return(test_ret);
! 39597: }
! 39598:
! 39599:
! 39600: static int
! 39601: test_xmlUCSIsEthiopic(void) {
! 39602: int test_ret = 0;
! 39603:
! 39604: #if defined(LIBXML_UNICODE_ENABLED)
! 39605: int mem_base;
! 39606: int ret_val;
! 39607: int code; /* UCS code point */
! 39608: int n_code;
! 39609:
! 39610: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39611: mem_base = xmlMemBlocks();
! 39612: code = gen_int(n_code, 0);
! 39613:
! 39614: ret_val = xmlUCSIsEthiopic(code);
! 39615: desret_int(ret_val);
! 39616: call_tests++;
! 39617: des_int(n_code, code, 0);
! 39618: xmlResetLastError();
! 39619: if (mem_base != xmlMemBlocks()) {
! 39620: printf("Leak of %d blocks found in xmlUCSIsEthiopic",
! 39621: xmlMemBlocks() - mem_base);
! 39622: test_ret++;
! 39623: printf(" %d", n_code);
! 39624: printf("\n");
! 39625: }
! 39626: }
! 39627: function_tests++;
! 39628: #endif
! 39629:
! 39630: return(test_ret);
! 39631: }
! 39632:
! 39633:
! 39634: static int
! 39635: test_xmlUCSIsGeneralPunctuation(void) {
! 39636: int test_ret = 0;
! 39637:
! 39638: #if defined(LIBXML_UNICODE_ENABLED)
! 39639: int mem_base;
! 39640: int ret_val;
! 39641: int code; /* UCS code point */
! 39642: int n_code;
! 39643:
! 39644: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39645: mem_base = xmlMemBlocks();
! 39646: code = gen_int(n_code, 0);
! 39647:
! 39648: ret_val = xmlUCSIsGeneralPunctuation(code);
! 39649: desret_int(ret_val);
! 39650: call_tests++;
! 39651: des_int(n_code, code, 0);
! 39652: xmlResetLastError();
! 39653: if (mem_base != xmlMemBlocks()) {
! 39654: printf("Leak of %d blocks found in xmlUCSIsGeneralPunctuation",
! 39655: xmlMemBlocks() - mem_base);
! 39656: test_ret++;
! 39657: printf(" %d", n_code);
! 39658: printf("\n");
! 39659: }
! 39660: }
! 39661: function_tests++;
! 39662: #endif
! 39663:
! 39664: return(test_ret);
! 39665: }
! 39666:
! 39667:
! 39668: static int
! 39669: test_xmlUCSIsGeometricShapes(void) {
! 39670: int test_ret = 0;
! 39671:
! 39672: #if defined(LIBXML_UNICODE_ENABLED)
! 39673: int mem_base;
! 39674: int ret_val;
! 39675: int code; /* UCS code point */
! 39676: int n_code;
! 39677:
! 39678: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39679: mem_base = xmlMemBlocks();
! 39680: code = gen_int(n_code, 0);
! 39681:
! 39682: ret_val = xmlUCSIsGeometricShapes(code);
! 39683: desret_int(ret_val);
! 39684: call_tests++;
! 39685: des_int(n_code, code, 0);
! 39686: xmlResetLastError();
! 39687: if (mem_base != xmlMemBlocks()) {
! 39688: printf("Leak of %d blocks found in xmlUCSIsGeometricShapes",
! 39689: xmlMemBlocks() - mem_base);
! 39690: test_ret++;
! 39691: printf(" %d", n_code);
! 39692: printf("\n");
! 39693: }
! 39694: }
! 39695: function_tests++;
! 39696: #endif
! 39697:
! 39698: return(test_ret);
! 39699: }
! 39700:
! 39701:
! 39702: static int
! 39703: test_xmlUCSIsGeorgian(void) {
! 39704: int test_ret = 0;
! 39705:
! 39706: #if defined(LIBXML_UNICODE_ENABLED)
! 39707: int mem_base;
! 39708: int ret_val;
! 39709: int code; /* UCS code point */
! 39710: int n_code;
! 39711:
! 39712: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39713: mem_base = xmlMemBlocks();
! 39714: code = gen_int(n_code, 0);
! 39715:
! 39716: ret_val = xmlUCSIsGeorgian(code);
! 39717: desret_int(ret_val);
! 39718: call_tests++;
! 39719: des_int(n_code, code, 0);
! 39720: xmlResetLastError();
! 39721: if (mem_base != xmlMemBlocks()) {
! 39722: printf("Leak of %d blocks found in xmlUCSIsGeorgian",
! 39723: xmlMemBlocks() - mem_base);
! 39724: test_ret++;
! 39725: printf(" %d", n_code);
! 39726: printf("\n");
! 39727: }
! 39728: }
! 39729: function_tests++;
! 39730: #endif
! 39731:
! 39732: return(test_ret);
! 39733: }
! 39734:
! 39735:
! 39736: static int
! 39737: test_xmlUCSIsGothic(void) {
! 39738: int test_ret = 0;
! 39739:
! 39740: #if defined(LIBXML_UNICODE_ENABLED)
! 39741: int mem_base;
! 39742: int ret_val;
! 39743: int code; /* UCS code point */
! 39744: int n_code;
! 39745:
! 39746: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39747: mem_base = xmlMemBlocks();
! 39748: code = gen_int(n_code, 0);
! 39749:
! 39750: ret_val = xmlUCSIsGothic(code);
! 39751: desret_int(ret_val);
! 39752: call_tests++;
! 39753: des_int(n_code, code, 0);
! 39754: xmlResetLastError();
! 39755: if (mem_base != xmlMemBlocks()) {
! 39756: printf("Leak of %d blocks found in xmlUCSIsGothic",
! 39757: xmlMemBlocks() - mem_base);
! 39758: test_ret++;
! 39759: printf(" %d", n_code);
! 39760: printf("\n");
! 39761: }
! 39762: }
! 39763: function_tests++;
! 39764: #endif
! 39765:
! 39766: return(test_ret);
! 39767: }
! 39768:
! 39769:
! 39770: static int
! 39771: test_xmlUCSIsGreek(void) {
! 39772: int test_ret = 0;
! 39773:
! 39774: #if defined(LIBXML_UNICODE_ENABLED)
! 39775: int mem_base;
! 39776: int ret_val;
! 39777: int code; /* UCS code point */
! 39778: int n_code;
! 39779:
! 39780: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39781: mem_base = xmlMemBlocks();
! 39782: code = gen_int(n_code, 0);
! 39783:
! 39784: ret_val = xmlUCSIsGreek(code);
! 39785: desret_int(ret_val);
! 39786: call_tests++;
! 39787: des_int(n_code, code, 0);
! 39788: xmlResetLastError();
! 39789: if (mem_base != xmlMemBlocks()) {
! 39790: printf("Leak of %d blocks found in xmlUCSIsGreek",
! 39791: xmlMemBlocks() - mem_base);
! 39792: test_ret++;
! 39793: printf(" %d", n_code);
! 39794: printf("\n");
! 39795: }
! 39796: }
! 39797: function_tests++;
! 39798: #endif
! 39799:
! 39800: return(test_ret);
! 39801: }
! 39802:
! 39803:
! 39804: static int
! 39805: test_xmlUCSIsGreekExtended(void) {
! 39806: int test_ret = 0;
! 39807:
! 39808: #if defined(LIBXML_UNICODE_ENABLED)
! 39809: int mem_base;
! 39810: int ret_val;
! 39811: int code; /* UCS code point */
! 39812: int n_code;
! 39813:
! 39814: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39815: mem_base = xmlMemBlocks();
! 39816: code = gen_int(n_code, 0);
! 39817:
! 39818: ret_val = xmlUCSIsGreekExtended(code);
! 39819: desret_int(ret_val);
! 39820: call_tests++;
! 39821: des_int(n_code, code, 0);
! 39822: xmlResetLastError();
! 39823: if (mem_base != xmlMemBlocks()) {
! 39824: printf("Leak of %d blocks found in xmlUCSIsGreekExtended",
! 39825: xmlMemBlocks() - mem_base);
! 39826: test_ret++;
! 39827: printf(" %d", n_code);
! 39828: printf("\n");
! 39829: }
! 39830: }
! 39831: function_tests++;
! 39832: #endif
! 39833:
! 39834: return(test_ret);
! 39835: }
! 39836:
! 39837:
! 39838: static int
! 39839: test_xmlUCSIsGreekandCoptic(void) {
! 39840: int test_ret = 0;
! 39841:
! 39842: #if defined(LIBXML_UNICODE_ENABLED)
! 39843: int mem_base;
! 39844: int ret_val;
! 39845: int code; /* UCS code point */
! 39846: int n_code;
! 39847:
! 39848: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39849: mem_base = xmlMemBlocks();
! 39850: code = gen_int(n_code, 0);
! 39851:
! 39852: ret_val = xmlUCSIsGreekandCoptic(code);
! 39853: desret_int(ret_val);
! 39854: call_tests++;
! 39855: des_int(n_code, code, 0);
! 39856: xmlResetLastError();
! 39857: if (mem_base != xmlMemBlocks()) {
! 39858: printf("Leak of %d blocks found in xmlUCSIsGreekandCoptic",
! 39859: xmlMemBlocks() - mem_base);
! 39860: test_ret++;
! 39861: printf(" %d", n_code);
! 39862: printf("\n");
! 39863: }
! 39864: }
! 39865: function_tests++;
! 39866: #endif
! 39867:
! 39868: return(test_ret);
! 39869: }
! 39870:
! 39871:
! 39872: static int
! 39873: test_xmlUCSIsGujarati(void) {
! 39874: int test_ret = 0;
! 39875:
! 39876: #if defined(LIBXML_UNICODE_ENABLED)
! 39877: int mem_base;
! 39878: int ret_val;
! 39879: int code; /* UCS code point */
! 39880: int n_code;
! 39881:
! 39882: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39883: mem_base = xmlMemBlocks();
! 39884: code = gen_int(n_code, 0);
! 39885:
! 39886: ret_val = xmlUCSIsGujarati(code);
! 39887: desret_int(ret_val);
! 39888: call_tests++;
! 39889: des_int(n_code, code, 0);
! 39890: xmlResetLastError();
! 39891: if (mem_base != xmlMemBlocks()) {
! 39892: printf("Leak of %d blocks found in xmlUCSIsGujarati",
! 39893: xmlMemBlocks() - mem_base);
! 39894: test_ret++;
! 39895: printf(" %d", n_code);
! 39896: printf("\n");
! 39897: }
! 39898: }
! 39899: function_tests++;
! 39900: #endif
! 39901:
! 39902: return(test_ret);
! 39903: }
! 39904:
! 39905:
! 39906: static int
! 39907: test_xmlUCSIsGurmukhi(void) {
! 39908: int test_ret = 0;
! 39909:
! 39910: #if defined(LIBXML_UNICODE_ENABLED)
! 39911: int mem_base;
! 39912: int ret_val;
! 39913: int code; /* UCS code point */
! 39914: int n_code;
! 39915:
! 39916: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39917: mem_base = xmlMemBlocks();
! 39918: code = gen_int(n_code, 0);
! 39919:
! 39920: ret_val = xmlUCSIsGurmukhi(code);
! 39921: desret_int(ret_val);
! 39922: call_tests++;
! 39923: des_int(n_code, code, 0);
! 39924: xmlResetLastError();
! 39925: if (mem_base != xmlMemBlocks()) {
! 39926: printf("Leak of %d blocks found in xmlUCSIsGurmukhi",
! 39927: xmlMemBlocks() - mem_base);
! 39928: test_ret++;
! 39929: printf(" %d", n_code);
! 39930: printf("\n");
! 39931: }
! 39932: }
! 39933: function_tests++;
! 39934: #endif
! 39935:
! 39936: return(test_ret);
! 39937: }
! 39938:
! 39939:
! 39940: static int
! 39941: test_xmlUCSIsHalfwidthandFullwidthForms(void) {
! 39942: int test_ret = 0;
! 39943:
! 39944: #if defined(LIBXML_UNICODE_ENABLED)
! 39945: int mem_base;
! 39946: int ret_val;
! 39947: int code; /* UCS code point */
! 39948: int n_code;
! 39949:
! 39950: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39951: mem_base = xmlMemBlocks();
! 39952: code = gen_int(n_code, 0);
! 39953:
! 39954: ret_val = xmlUCSIsHalfwidthandFullwidthForms(code);
! 39955: desret_int(ret_val);
! 39956: call_tests++;
! 39957: des_int(n_code, code, 0);
! 39958: xmlResetLastError();
! 39959: if (mem_base != xmlMemBlocks()) {
! 39960: printf("Leak of %d blocks found in xmlUCSIsHalfwidthandFullwidthForms",
! 39961: xmlMemBlocks() - mem_base);
! 39962: test_ret++;
! 39963: printf(" %d", n_code);
! 39964: printf("\n");
! 39965: }
! 39966: }
! 39967: function_tests++;
! 39968: #endif
! 39969:
! 39970: return(test_ret);
! 39971: }
! 39972:
! 39973:
! 39974: static int
! 39975: test_xmlUCSIsHangulCompatibilityJamo(void) {
! 39976: int test_ret = 0;
! 39977:
! 39978: #if defined(LIBXML_UNICODE_ENABLED)
! 39979: int mem_base;
! 39980: int ret_val;
! 39981: int code; /* UCS code point */
! 39982: int n_code;
! 39983:
! 39984: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 39985: mem_base = xmlMemBlocks();
! 39986: code = gen_int(n_code, 0);
! 39987:
! 39988: ret_val = xmlUCSIsHangulCompatibilityJamo(code);
! 39989: desret_int(ret_val);
! 39990: call_tests++;
! 39991: des_int(n_code, code, 0);
! 39992: xmlResetLastError();
! 39993: if (mem_base != xmlMemBlocks()) {
! 39994: printf("Leak of %d blocks found in xmlUCSIsHangulCompatibilityJamo",
! 39995: xmlMemBlocks() - mem_base);
! 39996: test_ret++;
! 39997: printf(" %d", n_code);
! 39998: printf("\n");
! 39999: }
! 40000: }
! 40001: function_tests++;
! 40002: #endif
! 40003:
! 40004: return(test_ret);
! 40005: }
! 40006:
! 40007:
! 40008: static int
! 40009: test_xmlUCSIsHangulJamo(void) {
! 40010: int test_ret = 0;
! 40011:
! 40012: #if defined(LIBXML_UNICODE_ENABLED)
! 40013: int mem_base;
! 40014: int ret_val;
! 40015: int code; /* UCS code point */
! 40016: int n_code;
! 40017:
! 40018: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40019: mem_base = xmlMemBlocks();
! 40020: code = gen_int(n_code, 0);
! 40021:
! 40022: ret_val = xmlUCSIsHangulJamo(code);
! 40023: desret_int(ret_val);
! 40024: call_tests++;
! 40025: des_int(n_code, code, 0);
! 40026: xmlResetLastError();
! 40027: if (mem_base != xmlMemBlocks()) {
! 40028: printf("Leak of %d blocks found in xmlUCSIsHangulJamo",
! 40029: xmlMemBlocks() - mem_base);
! 40030: test_ret++;
! 40031: printf(" %d", n_code);
! 40032: printf("\n");
! 40033: }
! 40034: }
! 40035: function_tests++;
! 40036: #endif
! 40037:
! 40038: return(test_ret);
! 40039: }
! 40040:
! 40041:
! 40042: static int
! 40043: test_xmlUCSIsHangulSyllables(void) {
! 40044: int test_ret = 0;
! 40045:
! 40046: #if defined(LIBXML_UNICODE_ENABLED)
! 40047: int mem_base;
! 40048: int ret_val;
! 40049: int code; /* UCS code point */
! 40050: int n_code;
! 40051:
! 40052: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40053: mem_base = xmlMemBlocks();
! 40054: code = gen_int(n_code, 0);
! 40055:
! 40056: ret_val = xmlUCSIsHangulSyllables(code);
! 40057: desret_int(ret_val);
! 40058: call_tests++;
! 40059: des_int(n_code, code, 0);
! 40060: xmlResetLastError();
! 40061: if (mem_base != xmlMemBlocks()) {
! 40062: printf("Leak of %d blocks found in xmlUCSIsHangulSyllables",
! 40063: xmlMemBlocks() - mem_base);
! 40064: test_ret++;
! 40065: printf(" %d", n_code);
! 40066: printf("\n");
! 40067: }
! 40068: }
! 40069: function_tests++;
! 40070: #endif
! 40071:
! 40072: return(test_ret);
! 40073: }
! 40074:
! 40075:
! 40076: static int
! 40077: test_xmlUCSIsHanunoo(void) {
! 40078: int test_ret = 0;
! 40079:
! 40080: #if defined(LIBXML_UNICODE_ENABLED)
! 40081: int mem_base;
! 40082: int ret_val;
! 40083: int code; /* UCS code point */
! 40084: int n_code;
! 40085:
! 40086: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40087: mem_base = xmlMemBlocks();
! 40088: code = gen_int(n_code, 0);
! 40089:
! 40090: ret_val = xmlUCSIsHanunoo(code);
! 40091: desret_int(ret_val);
! 40092: call_tests++;
! 40093: des_int(n_code, code, 0);
! 40094: xmlResetLastError();
! 40095: if (mem_base != xmlMemBlocks()) {
! 40096: printf("Leak of %d blocks found in xmlUCSIsHanunoo",
! 40097: xmlMemBlocks() - mem_base);
! 40098: test_ret++;
! 40099: printf(" %d", n_code);
! 40100: printf("\n");
! 40101: }
! 40102: }
! 40103: function_tests++;
! 40104: #endif
! 40105:
! 40106: return(test_ret);
! 40107: }
! 40108:
! 40109:
! 40110: static int
! 40111: test_xmlUCSIsHebrew(void) {
! 40112: int test_ret = 0;
! 40113:
! 40114: #if defined(LIBXML_UNICODE_ENABLED)
! 40115: int mem_base;
! 40116: int ret_val;
! 40117: int code; /* UCS code point */
! 40118: int n_code;
! 40119:
! 40120: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40121: mem_base = xmlMemBlocks();
! 40122: code = gen_int(n_code, 0);
! 40123:
! 40124: ret_val = xmlUCSIsHebrew(code);
! 40125: desret_int(ret_val);
! 40126: call_tests++;
! 40127: des_int(n_code, code, 0);
! 40128: xmlResetLastError();
! 40129: if (mem_base != xmlMemBlocks()) {
! 40130: printf("Leak of %d blocks found in xmlUCSIsHebrew",
! 40131: xmlMemBlocks() - mem_base);
! 40132: test_ret++;
! 40133: printf(" %d", n_code);
! 40134: printf("\n");
! 40135: }
! 40136: }
! 40137: function_tests++;
! 40138: #endif
! 40139:
! 40140: return(test_ret);
! 40141: }
! 40142:
! 40143:
! 40144: static int
! 40145: test_xmlUCSIsHighPrivateUseSurrogates(void) {
! 40146: int test_ret = 0;
! 40147:
! 40148: #if defined(LIBXML_UNICODE_ENABLED)
! 40149: int mem_base;
! 40150: int ret_val;
! 40151: int code; /* UCS code point */
! 40152: int n_code;
! 40153:
! 40154: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40155: mem_base = xmlMemBlocks();
! 40156: code = gen_int(n_code, 0);
! 40157:
! 40158: ret_val = xmlUCSIsHighPrivateUseSurrogates(code);
! 40159: desret_int(ret_val);
! 40160: call_tests++;
! 40161: des_int(n_code, code, 0);
! 40162: xmlResetLastError();
! 40163: if (mem_base != xmlMemBlocks()) {
! 40164: printf("Leak of %d blocks found in xmlUCSIsHighPrivateUseSurrogates",
! 40165: xmlMemBlocks() - mem_base);
! 40166: test_ret++;
! 40167: printf(" %d", n_code);
! 40168: printf("\n");
! 40169: }
! 40170: }
! 40171: function_tests++;
! 40172: #endif
! 40173:
! 40174: return(test_ret);
! 40175: }
! 40176:
! 40177:
! 40178: static int
! 40179: test_xmlUCSIsHighSurrogates(void) {
! 40180: int test_ret = 0;
! 40181:
! 40182: #if defined(LIBXML_UNICODE_ENABLED)
! 40183: int mem_base;
! 40184: int ret_val;
! 40185: int code; /* UCS code point */
! 40186: int n_code;
! 40187:
! 40188: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40189: mem_base = xmlMemBlocks();
! 40190: code = gen_int(n_code, 0);
! 40191:
! 40192: ret_val = xmlUCSIsHighSurrogates(code);
! 40193: desret_int(ret_val);
! 40194: call_tests++;
! 40195: des_int(n_code, code, 0);
! 40196: xmlResetLastError();
! 40197: if (mem_base != xmlMemBlocks()) {
! 40198: printf("Leak of %d blocks found in xmlUCSIsHighSurrogates",
! 40199: xmlMemBlocks() - mem_base);
! 40200: test_ret++;
! 40201: printf(" %d", n_code);
! 40202: printf("\n");
! 40203: }
! 40204: }
! 40205: function_tests++;
! 40206: #endif
! 40207:
! 40208: return(test_ret);
! 40209: }
! 40210:
! 40211:
! 40212: static int
! 40213: test_xmlUCSIsHiragana(void) {
! 40214: int test_ret = 0;
! 40215:
! 40216: #if defined(LIBXML_UNICODE_ENABLED)
! 40217: int mem_base;
! 40218: int ret_val;
! 40219: int code; /* UCS code point */
! 40220: int n_code;
! 40221:
! 40222: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40223: mem_base = xmlMemBlocks();
! 40224: code = gen_int(n_code, 0);
! 40225:
! 40226: ret_val = xmlUCSIsHiragana(code);
! 40227: desret_int(ret_val);
! 40228: call_tests++;
! 40229: des_int(n_code, code, 0);
! 40230: xmlResetLastError();
! 40231: if (mem_base != xmlMemBlocks()) {
! 40232: printf("Leak of %d blocks found in xmlUCSIsHiragana",
! 40233: xmlMemBlocks() - mem_base);
! 40234: test_ret++;
! 40235: printf(" %d", n_code);
! 40236: printf("\n");
! 40237: }
! 40238: }
! 40239: function_tests++;
! 40240: #endif
! 40241:
! 40242: return(test_ret);
! 40243: }
! 40244:
! 40245:
! 40246: static int
! 40247: test_xmlUCSIsIPAExtensions(void) {
! 40248: int test_ret = 0;
! 40249:
! 40250: #if defined(LIBXML_UNICODE_ENABLED)
! 40251: int mem_base;
! 40252: int ret_val;
! 40253: int code; /* UCS code point */
! 40254: int n_code;
! 40255:
! 40256: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40257: mem_base = xmlMemBlocks();
! 40258: code = gen_int(n_code, 0);
! 40259:
! 40260: ret_val = xmlUCSIsIPAExtensions(code);
! 40261: desret_int(ret_val);
! 40262: call_tests++;
! 40263: des_int(n_code, code, 0);
! 40264: xmlResetLastError();
! 40265: if (mem_base != xmlMemBlocks()) {
! 40266: printf("Leak of %d blocks found in xmlUCSIsIPAExtensions",
! 40267: xmlMemBlocks() - mem_base);
! 40268: test_ret++;
! 40269: printf(" %d", n_code);
! 40270: printf("\n");
! 40271: }
! 40272: }
! 40273: function_tests++;
! 40274: #endif
! 40275:
! 40276: return(test_ret);
! 40277: }
! 40278:
! 40279:
! 40280: static int
! 40281: test_xmlUCSIsIdeographicDescriptionCharacters(void) {
! 40282: int test_ret = 0;
! 40283:
! 40284: #if defined(LIBXML_UNICODE_ENABLED)
! 40285: int mem_base;
! 40286: int ret_val;
! 40287: int code; /* UCS code point */
! 40288: int n_code;
! 40289:
! 40290: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40291: mem_base = xmlMemBlocks();
! 40292: code = gen_int(n_code, 0);
! 40293:
! 40294: ret_val = xmlUCSIsIdeographicDescriptionCharacters(code);
! 40295: desret_int(ret_val);
! 40296: call_tests++;
! 40297: des_int(n_code, code, 0);
! 40298: xmlResetLastError();
! 40299: if (mem_base != xmlMemBlocks()) {
! 40300: printf("Leak of %d blocks found in xmlUCSIsIdeographicDescriptionCharacters",
! 40301: xmlMemBlocks() - mem_base);
! 40302: test_ret++;
! 40303: printf(" %d", n_code);
! 40304: printf("\n");
! 40305: }
! 40306: }
! 40307: function_tests++;
! 40308: #endif
! 40309:
! 40310: return(test_ret);
! 40311: }
! 40312:
! 40313:
! 40314: static int
! 40315: test_xmlUCSIsKanbun(void) {
! 40316: int test_ret = 0;
! 40317:
! 40318: #if defined(LIBXML_UNICODE_ENABLED)
! 40319: int mem_base;
! 40320: int ret_val;
! 40321: int code; /* UCS code point */
! 40322: int n_code;
! 40323:
! 40324: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40325: mem_base = xmlMemBlocks();
! 40326: code = gen_int(n_code, 0);
! 40327:
! 40328: ret_val = xmlUCSIsKanbun(code);
! 40329: desret_int(ret_val);
! 40330: call_tests++;
! 40331: des_int(n_code, code, 0);
! 40332: xmlResetLastError();
! 40333: if (mem_base != xmlMemBlocks()) {
! 40334: printf("Leak of %d blocks found in xmlUCSIsKanbun",
! 40335: xmlMemBlocks() - mem_base);
! 40336: test_ret++;
! 40337: printf(" %d", n_code);
! 40338: printf("\n");
! 40339: }
! 40340: }
! 40341: function_tests++;
! 40342: #endif
! 40343:
! 40344: return(test_ret);
! 40345: }
! 40346:
! 40347:
! 40348: static int
! 40349: test_xmlUCSIsKangxiRadicals(void) {
! 40350: int test_ret = 0;
! 40351:
! 40352: #if defined(LIBXML_UNICODE_ENABLED)
! 40353: int mem_base;
! 40354: int ret_val;
! 40355: int code; /* UCS code point */
! 40356: int n_code;
! 40357:
! 40358: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40359: mem_base = xmlMemBlocks();
! 40360: code = gen_int(n_code, 0);
! 40361:
! 40362: ret_val = xmlUCSIsKangxiRadicals(code);
! 40363: desret_int(ret_val);
! 40364: call_tests++;
! 40365: des_int(n_code, code, 0);
! 40366: xmlResetLastError();
! 40367: if (mem_base != xmlMemBlocks()) {
! 40368: printf("Leak of %d blocks found in xmlUCSIsKangxiRadicals",
! 40369: xmlMemBlocks() - mem_base);
! 40370: test_ret++;
! 40371: printf(" %d", n_code);
! 40372: printf("\n");
! 40373: }
! 40374: }
! 40375: function_tests++;
! 40376: #endif
! 40377:
! 40378: return(test_ret);
! 40379: }
! 40380:
! 40381:
! 40382: static int
! 40383: test_xmlUCSIsKannada(void) {
! 40384: int test_ret = 0;
! 40385:
! 40386: #if defined(LIBXML_UNICODE_ENABLED)
! 40387: int mem_base;
! 40388: int ret_val;
! 40389: int code; /* UCS code point */
! 40390: int n_code;
! 40391:
! 40392: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40393: mem_base = xmlMemBlocks();
! 40394: code = gen_int(n_code, 0);
! 40395:
! 40396: ret_val = xmlUCSIsKannada(code);
! 40397: desret_int(ret_val);
! 40398: call_tests++;
! 40399: des_int(n_code, code, 0);
! 40400: xmlResetLastError();
! 40401: if (mem_base != xmlMemBlocks()) {
! 40402: printf("Leak of %d blocks found in xmlUCSIsKannada",
! 40403: xmlMemBlocks() - mem_base);
! 40404: test_ret++;
! 40405: printf(" %d", n_code);
! 40406: printf("\n");
! 40407: }
! 40408: }
! 40409: function_tests++;
! 40410: #endif
! 40411:
! 40412: return(test_ret);
! 40413: }
! 40414:
! 40415:
! 40416: static int
! 40417: test_xmlUCSIsKatakana(void) {
! 40418: int test_ret = 0;
! 40419:
! 40420: #if defined(LIBXML_UNICODE_ENABLED)
! 40421: int mem_base;
! 40422: int ret_val;
! 40423: int code; /* UCS code point */
! 40424: int n_code;
! 40425:
! 40426: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40427: mem_base = xmlMemBlocks();
! 40428: code = gen_int(n_code, 0);
! 40429:
! 40430: ret_val = xmlUCSIsKatakana(code);
! 40431: desret_int(ret_val);
! 40432: call_tests++;
! 40433: des_int(n_code, code, 0);
! 40434: xmlResetLastError();
! 40435: if (mem_base != xmlMemBlocks()) {
! 40436: printf("Leak of %d blocks found in xmlUCSIsKatakana",
! 40437: xmlMemBlocks() - mem_base);
! 40438: test_ret++;
! 40439: printf(" %d", n_code);
! 40440: printf("\n");
! 40441: }
! 40442: }
! 40443: function_tests++;
! 40444: #endif
! 40445:
! 40446: return(test_ret);
! 40447: }
! 40448:
! 40449:
! 40450: static int
! 40451: test_xmlUCSIsKatakanaPhoneticExtensions(void) {
! 40452: int test_ret = 0;
! 40453:
! 40454: #if defined(LIBXML_UNICODE_ENABLED)
! 40455: int mem_base;
! 40456: int ret_val;
! 40457: int code; /* UCS code point */
! 40458: int n_code;
! 40459:
! 40460: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40461: mem_base = xmlMemBlocks();
! 40462: code = gen_int(n_code, 0);
! 40463:
! 40464: ret_val = xmlUCSIsKatakanaPhoneticExtensions(code);
! 40465: desret_int(ret_val);
! 40466: call_tests++;
! 40467: des_int(n_code, code, 0);
! 40468: xmlResetLastError();
! 40469: if (mem_base != xmlMemBlocks()) {
! 40470: printf("Leak of %d blocks found in xmlUCSIsKatakanaPhoneticExtensions",
! 40471: xmlMemBlocks() - mem_base);
! 40472: test_ret++;
! 40473: printf(" %d", n_code);
! 40474: printf("\n");
! 40475: }
! 40476: }
! 40477: function_tests++;
! 40478: #endif
! 40479:
! 40480: return(test_ret);
! 40481: }
! 40482:
! 40483:
! 40484: static int
! 40485: test_xmlUCSIsKhmer(void) {
! 40486: int test_ret = 0;
! 40487:
! 40488: #if defined(LIBXML_UNICODE_ENABLED)
! 40489: int mem_base;
! 40490: int ret_val;
! 40491: int code; /* UCS code point */
! 40492: int n_code;
! 40493:
! 40494: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40495: mem_base = xmlMemBlocks();
! 40496: code = gen_int(n_code, 0);
! 40497:
! 40498: ret_val = xmlUCSIsKhmer(code);
! 40499: desret_int(ret_val);
! 40500: call_tests++;
! 40501: des_int(n_code, code, 0);
! 40502: xmlResetLastError();
! 40503: if (mem_base != xmlMemBlocks()) {
! 40504: printf("Leak of %d blocks found in xmlUCSIsKhmer",
! 40505: xmlMemBlocks() - mem_base);
! 40506: test_ret++;
! 40507: printf(" %d", n_code);
! 40508: printf("\n");
! 40509: }
! 40510: }
! 40511: function_tests++;
! 40512: #endif
! 40513:
! 40514: return(test_ret);
! 40515: }
! 40516:
! 40517:
! 40518: static int
! 40519: test_xmlUCSIsKhmerSymbols(void) {
! 40520: int test_ret = 0;
! 40521:
! 40522: #if defined(LIBXML_UNICODE_ENABLED)
! 40523: int mem_base;
! 40524: int ret_val;
! 40525: int code; /* UCS code point */
! 40526: int n_code;
! 40527:
! 40528: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40529: mem_base = xmlMemBlocks();
! 40530: code = gen_int(n_code, 0);
! 40531:
! 40532: ret_val = xmlUCSIsKhmerSymbols(code);
! 40533: desret_int(ret_val);
! 40534: call_tests++;
! 40535: des_int(n_code, code, 0);
! 40536: xmlResetLastError();
! 40537: if (mem_base != xmlMemBlocks()) {
! 40538: printf("Leak of %d blocks found in xmlUCSIsKhmerSymbols",
! 40539: xmlMemBlocks() - mem_base);
! 40540: test_ret++;
! 40541: printf(" %d", n_code);
! 40542: printf("\n");
! 40543: }
! 40544: }
! 40545: function_tests++;
! 40546: #endif
! 40547:
! 40548: return(test_ret);
! 40549: }
! 40550:
! 40551:
! 40552: static int
! 40553: test_xmlUCSIsLao(void) {
! 40554: int test_ret = 0;
! 40555:
! 40556: #if defined(LIBXML_UNICODE_ENABLED)
! 40557: int mem_base;
! 40558: int ret_val;
! 40559: int code; /* UCS code point */
! 40560: int n_code;
! 40561:
! 40562: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40563: mem_base = xmlMemBlocks();
! 40564: code = gen_int(n_code, 0);
! 40565:
! 40566: ret_val = xmlUCSIsLao(code);
! 40567: desret_int(ret_val);
! 40568: call_tests++;
! 40569: des_int(n_code, code, 0);
! 40570: xmlResetLastError();
! 40571: if (mem_base != xmlMemBlocks()) {
! 40572: printf("Leak of %d blocks found in xmlUCSIsLao",
! 40573: xmlMemBlocks() - mem_base);
! 40574: test_ret++;
! 40575: printf(" %d", n_code);
! 40576: printf("\n");
! 40577: }
! 40578: }
! 40579: function_tests++;
! 40580: #endif
! 40581:
! 40582: return(test_ret);
! 40583: }
! 40584:
! 40585:
! 40586: static int
! 40587: test_xmlUCSIsLatin1Supplement(void) {
! 40588: int test_ret = 0;
! 40589:
! 40590: #if defined(LIBXML_UNICODE_ENABLED)
! 40591: int mem_base;
! 40592: int ret_val;
! 40593: int code; /* UCS code point */
! 40594: int n_code;
! 40595:
! 40596: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40597: mem_base = xmlMemBlocks();
! 40598: code = gen_int(n_code, 0);
! 40599:
! 40600: ret_val = xmlUCSIsLatin1Supplement(code);
! 40601: desret_int(ret_val);
! 40602: call_tests++;
! 40603: des_int(n_code, code, 0);
! 40604: xmlResetLastError();
! 40605: if (mem_base != xmlMemBlocks()) {
! 40606: printf("Leak of %d blocks found in xmlUCSIsLatin1Supplement",
! 40607: xmlMemBlocks() - mem_base);
! 40608: test_ret++;
! 40609: printf(" %d", n_code);
! 40610: printf("\n");
! 40611: }
! 40612: }
! 40613: function_tests++;
! 40614: #endif
! 40615:
! 40616: return(test_ret);
! 40617: }
! 40618:
! 40619:
! 40620: static int
! 40621: test_xmlUCSIsLatinExtendedA(void) {
! 40622: int test_ret = 0;
! 40623:
! 40624: #if defined(LIBXML_UNICODE_ENABLED)
! 40625: int mem_base;
! 40626: int ret_val;
! 40627: int code; /* UCS code point */
! 40628: int n_code;
! 40629:
! 40630: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40631: mem_base = xmlMemBlocks();
! 40632: code = gen_int(n_code, 0);
! 40633:
! 40634: ret_val = xmlUCSIsLatinExtendedA(code);
! 40635: desret_int(ret_val);
! 40636: call_tests++;
! 40637: des_int(n_code, code, 0);
! 40638: xmlResetLastError();
! 40639: if (mem_base != xmlMemBlocks()) {
! 40640: printf("Leak of %d blocks found in xmlUCSIsLatinExtendedA",
! 40641: xmlMemBlocks() - mem_base);
! 40642: test_ret++;
! 40643: printf(" %d", n_code);
! 40644: printf("\n");
! 40645: }
! 40646: }
! 40647: function_tests++;
! 40648: #endif
! 40649:
! 40650: return(test_ret);
! 40651: }
! 40652:
! 40653:
! 40654: static int
! 40655: test_xmlUCSIsLatinExtendedAdditional(void) {
! 40656: int test_ret = 0;
! 40657:
! 40658: #if defined(LIBXML_UNICODE_ENABLED)
! 40659: int mem_base;
! 40660: int ret_val;
! 40661: int code; /* UCS code point */
! 40662: int n_code;
! 40663:
! 40664: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40665: mem_base = xmlMemBlocks();
! 40666: code = gen_int(n_code, 0);
! 40667:
! 40668: ret_val = xmlUCSIsLatinExtendedAdditional(code);
! 40669: desret_int(ret_val);
! 40670: call_tests++;
! 40671: des_int(n_code, code, 0);
! 40672: xmlResetLastError();
! 40673: if (mem_base != xmlMemBlocks()) {
! 40674: printf("Leak of %d blocks found in xmlUCSIsLatinExtendedAdditional",
! 40675: xmlMemBlocks() - mem_base);
! 40676: test_ret++;
! 40677: printf(" %d", n_code);
! 40678: printf("\n");
! 40679: }
! 40680: }
! 40681: function_tests++;
! 40682: #endif
! 40683:
! 40684: return(test_ret);
! 40685: }
! 40686:
! 40687:
! 40688: static int
! 40689: test_xmlUCSIsLatinExtendedB(void) {
! 40690: int test_ret = 0;
! 40691:
! 40692: #if defined(LIBXML_UNICODE_ENABLED)
! 40693: int mem_base;
! 40694: int ret_val;
! 40695: int code; /* UCS code point */
! 40696: int n_code;
! 40697:
! 40698: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40699: mem_base = xmlMemBlocks();
! 40700: code = gen_int(n_code, 0);
! 40701:
! 40702: ret_val = xmlUCSIsLatinExtendedB(code);
! 40703: desret_int(ret_val);
! 40704: call_tests++;
! 40705: des_int(n_code, code, 0);
! 40706: xmlResetLastError();
! 40707: if (mem_base != xmlMemBlocks()) {
! 40708: printf("Leak of %d blocks found in xmlUCSIsLatinExtendedB",
! 40709: xmlMemBlocks() - mem_base);
! 40710: test_ret++;
! 40711: printf(" %d", n_code);
! 40712: printf("\n");
! 40713: }
! 40714: }
! 40715: function_tests++;
! 40716: #endif
! 40717:
! 40718: return(test_ret);
! 40719: }
! 40720:
! 40721:
! 40722: static int
! 40723: test_xmlUCSIsLetterlikeSymbols(void) {
! 40724: int test_ret = 0;
! 40725:
! 40726: #if defined(LIBXML_UNICODE_ENABLED)
! 40727: int mem_base;
! 40728: int ret_val;
! 40729: int code; /* UCS code point */
! 40730: int n_code;
! 40731:
! 40732: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40733: mem_base = xmlMemBlocks();
! 40734: code = gen_int(n_code, 0);
! 40735:
! 40736: ret_val = xmlUCSIsLetterlikeSymbols(code);
! 40737: desret_int(ret_val);
! 40738: call_tests++;
! 40739: des_int(n_code, code, 0);
! 40740: xmlResetLastError();
! 40741: if (mem_base != xmlMemBlocks()) {
! 40742: printf("Leak of %d blocks found in xmlUCSIsLetterlikeSymbols",
! 40743: xmlMemBlocks() - mem_base);
! 40744: test_ret++;
! 40745: printf(" %d", n_code);
! 40746: printf("\n");
! 40747: }
! 40748: }
! 40749: function_tests++;
! 40750: #endif
! 40751:
! 40752: return(test_ret);
! 40753: }
! 40754:
! 40755:
! 40756: static int
! 40757: test_xmlUCSIsLimbu(void) {
! 40758: int test_ret = 0;
! 40759:
! 40760: #if defined(LIBXML_UNICODE_ENABLED)
! 40761: int mem_base;
! 40762: int ret_val;
! 40763: int code; /* UCS code point */
! 40764: int n_code;
! 40765:
! 40766: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40767: mem_base = xmlMemBlocks();
! 40768: code = gen_int(n_code, 0);
! 40769:
! 40770: ret_val = xmlUCSIsLimbu(code);
! 40771: desret_int(ret_val);
! 40772: call_tests++;
! 40773: des_int(n_code, code, 0);
! 40774: xmlResetLastError();
! 40775: if (mem_base != xmlMemBlocks()) {
! 40776: printf("Leak of %d blocks found in xmlUCSIsLimbu",
! 40777: xmlMemBlocks() - mem_base);
! 40778: test_ret++;
! 40779: printf(" %d", n_code);
! 40780: printf("\n");
! 40781: }
! 40782: }
! 40783: function_tests++;
! 40784: #endif
! 40785:
! 40786: return(test_ret);
! 40787: }
! 40788:
! 40789:
! 40790: static int
! 40791: test_xmlUCSIsLinearBIdeograms(void) {
! 40792: int test_ret = 0;
! 40793:
! 40794: #if defined(LIBXML_UNICODE_ENABLED)
! 40795: int mem_base;
! 40796: int ret_val;
! 40797: int code; /* UCS code point */
! 40798: int n_code;
! 40799:
! 40800: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40801: mem_base = xmlMemBlocks();
! 40802: code = gen_int(n_code, 0);
! 40803:
! 40804: ret_val = xmlUCSIsLinearBIdeograms(code);
! 40805: desret_int(ret_val);
! 40806: call_tests++;
! 40807: des_int(n_code, code, 0);
! 40808: xmlResetLastError();
! 40809: if (mem_base != xmlMemBlocks()) {
! 40810: printf("Leak of %d blocks found in xmlUCSIsLinearBIdeograms",
! 40811: xmlMemBlocks() - mem_base);
! 40812: test_ret++;
! 40813: printf(" %d", n_code);
! 40814: printf("\n");
! 40815: }
! 40816: }
! 40817: function_tests++;
! 40818: #endif
! 40819:
! 40820: return(test_ret);
! 40821: }
! 40822:
! 40823:
! 40824: static int
! 40825: test_xmlUCSIsLinearBSyllabary(void) {
! 40826: int test_ret = 0;
! 40827:
! 40828: #if defined(LIBXML_UNICODE_ENABLED)
! 40829: int mem_base;
! 40830: int ret_val;
! 40831: int code; /* UCS code point */
! 40832: int n_code;
! 40833:
! 40834: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40835: mem_base = xmlMemBlocks();
! 40836: code = gen_int(n_code, 0);
! 40837:
! 40838: ret_val = xmlUCSIsLinearBSyllabary(code);
! 40839: desret_int(ret_val);
! 40840: call_tests++;
! 40841: des_int(n_code, code, 0);
! 40842: xmlResetLastError();
! 40843: if (mem_base != xmlMemBlocks()) {
! 40844: printf("Leak of %d blocks found in xmlUCSIsLinearBSyllabary",
! 40845: xmlMemBlocks() - mem_base);
! 40846: test_ret++;
! 40847: printf(" %d", n_code);
! 40848: printf("\n");
! 40849: }
! 40850: }
! 40851: function_tests++;
! 40852: #endif
! 40853:
! 40854: return(test_ret);
! 40855: }
! 40856:
! 40857:
! 40858: static int
! 40859: test_xmlUCSIsLowSurrogates(void) {
! 40860: int test_ret = 0;
! 40861:
! 40862: #if defined(LIBXML_UNICODE_ENABLED)
! 40863: int mem_base;
! 40864: int ret_val;
! 40865: int code; /* UCS code point */
! 40866: int n_code;
! 40867:
! 40868: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40869: mem_base = xmlMemBlocks();
! 40870: code = gen_int(n_code, 0);
! 40871:
! 40872: ret_val = xmlUCSIsLowSurrogates(code);
! 40873: desret_int(ret_val);
! 40874: call_tests++;
! 40875: des_int(n_code, code, 0);
! 40876: xmlResetLastError();
! 40877: if (mem_base != xmlMemBlocks()) {
! 40878: printf("Leak of %d blocks found in xmlUCSIsLowSurrogates",
! 40879: xmlMemBlocks() - mem_base);
! 40880: test_ret++;
! 40881: printf(" %d", n_code);
! 40882: printf("\n");
! 40883: }
! 40884: }
! 40885: function_tests++;
! 40886: #endif
! 40887:
! 40888: return(test_ret);
! 40889: }
! 40890:
! 40891:
! 40892: static int
! 40893: test_xmlUCSIsMalayalam(void) {
! 40894: int test_ret = 0;
! 40895:
! 40896: #if defined(LIBXML_UNICODE_ENABLED)
! 40897: int mem_base;
! 40898: int ret_val;
! 40899: int code; /* UCS code point */
! 40900: int n_code;
! 40901:
! 40902: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40903: mem_base = xmlMemBlocks();
! 40904: code = gen_int(n_code, 0);
! 40905:
! 40906: ret_val = xmlUCSIsMalayalam(code);
! 40907: desret_int(ret_val);
! 40908: call_tests++;
! 40909: des_int(n_code, code, 0);
! 40910: xmlResetLastError();
! 40911: if (mem_base != xmlMemBlocks()) {
! 40912: printf("Leak of %d blocks found in xmlUCSIsMalayalam",
! 40913: xmlMemBlocks() - mem_base);
! 40914: test_ret++;
! 40915: printf(" %d", n_code);
! 40916: printf("\n");
! 40917: }
! 40918: }
! 40919: function_tests++;
! 40920: #endif
! 40921:
! 40922: return(test_ret);
! 40923: }
! 40924:
! 40925:
! 40926: static int
! 40927: test_xmlUCSIsMathematicalAlphanumericSymbols(void) {
! 40928: int test_ret = 0;
! 40929:
! 40930: #if defined(LIBXML_UNICODE_ENABLED)
! 40931: int mem_base;
! 40932: int ret_val;
! 40933: int code; /* UCS code point */
! 40934: int n_code;
! 40935:
! 40936: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40937: mem_base = xmlMemBlocks();
! 40938: code = gen_int(n_code, 0);
! 40939:
! 40940: ret_val = xmlUCSIsMathematicalAlphanumericSymbols(code);
! 40941: desret_int(ret_val);
! 40942: call_tests++;
! 40943: des_int(n_code, code, 0);
! 40944: xmlResetLastError();
! 40945: if (mem_base != xmlMemBlocks()) {
! 40946: printf("Leak of %d blocks found in xmlUCSIsMathematicalAlphanumericSymbols",
! 40947: xmlMemBlocks() - mem_base);
! 40948: test_ret++;
! 40949: printf(" %d", n_code);
! 40950: printf("\n");
! 40951: }
! 40952: }
! 40953: function_tests++;
! 40954: #endif
! 40955:
! 40956: return(test_ret);
! 40957: }
! 40958:
! 40959:
! 40960: static int
! 40961: test_xmlUCSIsMathematicalOperators(void) {
! 40962: int test_ret = 0;
! 40963:
! 40964: #if defined(LIBXML_UNICODE_ENABLED)
! 40965: int mem_base;
! 40966: int ret_val;
! 40967: int code; /* UCS code point */
! 40968: int n_code;
! 40969:
! 40970: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 40971: mem_base = xmlMemBlocks();
! 40972: code = gen_int(n_code, 0);
! 40973:
! 40974: ret_val = xmlUCSIsMathematicalOperators(code);
! 40975: desret_int(ret_val);
! 40976: call_tests++;
! 40977: des_int(n_code, code, 0);
! 40978: xmlResetLastError();
! 40979: if (mem_base != xmlMemBlocks()) {
! 40980: printf("Leak of %d blocks found in xmlUCSIsMathematicalOperators",
! 40981: xmlMemBlocks() - mem_base);
! 40982: test_ret++;
! 40983: printf(" %d", n_code);
! 40984: printf("\n");
! 40985: }
! 40986: }
! 40987: function_tests++;
! 40988: #endif
! 40989:
! 40990: return(test_ret);
! 40991: }
! 40992:
! 40993:
! 40994: static int
! 40995: test_xmlUCSIsMiscellaneousMathematicalSymbolsA(void) {
! 40996: int test_ret = 0;
! 40997:
! 40998: #if defined(LIBXML_UNICODE_ENABLED)
! 40999: int mem_base;
! 41000: int ret_val;
! 41001: int code; /* UCS code point */
! 41002: int n_code;
! 41003:
! 41004: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41005: mem_base = xmlMemBlocks();
! 41006: code = gen_int(n_code, 0);
! 41007:
! 41008: ret_val = xmlUCSIsMiscellaneousMathematicalSymbolsA(code);
! 41009: desret_int(ret_val);
! 41010: call_tests++;
! 41011: des_int(n_code, code, 0);
! 41012: xmlResetLastError();
! 41013: if (mem_base != xmlMemBlocks()) {
! 41014: printf("Leak of %d blocks found in xmlUCSIsMiscellaneousMathematicalSymbolsA",
! 41015: xmlMemBlocks() - mem_base);
! 41016: test_ret++;
! 41017: printf(" %d", n_code);
! 41018: printf("\n");
! 41019: }
! 41020: }
! 41021: function_tests++;
! 41022: #endif
! 41023:
! 41024: return(test_ret);
! 41025: }
! 41026:
! 41027:
! 41028: static int
! 41029: test_xmlUCSIsMiscellaneousMathematicalSymbolsB(void) {
! 41030: int test_ret = 0;
! 41031:
! 41032: #if defined(LIBXML_UNICODE_ENABLED)
! 41033: int mem_base;
! 41034: int ret_val;
! 41035: int code; /* UCS code point */
! 41036: int n_code;
! 41037:
! 41038: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41039: mem_base = xmlMemBlocks();
! 41040: code = gen_int(n_code, 0);
! 41041:
! 41042: ret_val = xmlUCSIsMiscellaneousMathematicalSymbolsB(code);
! 41043: desret_int(ret_val);
! 41044: call_tests++;
! 41045: des_int(n_code, code, 0);
! 41046: xmlResetLastError();
! 41047: if (mem_base != xmlMemBlocks()) {
! 41048: printf("Leak of %d blocks found in xmlUCSIsMiscellaneousMathematicalSymbolsB",
! 41049: xmlMemBlocks() - mem_base);
! 41050: test_ret++;
! 41051: printf(" %d", n_code);
! 41052: printf("\n");
! 41053: }
! 41054: }
! 41055: function_tests++;
! 41056: #endif
! 41057:
! 41058: return(test_ret);
! 41059: }
! 41060:
! 41061:
! 41062: static int
! 41063: test_xmlUCSIsMiscellaneousSymbols(void) {
! 41064: int test_ret = 0;
! 41065:
! 41066: #if defined(LIBXML_UNICODE_ENABLED)
! 41067: int mem_base;
! 41068: int ret_val;
! 41069: int code; /* UCS code point */
! 41070: int n_code;
! 41071:
! 41072: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41073: mem_base = xmlMemBlocks();
! 41074: code = gen_int(n_code, 0);
! 41075:
! 41076: ret_val = xmlUCSIsMiscellaneousSymbols(code);
! 41077: desret_int(ret_val);
! 41078: call_tests++;
! 41079: des_int(n_code, code, 0);
! 41080: xmlResetLastError();
! 41081: if (mem_base != xmlMemBlocks()) {
! 41082: printf("Leak of %d blocks found in xmlUCSIsMiscellaneousSymbols",
! 41083: xmlMemBlocks() - mem_base);
! 41084: test_ret++;
! 41085: printf(" %d", n_code);
! 41086: printf("\n");
! 41087: }
! 41088: }
! 41089: function_tests++;
! 41090: #endif
! 41091:
! 41092: return(test_ret);
! 41093: }
! 41094:
! 41095:
! 41096: static int
! 41097: test_xmlUCSIsMiscellaneousSymbolsandArrows(void) {
! 41098: int test_ret = 0;
! 41099:
! 41100: #if defined(LIBXML_UNICODE_ENABLED)
! 41101: int mem_base;
! 41102: int ret_val;
! 41103: int code; /* UCS code point */
! 41104: int n_code;
! 41105:
! 41106: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41107: mem_base = xmlMemBlocks();
! 41108: code = gen_int(n_code, 0);
! 41109:
! 41110: ret_val = xmlUCSIsMiscellaneousSymbolsandArrows(code);
! 41111: desret_int(ret_val);
! 41112: call_tests++;
! 41113: des_int(n_code, code, 0);
! 41114: xmlResetLastError();
! 41115: if (mem_base != xmlMemBlocks()) {
! 41116: printf("Leak of %d blocks found in xmlUCSIsMiscellaneousSymbolsandArrows",
! 41117: xmlMemBlocks() - mem_base);
! 41118: test_ret++;
! 41119: printf(" %d", n_code);
! 41120: printf("\n");
! 41121: }
! 41122: }
! 41123: function_tests++;
! 41124: #endif
! 41125:
! 41126: return(test_ret);
! 41127: }
! 41128:
! 41129:
! 41130: static int
! 41131: test_xmlUCSIsMiscellaneousTechnical(void) {
! 41132: int test_ret = 0;
! 41133:
! 41134: #if defined(LIBXML_UNICODE_ENABLED)
! 41135: int mem_base;
! 41136: int ret_val;
! 41137: int code; /* UCS code point */
! 41138: int n_code;
! 41139:
! 41140: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41141: mem_base = xmlMemBlocks();
! 41142: code = gen_int(n_code, 0);
! 41143:
! 41144: ret_val = xmlUCSIsMiscellaneousTechnical(code);
! 41145: desret_int(ret_val);
! 41146: call_tests++;
! 41147: des_int(n_code, code, 0);
! 41148: xmlResetLastError();
! 41149: if (mem_base != xmlMemBlocks()) {
! 41150: printf("Leak of %d blocks found in xmlUCSIsMiscellaneousTechnical",
! 41151: xmlMemBlocks() - mem_base);
! 41152: test_ret++;
! 41153: printf(" %d", n_code);
! 41154: printf("\n");
! 41155: }
! 41156: }
! 41157: function_tests++;
! 41158: #endif
! 41159:
! 41160: return(test_ret);
! 41161: }
! 41162:
! 41163:
! 41164: static int
! 41165: test_xmlUCSIsMongolian(void) {
! 41166: int test_ret = 0;
! 41167:
! 41168: #if defined(LIBXML_UNICODE_ENABLED)
! 41169: int mem_base;
! 41170: int ret_val;
! 41171: int code; /* UCS code point */
! 41172: int n_code;
! 41173:
! 41174: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41175: mem_base = xmlMemBlocks();
! 41176: code = gen_int(n_code, 0);
! 41177:
! 41178: ret_val = xmlUCSIsMongolian(code);
! 41179: desret_int(ret_val);
! 41180: call_tests++;
! 41181: des_int(n_code, code, 0);
! 41182: xmlResetLastError();
! 41183: if (mem_base != xmlMemBlocks()) {
! 41184: printf("Leak of %d blocks found in xmlUCSIsMongolian",
! 41185: xmlMemBlocks() - mem_base);
! 41186: test_ret++;
! 41187: printf(" %d", n_code);
! 41188: printf("\n");
! 41189: }
! 41190: }
! 41191: function_tests++;
! 41192: #endif
! 41193:
! 41194: return(test_ret);
! 41195: }
! 41196:
! 41197:
! 41198: static int
! 41199: test_xmlUCSIsMusicalSymbols(void) {
! 41200: int test_ret = 0;
! 41201:
! 41202: #if defined(LIBXML_UNICODE_ENABLED)
! 41203: int mem_base;
! 41204: int ret_val;
! 41205: int code; /* UCS code point */
! 41206: int n_code;
! 41207:
! 41208: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41209: mem_base = xmlMemBlocks();
! 41210: code = gen_int(n_code, 0);
! 41211:
! 41212: ret_val = xmlUCSIsMusicalSymbols(code);
! 41213: desret_int(ret_val);
! 41214: call_tests++;
! 41215: des_int(n_code, code, 0);
! 41216: xmlResetLastError();
! 41217: if (mem_base != xmlMemBlocks()) {
! 41218: printf("Leak of %d blocks found in xmlUCSIsMusicalSymbols",
! 41219: xmlMemBlocks() - mem_base);
! 41220: test_ret++;
! 41221: printf(" %d", n_code);
! 41222: printf("\n");
! 41223: }
! 41224: }
! 41225: function_tests++;
! 41226: #endif
! 41227:
! 41228: return(test_ret);
! 41229: }
! 41230:
! 41231:
! 41232: static int
! 41233: test_xmlUCSIsMyanmar(void) {
! 41234: int test_ret = 0;
! 41235:
! 41236: #if defined(LIBXML_UNICODE_ENABLED)
! 41237: int mem_base;
! 41238: int ret_val;
! 41239: int code; /* UCS code point */
! 41240: int n_code;
! 41241:
! 41242: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41243: mem_base = xmlMemBlocks();
! 41244: code = gen_int(n_code, 0);
! 41245:
! 41246: ret_val = xmlUCSIsMyanmar(code);
! 41247: desret_int(ret_val);
! 41248: call_tests++;
! 41249: des_int(n_code, code, 0);
! 41250: xmlResetLastError();
! 41251: if (mem_base != xmlMemBlocks()) {
! 41252: printf("Leak of %d blocks found in xmlUCSIsMyanmar",
! 41253: xmlMemBlocks() - mem_base);
! 41254: test_ret++;
! 41255: printf(" %d", n_code);
! 41256: printf("\n");
! 41257: }
! 41258: }
! 41259: function_tests++;
! 41260: #endif
! 41261:
! 41262: return(test_ret);
! 41263: }
! 41264:
! 41265:
! 41266: static int
! 41267: test_xmlUCSIsNumberForms(void) {
! 41268: int test_ret = 0;
! 41269:
! 41270: #if defined(LIBXML_UNICODE_ENABLED)
! 41271: int mem_base;
! 41272: int ret_val;
! 41273: int code; /* UCS code point */
! 41274: int n_code;
! 41275:
! 41276: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41277: mem_base = xmlMemBlocks();
! 41278: code = gen_int(n_code, 0);
! 41279:
! 41280: ret_val = xmlUCSIsNumberForms(code);
! 41281: desret_int(ret_val);
! 41282: call_tests++;
! 41283: des_int(n_code, code, 0);
! 41284: xmlResetLastError();
! 41285: if (mem_base != xmlMemBlocks()) {
! 41286: printf("Leak of %d blocks found in xmlUCSIsNumberForms",
! 41287: xmlMemBlocks() - mem_base);
! 41288: test_ret++;
! 41289: printf(" %d", n_code);
! 41290: printf("\n");
! 41291: }
! 41292: }
! 41293: function_tests++;
! 41294: #endif
! 41295:
! 41296: return(test_ret);
! 41297: }
! 41298:
! 41299:
! 41300: static int
! 41301: test_xmlUCSIsOgham(void) {
! 41302: int test_ret = 0;
! 41303:
! 41304: #if defined(LIBXML_UNICODE_ENABLED)
! 41305: int mem_base;
! 41306: int ret_val;
! 41307: int code; /* UCS code point */
! 41308: int n_code;
! 41309:
! 41310: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41311: mem_base = xmlMemBlocks();
! 41312: code = gen_int(n_code, 0);
! 41313:
! 41314: ret_val = xmlUCSIsOgham(code);
! 41315: desret_int(ret_val);
! 41316: call_tests++;
! 41317: des_int(n_code, code, 0);
! 41318: xmlResetLastError();
! 41319: if (mem_base != xmlMemBlocks()) {
! 41320: printf("Leak of %d blocks found in xmlUCSIsOgham",
! 41321: xmlMemBlocks() - mem_base);
! 41322: test_ret++;
! 41323: printf(" %d", n_code);
! 41324: printf("\n");
! 41325: }
! 41326: }
! 41327: function_tests++;
! 41328: #endif
! 41329:
! 41330: return(test_ret);
! 41331: }
! 41332:
! 41333:
! 41334: static int
! 41335: test_xmlUCSIsOldItalic(void) {
! 41336: int test_ret = 0;
! 41337:
! 41338: #if defined(LIBXML_UNICODE_ENABLED)
! 41339: int mem_base;
! 41340: int ret_val;
! 41341: int code; /* UCS code point */
! 41342: int n_code;
! 41343:
! 41344: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41345: mem_base = xmlMemBlocks();
! 41346: code = gen_int(n_code, 0);
! 41347:
! 41348: ret_val = xmlUCSIsOldItalic(code);
! 41349: desret_int(ret_val);
! 41350: call_tests++;
! 41351: des_int(n_code, code, 0);
! 41352: xmlResetLastError();
! 41353: if (mem_base != xmlMemBlocks()) {
! 41354: printf("Leak of %d blocks found in xmlUCSIsOldItalic",
! 41355: xmlMemBlocks() - mem_base);
! 41356: test_ret++;
! 41357: printf(" %d", n_code);
! 41358: printf("\n");
! 41359: }
! 41360: }
! 41361: function_tests++;
! 41362: #endif
! 41363:
! 41364: return(test_ret);
! 41365: }
! 41366:
! 41367:
! 41368: static int
! 41369: test_xmlUCSIsOpticalCharacterRecognition(void) {
! 41370: int test_ret = 0;
! 41371:
! 41372: #if defined(LIBXML_UNICODE_ENABLED)
! 41373: int mem_base;
! 41374: int ret_val;
! 41375: int code; /* UCS code point */
! 41376: int n_code;
! 41377:
! 41378: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41379: mem_base = xmlMemBlocks();
! 41380: code = gen_int(n_code, 0);
! 41381:
! 41382: ret_val = xmlUCSIsOpticalCharacterRecognition(code);
! 41383: desret_int(ret_val);
! 41384: call_tests++;
! 41385: des_int(n_code, code, 0);
! 41386: xmlResetLastError();
! 41387: if (mem_base != xmlMemBlocks()) {
! 41388: printf("Leak of %d blocks found in xmlUCSIsOpticalCharacterRecognition",
! 41389: xmlMemBlocks() - mem_base);
! 41390: test_ret++;
! 41391: printf(" %d", n_code);
! 41392: printf("\n");
! 41393: }
! 41394: }
! 41395: function_tests++;
! 41396: #endif
! 41397:
! 41398: return(test_ret);
! 41399: }
! 41400:
! 41401:
! 41402: static int
! 41403: test_xmlUCSIsOriya(void) {
! 41404: int test_ret = 0;
! 41405:
! 41406: #if defined(LIBXML_UNICODE_ENABLED)
! 41407: int mem_base;
! 41408: int ret_val;
! 41409: int code; /* UCS code point */
! 41410: int n_code;
! 41411:
! 41412: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41413: mem_base = xmlMemBlocks();
! 41414: code = gen_int(n_code, 0);
! 41415:
! 41416: ret_val = xmlUCSIsOriya(code);
! 41417: desret_int(ret_val);
! 41418: call_tests++;
! 41419: des_int(n_code, code, 0);
! 41420: xmlResetLastError();
! 41421: if (mem_base != xmlMemBlocks()) {
! 41422: printf("Leak of %d blocks found in xmlUCSIsOriya",
! 41423: xmlMemBlocks() - mem_base);
! 41424: test_ret++;
! 41425: printf(" %d", n_code);
! 41426: printf("\n");
! 41427: }
! 41428: }
! 41429: function_tests++;
! 41430: #endif
! 41431:
! 41432: return(test_ret);
! 41433: }
! 41434:
! 41435:
! 41436: static int
! 41437: test_xmlUCSIsOsmanya(void) {
! 41438: int test_ret = 0;
! 41439:
! 41440: #if defined(LIBXML_UNICODE_ENABLED)
! 41441: int mem_base;
! 41442: int ret_val;
! 41443: int code; /* UCS code point */
! 41444: int n_code;
! 41445:
! 41446: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41447: mem_base = xmlMemBlocks();
! 41448: code = gen_int(n_code, 0);
! 41449:
! 41450: ret_val = xmlUCSIsOsmanya(code);
! 41451: desret_int(ret_val);
! 41452: call_tests++;
! 41453: des_int(n_code, code, 0);
! 41454: xmlResetLastError();
! 41455: if (mem_base != xmlMemBlocks()) {
! 41456: printf("Leak of %d blocks found in xmlUCSIsOsmanya",
! 41457: xmlMemBlocks() - mem_base);
! 41458: test_ret++;
! 41459: printf(" %d", n_code);
! 41460: printf("\n");
! 41461: }
! 41462: }
! 41463: function_tests++;
! 41464: #endif
! 41465:
! 41466: return(test_ret);
! 41467: }
! 41468:
! 41469:
! 41470: static int
! 41471: test_xmlUCSIsPhoneticExtensions(void) {
! 41472: int test_ret = 0;
! 41473:
! 41474: #if defined(LIBXML_UNICODE_ENABLED)
! 41475: int mem_base;
! 41476: int ret_val;
! 41477: int code; /* UCS code point */
! 41478: int n_code;
! 41479:
! 41480: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41481: mem_base = xmlMemBlocks();
! 41482: code = gen_int(n_code, 0);
! 41483:
! 41484: ret_val = xmlUCSIsPhoneticExtensions(code);
! 41485: desret_int(ret_val);
! 41486: call_tests++;
! 41487: des_int(n_code, code, 0);
! 41488: xmlResetLastError();
! 41489: if (mem_base != xmlMemBlocks()) {
! 41490: printf("Leak of %d blocks found in xmlUCSIsPhoneticExtensions",
! 41491: xmlMemBlocks() - mem_base);
! 41492: test_ret++;
! 41493: printf(" %d", n_code);
! 41494: printf("\n");
! 41495: }
! 41496: }
! 41497: function_tests++;
! 41498: #endif
! 41499:
! 41500: return(test_ret);
! 41501: }
! 41502:
! 41503:
! 41504: static int
! 41505: test_xmlUCSIsPrivateUse(void) {
! 41506: int test_ret = 0;
! 41507:
! 41508: #if defined(LIBXML_UNICODE_ENABLED)
! 41509: int mem_base;
! 41510: int ret_val;
! 41511: int code; /* UCS code point */
! 41512: int n_code;
! 41513:
! 41514: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41515: mem_base = xmlMemBlocks();
! 41516: code = gen_int(n_code, 0);
! 41517:
! 41518: ret_val = xmlUCSIsPrivateUse(code);
! 41519: desret_int(ret_val);
! 41520: call_tests++;
! 41521: des_int(n_code, code, 0);
! 41522: xmlResetLastError();
! 41523: if (mem_base != xmlMemBlocks()) {
! 41524: printf("Leak of %d blocks found in xmlUCSIsPrivateUse",
! 41525: xmlMemBlocks() - mem_base);
! 41526: test_ret++;
! 41527: printf(" %d", n_code);
! 41528: printf("\n");
! 41529: }
! 41530: }
! 41531: function_tests++;
! 41532: #endif
! 41533:
! 41534: return(test_ret);
! 41535: }
! 41536:
! 41537:
! 41538: static int
! 41539: test_xmlUCSIsPrivateUseArea(void) {
! 41540: int test_ret = 0;
! 41541:
! 41542: #if defined(LIBXML_UNICODE_ENABLED)
! 41543: int mem_base;
! 41544: int ret_val;
! 41545: int code; /* UCS code point */
! 41546: int n_code;
! 41547:
! 41548: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41549: mem_base = xmlMemBlocks();
! 41550: code = gen_int(n_code, 0);
! 41551:
! 41552: ret_val = xmlUCSIsPrivateUseArea(code);
! 41553: desret_int(ret_val);
! 41554: call_tests++;
! 41555: des_int(n_code, code, 0);
! 41556: xmlResetLastError();
! 41557: if (mem_base != xmlMemBlocks()) {
! 41558: printf("Leak of %d blocks found in xmlUCSIsPrivateUseArea",
! 41559: xmlMemBlocks() - mem_base);
! 41560: test_ret++;
! 41561: printf(" %d", n_code);
! 41562: printf("\n");
! 41563: }
! 41564: }
! 41565: function_tests++;
! 41566: #endif
! 41567:
! 41568: return(test_ret);
! 41569: }
! 41570:
! 41571:
! 41572: static int
! 41573: test_xmlUCSIsRunic(void) {
! 41574: int test_ret = 0;
! 41575:
! 41576: #if defined(LIBXML_UNICODE_ENABLED)
! 41577: int mem_base;
! 41578: int ret_val;
! 41579: int code; /* UCS code point */
! 41580: int n_code;
! 41581:
! 41582: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41583: mem_base = xmlMemBlocks();
! 41584: code = gen_int(n_code, 0);
! 41585:
! 41586: ret_val = xmlUCSIsRunic(code);
! 41587: desret_int(ret_val);
! 41588: call_tests++;
! 41589: des_int(n_code, code, 0);
! 41590: xmlResetLastError();
! 41591: if (mem_base != xmlMemBlocks()) {
! 41592: printf("Leak of %d blocks found in xmlUCSIsRunic",
! 41593: xmlMemBlocks() - mem_base);
! 41594: test_ret++;
! 41595: printf(" %d", n_code);
! 41596: printf("\n");
! 41597: }
! 41598: }
! 41599: function_tests++;
! 41600: #endif
! 41601:
! 41602: return(test_ret);
! 41603: }
! 41604:
! 41605:
! 41606: static int
! 41607: test_xmlUCSIsShavian(void) {
! 41608: int test_ret = 0;
! 41609:
! 41610: #if defined(LIBXML_UNICODE_ENABLED)
! 41611: int mem_base;
! 41612: int ret_val;
! 41613: int code; /* UCS code point */
! 41614: int n_code;
! 41615:
! 41616: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41617: mem_base = xmlMemBlocks();
! 41618: code = gen_int(n_code, 0);
! 41619:
! 41620: ret_val = xmlUCSIsShavian(code);
! 41621: desret_int(ret_val);
! 41622: call_tests++;
! 41623: des_int(n_code, code, 0);
! 41624: xmlResetLastError();
! 41625: if (mem_base != xmlMemBlocks()) {
! 41626: printf("Leak of %d blocks found in xmlUCSIsShavian",
! 41627: xmlMemBlocks() - mem_base);
! 41628: test_ret++;
! 41629: printf(" %d", n_code);
! 41630: printf("\n");
! 41631: }
! 41632: }
! 41633: function_tests++;
! 41634: #endif
! 41635:
! 41636: return(test_ret);
! 41637: }
! 41638:
! 41639:
! 41640: static int
! 41641: test_xmlUCSIsSinhala(void) {
! 41642: int test_ret = 0;
! 41643:
! 41644: #if defined(LIBXML_UNICODE_ENABLED)
! 41645: int mem_base;
! 41646: int ret_val;
! 41647: int code; /* UCS code point */
! 41648: int n_code;
! 41649:
! 41650: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41651: mem_base = xmlMemBlocks();
! 41652: code = gen_int(n_code, 0);
! 41653:
! 41654: ret_val = xmlUCSIsSinhala(code);
! 41655: desret_int(ret_val);
! 41656: call_tests++;
! 41657: des_int(n_code, code, 0);
! 41658: xmlResetLastError();
! 41659: if (mem_base != xmlMemBlocks()) {
! 41660: printf("Leak of %d blocks found in xmlUCSIsSinhala",
! 41661: xmlMemBlocks() - mem_base);
! 41662: test_ret++;
! 41663: printf(" %d", n_code);
! 41664: printf("\n");
! 41665: }
! 41666: }
! 41667: function_tests++;
! 41668: #endif
! 41669:
! 41670: return(test_ret);
! 41671: }
! 41672:
! 41673:
! 41674: static int
! 41675: test_xmlUCSIsSmallFormVariants(void) {
! 41676: int test_ret = 0;
! 41677:
! 41678: #if defined(LIBXML_UNICODE_ENABLED)
! 41679: int mem_base;
! 41680: int ret_val;
! 41681: int code; /* UCS code point */
! 41682: int n_code;
! 41683:
! 41684: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41685: mem_base = xmlMemBlocks();
! 41686: code = gen_int(n_code, 0);
! 41687:
! 41688: ret_val = xmlUCSIsSmallFormVariants(code);
! 41689: desret_int(ret_val);
! 41690: call_tests++;
! 41691: des_int(n_code, code, 0);
! 41692: xmlResetLastError();
! 41693: if (mem_base != xmlMemBlocks()) {
! 41694: printf("Leak of %d blocks found in xmlUCSIsSmallFormVariants",
! 41695: xmlMemBlocks() - mem_base);
! 41696: test_ret++;
! 41697: printf(" %d", n_code);
! 41698: printf("\n");
! 41699: }
! 41700: }
! 41701: function_tests++;
! 41702: #endif
! 41703:
! 41704: return(test_ret);
! 41705: }
! 41706:
! 41707:
! 41708: static int
! 41709: test_xmlUCSIsSpacingModifierLetters(void) {
! 41710: int test_ret = 0;
! 41711:
! 41712: #if defined(LIBXML_UNICODE_ENABLED)
! 41713: int mem_base;
! 41714: int ret_val;
! 41715: int code; /* UCS code point */
! 41716: int n_code;
! 41717:
! 41718: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41719: mem_base = xmlMemBlocks();
! 41720: code = gen_int(n_code, 0);
! 41721:
! 41722: ret_val = xmlUCSIsSpacingModifierLetters(code);
! 41723: desret_int(ret_val);
! 41724: call_tests++;
! 41725: des_int(n_code, code, 0);
! 41726: xmlResetLastError();
! 41727: if (mem_base != xmlMemBlocks()) {
! 41728: printf("Leak of %d blocks found in xmlUCSIsSpacingModifierLetters",
! 41729: xmlMemBlocks() - mem_base);
! 41730: test_ret++;
! 41731: printf(" %d", n_code);
! 41732: printf("\n");
! 41733: }
! 41734: }
! 41735: function_tests++;
! 41736: #endif
! 41737:
! 41738: return(test_ret);
! 41739: }
! 41740:
! 41741:
! 41742: static int
! 41743: test_xmlUCSIsSpecials(void) {
! 41744: int test_ret = 0;
! 41745:
! 41746: #if defined(LIBXML_UNICODE_ENABLED)
! 41747: int mem_base;
! 41748: int ret_val;
! 41749: int code; /* UCS code point */
! 41750: int n_code;
! 41751:
! 41752: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41753: mem_base = xmlMemBlocks();
! 41754: code = gen_int(n_code, 0);
! 41755:
! 41756: ret_val = xmlUCSIsSpecials(code);
! 41757: desret_int(ret_val);
! 41758: call_tests++;
! 41759: des_int(n_code, code, 0);
! 41760: xmlResetLastError();
! 41761: if (mem_base != xmlMemBlocks()) {
! 41762: printf("Leak of %d blocks found in xmlUCSIsSpecials",
! 41763: xmlMemBlocks() - mem_base);
! 41764: test_ret++;
! 41765: printf(" %d", n_code);
! 41766: printf("\n");
! 41767: }
! 41768: }
! 41769: function_tests++;
! 41770: #endif
! 41771:
! 41772: return(test_ret);
! 41773: }
! 41774:
! 41775:
! 41776: static int
! 41777: test_xmlUCSIsSuperscriptsandSubscripts(void) {
! 41778: int test_ret = 0;
! 41779:
! 41780: #if defined(LIBXML_UNICODE_ENABLED)
! 41781: int mem_base;
! 41782: int ret_val;
! 41783: int code; /* UCS code point */
! 41784: int n_code;
! 41785:
! 41786: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41787: mem_base = xmlMemBlocks();
! 41788: code = gen_int(n_code, 0);
! 41789:
! 41790: ret_val = xmlUCSIsSuperscriptsandSubscripts(code);
! 41791: desret_int(ret_val);
! 41792: call_tests++;
! 41793: des_int(n_code, code, 0);
! 41794: xmlResetLastError();
! 41795: if (mem_base != xmlMemBlocks()) {
! 41796: printf("Leak of %d blocks found in xmlUCSIsSuperscriptsandSubscripts",
! 41797: xmlMemBlocks() - mem_base);
! 41798: test_ret++;
! 41799: printf(" %d", n_code);
! 41800: printf("\n");
! 41801: }
! 41802: }
! 41803: function_tests++;
! 41804: #endif
! 41805:
! 41806: return(test_ret);
! 41807: }
! 41808:
! 41809:
! 41810: static int
! 41811: test_xmlUCSIsSupplementalArrowsA(void) {
! 41812: int test_ret = 0;
! 41813:
! 41814: #if defined(LIBXML_UNICODE_ENABLED)
! 41815: int mem_base;
! 41816: int ret_val;
! 41817: int code; /* UCS code point */
! 41818: int n_code;
! 41819:
! 41820: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41821: mem_base = xmlMemBlocks();
! 41822: code = gen_int(n_code, 0);
! 41823:
! 41824: ret_val = xmlUCSIsSupplementalArrowsA(code);
! 41825: desret_int(ret_val);
! 41826: call_tests++;
! 41827: des_int(n_code, code, 0);
! 41828: xmlResetLastError();
! 41829: if (mem_base != xmlMemBlocks()) {
! 41830: printf("Leak of %d blocks found in xmlUCSIsSupplementalArrowsA",
! 41831: xmlMemBlocks() - mem_base);
! 41832: test_ret++;
! 41833: printf(" %d", n_code);
! 41834: printf("\n");
! 41835: }
! 41836: }
! 41837: function_tests++;
! 41838: #endif
! 41839:
! 41840: return(test_ret);
! 41841: }
! 41842:
! 41843:
! 41844: static int
! 41845: test_xmlUCSIsSupplementalArrowsB(void) {
! 41846: int test_ret = 0;
! 41847:
! 41848: #if defined(LIBXML_UNICODE_ENABLED)
! 41849: int mem_base;
! 41850: int ret_val;
! 41851: int code; /* UCS code point */
! 41852: int n_code;
! 41853:
! 41854: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41855: mem_base = xmlMemBlocks();
! 41856: code = gen_int(n_code, 0);
! 41857:
! 41858: ret_val = xmlUCSIsSupplementalArrowsB(code);
! 41859: desret_int(ret_val);
! 41860: call_tests++;
! 41861: des_int(n_code, code, 0);
! 41862: xmlResetLastError();
! 41863: if (mem_base != xmlMemBlocks()) {
! 41864: printf("Leak of %d blocks found in xmlUCSIsSupplementalArrowsB",
! 41865: xmlMemBlocks() - mem_base);
! 41866: test_ret++;
! 41867: printf(" %d", n_code);
! 41868: printf("\n");
! 41869: }
! 41870: }
! 41871: function_tests++;
! 41872: #endif
! 41873:
! 41874: return(test_ret);
! 41875: }
! 41876:
! 41877:
! 41878: static int
! 41879: test_xmlUCSIsSupplementalMathematicalOperators(void) {
! 41880: int test_ret = 0;
! 41881:
! 41882: #if defined(LIBXML_UNICODE_ENABLED)
! 41883: int mem_base;
! 41884: int ret_val;
! 41885: int code; /* UCS code point */
! 41886: int n_code;
! 41887:
! 41888: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41889: mem_base = xmlMemBlocks();
! 41890: code = gen_int(n_code, 0);
! 41891:
! 41892: ret_val = xmlUCSIsSupplementalMathematicalOperators(code);
! 41893: desret_int(ret_val);
! 41894: call_tests++;
! 41895: des_int(n_code, code, 0);
! 41896: xmlResetLastError();
! 41897: if (mem_base != xmlMemBlocks()) {
! 41898: printf("Leak of %d blocks found in xmlUCSIsSupplementalMathematicalOperators",
! 41899: xmlMemBlocks() - mem_base);
! 41900: test_ret++;
! 41901: printf(" %d", n_code);
! 41902: printf("\n");
! 41903: }
! 41904: }
! 41905: function_tests++;
! 41906: #endif
! 41907:
! 41908: return(test_ret);
! 41909: }
! 41910:
! 41911:
! 41912: static int
! 41913: test_xmlUCSIsSupplementaryPrivateUseAreaA(void) {
! 41914: int test_ret = 0;
! 41915:
! 41916: #if defined(LIBXML_UNICODE_ENABLED)
! 41917: int mem_base;
! 41918: int ret_val;
! 41919: int code; /* UCS code point */
! 41920: int n_code;
! 41921:
! 41922: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41923: mem_base = xmlMemBlocks();
! 41924: code = gen_int(n_code, 0);
! 41925:
! 41926: ret_val = xmlUCSIsSupplementaryPrivateUseAreaA(code);
! 41927: desret_int(ret_val);
! 41928: call_tests++;
! 41929: des_int(n_code, code, 0);
! 41930: xmlResetLastError();
! 41931: if (mem_base != xmlMemBlocks()) {
! 41932: printf("Leak of %d blocks found in xmlUCSIsSupplementaryPrivateUseAreaA",
! 41933: xmlMemBlocks() - mem_base);
! 41934: test_ret++;
! 41935: printf(" %d", n_code);
! 41936: printf("\n");
! 41937: }
! 41938: }
! 41939: function_tests++;
! 41940: #endif
! 41941:
! 41942: return(test_ret);
! 41943: }
! 41944:
! 41945:
! 41946: static int
! 41947: test_xmlUCSIsSupplementaryPrivateUseAreaB(void) {
! 41948: int test_ret = 0;
! 41949:
! 41950: #if defined(LIBXML_UNICODE_ENABLED)
! 41951: int mem_base;
! 41952: int ret_val;
! 41953: int code; /* UCS code point */
! 41954: int n_code;
! 41955:
! 41956: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41957: mem_base = xmlMemBlocks();
! 41958: code = gen_int(n_code, 0);
! 41959:
! 41960: ret_val = xmlUCSIsSupplementaryPrivateUseAreaB(code);
! 41961: desret_int(ret_val);
! 41962: call_tests++;
! 41963: des_int(n_code, code, 0);
! 41964: xmlResetLastError();
! 41965: if (mem_base != xmlMemBlocks()) {
! 41966: printf("Leak of %d blocks found in xmlUCSIsSupplementaryPrivateUseAreaB",
! 41967: xmlMemBlocks() - mem_base);
! 41968: test_ret++;
! 41969: printf(" %d", n_code);
! 41970: printf("\n");
! 41971: }
! 41972: }
! 41973: function_tests++;
! 41974: #endif
! 41975:
! 41976: return(test_ret);
! 41977: }
! 41978:
! 41979:
! 41980: static int
! 41981: test_xmlUCSIsSyriac(void) {
! 41982: int test_ret = 0;
! 41983:
! 41984: #if defined(LIBXML_UNICODE_ENABLED)
! 41985: int mem_base;
! 41986: int ret_val;
! 41987: int code; /* UCS code point */
! 41988: int n_code;
! 41989:
! 41990: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 41991: mem_base = xmlMemBlocks();
! 41992: code = gen_int(n_code, 0);
! 41993:
! 41994: ret_val = xmlUCSIsSyriac(code);
! 41995: desret_int(ret_val);
! 41996: call_tests++;
! 41997: des_int(n_code, code, 0);
! 41998: xmlResetLastError();
! 41999: if (mem_base != xmlMemBlocks()) {
! 42000: printf("Leak of %d blocks found in xmlUCSIsSyriac",
! 42001: xmlMemBlocks() - mem_base);
! 42002: test_ret++;
! 42003: printf(" %d", n_code);
! 42004: printf("\n");
! 42005: }
! 42006: }
! 42007: function_tests++;
! 42008: #endif
! 42009:
! 42010: return(test_ret);
! 42011: }
! 42012:
! 42013:
! 42014: static int
! 42015: test_xmlUCSIsTagalog(void) {
! 42016: int test_ret = 0;
! 42017:
! 42018: #if defined(LIBXML_UNICODE_ENABLED)
! 42019: int mem_base;
! 42020: int ret_val;
! 42021: int code; /* UCS code point */
! 42022: int n_code;
! 42023:
! 42024: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 42025: mem_base = xmlMemBlocks();
! 42026: code = gen_int(n_code, 0);
! 42027:
! 42028: ret_val = xmlUCSIsTagalog(code);
! 42029: desret_int(ret_val);
! 42030: call_tests++;
! 42031: des_int(n_code, code, 0);
! 42032: xmlResetLastError();
! 42033: if (mem_base != xmlMemBlocks()) {
! 42034: printf("Leak of %d blocks found in xmlUCSIsTagalog",
! 42035: xmlMemBlocks() - mem_base);
! 42036: test_ret++;
! 42037: printf(" %d", n_code);
! 42038: printf("\n");
! 42039: }
! 42040: }
! 42041: function_tests++;
! 42042: #endif
! 42043:
! 42044: return(test_ret);
! 42045: }
! 42046:
! 42047:
! 42048: static int
! 42049: test_xmlUCSIsTagbanwa(void) {
! 42050: int test_ret = 0;
! 42051:
! 42052: #if defined(LIBXML_UNICODE_ENABLED)
! 42053: int mem_base;
! 42054: int ret_val;
! 42055: int code; /* UCS code point */
! 42056: int n_code;
! 42057:
! 42058: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 42059: mem_base = xmlMemBlocks();
! 42060: code = gen_int(n_code, 0);
! 42061:
! 42062: ret_val = xmlUCSIsTagbanwa(code);
! 42063: desret_int(ret_val);
! 42064: call_tests++;
! 42065: des_int(n_code, code, 0);
! 42066: xmlResetLastError();
! 42067: if (mem_base != xmlMemBlocks()) {
! 42068: printf("Leak of %d blocks found in xmlUCSIsTagbanwa",
! 42069: xmlMemBlocks() - mem_base);
! 42070: test_ret++;
! 42071: printf(" %d", n_code);
! 42072: printf("\n");
! 42073: }
! 42074: }
! 42075: function_tests++;
! 42076: #endif
! 42077:
! 42078: return(test_ret);
! 42079: }
! 42080:
! 42081:
! 42082: static int
! 42083: test_xmlUCSIsTags(void) {
! 42084: int test_ret = 0;
! 42085:
! 42086: #if defined(LIBXML_UNICODE_ENABLED)
! 42087: int mem_base;
! 42088: int ret_val;
! 42089: int code; /* UCS code point */
! 42090: int n_code;
! 42091:
! 42092: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 42093: mem_base = xmlMemBlocks();
! 42094: code = gen_int(n_code, 0);
! 42095:
! 42096: ret_val = xmlUCSIsTags(code);
! 42097: desret_int(ret_val);
! 42098: call_tests++;
! 42099: des_int(n_code, code, 0);
! 42100: xmlResetLastError();
! 42101: if (mem_base != xmlMemBlocks()) {
! 42102: printf("Leak of %d blocks found in xmlUCSIsTags",
! 42103: xmlMemBlocks() - mem_base);
! 42104: test_ret++;
! 42105: printf(" %d", n_code);
! 42106: printf("\n");
! 42107: }
! 42108: }
! 42109: function_tests++;
! 42110: #endif
! 42111:
! 42112: return(test_ret);
! 42113: }
! 42114:
! 42115:
! 42116: static int
! 42117: test_xmlUCSIsTaiLe(void) {
! 42118: int test_ret = 0;
! 42119:
! 42120: #if defined(LIBXML_UNICODE_ENABLED)
! 42121: int mem_base;
! 42122: int ret_val;
! 42123: int code; /* UCS code point */
! 42124: int n_code;
! 42125:
! 42126: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 42127: mem_base = xmlMemBlocks();
! 42128: code = gen_int(n_code, 0);
! 42129:
! 42130: ret_val = xmlUCSIsTaiLe(code);
! 42131: desret_int(ret_val);
! 42132: call_tests++;
! 42133: des_int(n_code, code, 0);
! 42134: xmlResetLastError();
! 42135: if (mem_base != xmlMemBlocks()) {
! 42136: printf("Leak of %d blocks found in xmlUCSIsTaiLe",
! 42137: xmlMemBlocks() - mem_base);
! 42138: test_ret++;
! 42139: printf(" %d", n_code);
! 42140: printf("\n");
! 42141: }
! 42142: }
! 42143: function_tests++;
! 42144: #endif
! 42145:
! 42146: return(test_ret);
! 42147: }
! 42148:
! 42149:
! 42150: static int
! 42151: test_xmlUCSIsTaiXuanJingSymbols(void) {
! 42152: int test_ret = 0;
! 42153:
! 42154: #if defined(LIBXML_UNICODE_ENABLED)
! 42155: int mem_base;
! 42156: int ret_val;
! 42157: int code; /* UCS code point */
! 42158: int n_code;
! 42159:
! 42160: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 42161: mem_base = xmlMemBlocks();
! 42162: code = gen_int(n_code, 0);
! 42163:
! 42164: ret_val = xmlUCSIsTaiXuanJingSymbols(code);
! 42165: desret_int(ret_val);
! 42166: call_tests++;
! 42167: des_int(n_code, code, 0);
! 42168: xmlResetLastError();
! 42169: if (mem_base != xmlMemBlocks()) {
! 42170: printf("Leak of %d blocks found in xmlUCSIsTaiXuanJingSymbols",
! 42171: xmlMemBlocks() - mem_base);
! 42172: test_ret++;
! 42173: printf(" %d", n_code);
! 42174: printf("\n");
! 42175: }
! 42176: }
! 42177: function_tests++;
! 42178: #endif
! 42179:
! 42180: return(test_ret);
! 42181: }
! 42182:
! 42183:
! 42184: static int
! 42185: test_xmlUCSIsTamil(void) {
! 42186: int test_ret = 0;
! 42187:
! 42188: #if defined(LIBXML_UNICODE_ENABLED)
! 42189: int mem_base;
! 42190: int ret_val;
! 42191: int code; /* UCS code point */
! 42192: int n_code;
! 42193:
! 42194: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 42195: mem_base = xmlMemBlocks();
! 42196: code = gen_int(n_code, 0);
! 42197:
! 42198: ret_val = xmlUCSIsTamil(code);
! 42199: desret_int(ret_val);
! 42200: call_tests++;
! 42201: des_int(n_code, code, 0);
! 42202: xmlResetLastError();
! 42203: if (mem_base != xmlMemBlocks()) {
! 42204: printf("Leak of %d blocks found in xmlUCSIsTamil",
! 42205: xmlMemBlocks() - mem_base);
! 42206: test_ret++;
! 42207: printf(" %d", n_code);
! 42208: printf("\n");
! 42209: }
! 42210: }
! 42211: function_tests++;
! 42212: #endif
! 42213:
! 42214: return(test_ret);
! 42215: }
! 42216:
! 42217:
! 42218: static int
! 42219: test_xmlUCSIsTelugu(void) {
! 42220: int test_ret = 0;
! 42221:
! 42222: #if defined(LIBXML_UNICODE_ENABLED)
! 42223: int mem_base;
! 42224: int ret_val;
! 42225: int code; /* UCS code point */
! 42226: int n_code;
! 42227:
! 42228: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 42229: mem_base = xmlMemBlocks();
! 42230: code = gen_int(n_code, 0);
! 42231:
! 42232: ret_val = xmlUCSIsTelugu(code);
! 42233: desret_int(ret_val);
! 42234: call_tests++;
! 42235: des_int(n_code, code, 0);
! 42236: xmlResetLastError();
! 42237: if (mem_base != xmlMemBlocks()) {
! 42238: printf("Leak of %d blocks found in xmlUCSIsTelugu",
! 42239: xmlMemBlocks() - mem_base);
! 42240: test_ret++;
! 42241: printf(" %d", n_code);
! 42242: printf("\n");
! 42243: }
! 42244: }
! 42245: function_tests++;
! 42246: #endif
! 42247:
! 42248: return(test_ret);
! 42249: }
! 42250:
! 42251:
! 42252: static int
! 42253: test_xmlUCSIsThaana(void) {
! 42254: int test_ret = 0;
! 42255:
! 42256: #if defined(LIBXML_UNICODE_ENABLED)
! 42257: int mem_base;
! 42258: int ret_val;
! 42259: int code; /* UCS code point */
! 42260: int n_code;
! 42261:
! 42262: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 42263: mem_base = xmlMemBlocks();
! 42264: code = gen_int(n_code, 0);
! 42265:
! 42266: ret_val = xmlUCSIsThaana(code);
! 42267: desret_int(ret_val);
! 42268: call_tests++;
! 42269: des_int(n_code, code, 0);
! 42270: xmlResetLastError();
! 42271: if (mem_base != xmlMemBlocks()) {
! 42272: printf("Leak of %d blocks found in xmlUCSIsThaana",
! 42273: xmlMemBlocks() - mem_base);
! 42274: test_ret++;
! 42275: printf(" %d", n_code);
! 42276: printf("\n");
! 42277: }
! 42278: }
! 42279: function_tests++;
! 42280: #endif
! 42281:
! 42282: return(test_ret);
! 42283: }
! 42284:
! 42285:
! 42286: static int
! 42287: test_xmlUCSIsThai(void) {
! 42288: int test_ret = 0;
! 42289:
! 42290: #if defined(LIBXML_UNICODE_ENABLED)
! 42291: int mem_base;
! 42292: int ret_val;
! 42293: int code; /* UCS code point */
! 42294: int n_code;
! 42295:
! 42296: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 42297: mem_base = xmlMemBlocks();
! 42298: code = gen_int(n_code, 0);
! 42299:
! 42300: ret_val = xmlUCSIsThai(code);
! 42301: desret_int(ret_val);
! 42302: call_tests++;
! 42303: des_int(n_code, code, 0);
! 42304: xmlResetLastError();
! 42305: if (mem_base != xmlMemBlocks()) {
! 42306: printf("Leak of %d blocks found in xmlUCSIsThai",
! 42307: xmlMemBlocks() - mem_base);
! 42308: test_ret++;
! 42309: printf(" %d", n_code);
! 42310: printf("\n");
! 42311: }
! 42312: }
! 42313: function_tests++;
! 42314: #endif
! 42315:
! 42316: return(test_ret);
! 42317: }
! 42318:
! 42319:
! 42320: static int
! 42321: test_xmlUCSIsTibetan(void) {
! 42322: int test_ret = 0;
! 42323:
! 42324: #if defined(LIBXML_UNICODE_ENABLED)
! 42325: int mem_base;
! 42326: int ret_val;
! 42327: int code; /* UCS code point */
! 42328: int n_code;
! 42329:
! 42330: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 42331: mem_base = xmlMemBlocks();
! 42332: code = gen_int(n_code, 0);
! 42333:
! 42334: ret_val = xmlUCSIsTibetan(code);
! 42335: desret_int(ret_val);
! 42336: call_tests++;
! 42337: des_int(n_code, code, 0);
! 42338: xmlResetLastError();
! 42339: if (mem_base != xmlMemBlocks()) {
! 42340: printf("Leak of %d blocks found in xmlUCSIsTibetan",
! 42341: xmlMemBlocks() - mem_base);
! 42342: test_ret++;
! 42343: printf(" %d", n_code);
! 42344: printf("\n");
! 42345: }
! 42346: }
! 42347: function_tests++;
! 42348: #endif
! 42349:
! 42350: return(test_ret);
! 42351: }
! 42352:
! 42353:
! 42354: static int
! 42355: test_xmlUCSIsUgaritic(void) {
! 42356: int test_ret = 0;
! 42357:
! 42358: #if defined(LIBXML_UNICODE_ENABLED)
! 42359: int mem_base;
! 42360: int ret_val;
! 42361: int code; /* UCS code point */
! 42362: int n_code;
! 42363:
! 42364: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 42365: mem_base = xmlMemBlocks();
! 42366: code = gen_int(n_code, 0);
! 42367:
! 42368: ret_val = xmlUCSIsUgaritic(code);
! 42369: desret_int(ret_val);
! 42370: call_tests++;
! 42371: des_int(n_code, code, 0);
! 42372: xmlResetLastError();
! 42373: if (mem_base != xmlMemBlocks()) {
! 42374: printf("Leak of %d blocks found in xmlUCSIsUgaritic",
! 42375: xmlMemBlocks() - mem_base);
! 42376: test_ret++;
! 42377: printf(" %d", n_code);
! 42378: printf("\n");
! 42379: }
! 42380: }
! 42381: function_tests++;
! 42382: #endif
! 42383:
! 42384: return(test_ret);
! 42385: }
! 42386:
! 42387:
! 42388: static int
! 42389: test_xmlUCSIsUnifiedCanadianAboriginalSyllabics(void) {
! 42390: int test_ret = 0;
! 42391:
! 42392: #if defined(LIBXML_UNICODE_ENABLED)
! 42393: int mem_base;
! 42394: int ret_val;
! 42395: int code; /* UCS code point */
! 42396: int n_code;
! 42397:
! 42398: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 42399: mem_base = xmlMemBlocks();
! 42400: code = gen_int(n_code, 0);
! 42401:
! 42402: ret_val = xmlUCSIsUnifiedCanadianAboriginalSyllabics(code);
! 42403: desret_int(ret_val);
! 42404: call_tests++;
! 42405: des_int(n_code, code, 0);
! 42406: xmlResetLastError();
! 42407: if (mem_base != xmlMemBlocks()) {
! 42408: printf("Leak of %d blocks found in xmlUCSIsUnifiedCanadianAboriginalSyllabics",
! 42409: xmlMemBlocks() - mem_base);
! 42410: test_ret++;
! 42411: printf(" %d", n_code);
! 42412: printf("\n");
! 42413: }
! 42414: }
! 42415: function_tests++;
! 42416: #endif
! 42417:
! 42418: return(test_ret);
! 42419: }
! 42420:
! 42421:
! 42422: static int
! 42423: test_xmlUCSIsVariationSelectors(void) {
! 42424: int test_ret = 0;
! 42425:
! 42426: #if defined(LIBXML_UNICODE_ENABLED)
! 42427: int mem_base;
! 42428: int ret_val;
! 42429: int code; /* UCS code point */
! 42430: int n_code;
! 42431:
! 42432: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 42433: mem_base = xmlMemBlocks();
! 42434: code = gen_int(n_code, 0);
! 42435:
! 42436: ret_val = xmlUCSIsVariationSelectors(code);
! 42437: desret_int(ret_val);
! 42438: call_tests++;
! 42439: des_int(n_code, code, 0);
! 42440: xmlResetLastError();
! 42441: if (mem_base != xmlMemBlocks()) {
! 42442: printf("Leak of %d blocks found in xmlUCSIsVariationSelectors",
! 42443: xmlMemBlocks() - mem_base);
! 42444: test_ret++;
! 42445: printf(" %d", n_code);
! 42446: printf("\n");
! 42447: }
! 42448: }
! 42449: function_tests++;
! 42450: #endif
! 42451:
! 42452: return(test_ret);
! 42453: }
! 42454:
! 42455:
! 42456: static int
! 42457: test_xmlUCSIsVariationSelectorsSupplement(void) {
! 42458: int test_ret = 0;
! 42459:
! 42460: #if defined(LIBXML_UNICODE_ENABLED)
! 42461: int mem_base;
! 42462: int ret_val;
! 42463: int code; /* UCS code point */
! 42464: int n_code;
! 42465:
! 42466: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 42467: mem_base = xmlMemBlocks();
! 42468: code = gen_int(n_code, 0);
! 42469:
! 42470: ret_val = xmlUCSIsVariationSelectorsSupplement(code);
! 42471: desret_int(ret_val);
! 42472: call_tests++;
! 42473: des_int(n_code, code, 0);
! 42474: xmlResetLastError();
! 42475: if (mem_base != xmlMemBlocks()) {
! 42476: printf("Leak of %d blocks found in xmlUCSIsVariationSelectorsSupplement",
! 42477: xmlMemBlocks() - mem_base);
! 42478: test_ret++;
! 42479: printf(" %d", n_code);
! 42480: printf("\n");
! 42481: }
! 42482: }
! 42483: function_tests++;
! 42484: #endif
! 42485:
! 42486: return(test_ret);
! 42487: }
! 42488:
! 42489:
! 42490: static int
! 42491: test_xmlUCSIsYiRadicals(void) {
! 42492: int test_ret = 0;
! 42493:
! 42494: #if defined(LIBXML_UNICODE_ENABLED)
! 42495: int mem_base;
! 42496: int ret_val;
! 42497: int code; /* UCS code point */
! 42498: int n_code;
! 42499:
! 42500: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 42501: mem_base = xmlMemBlocks();
! 42502: code = gen_int(n_code, 0);
! 42503:
! 42504: ret_val = xmlUCSIsYiRadicals(code);
! 42505: desret_int(ret_val);
! 42506: call_tests++;
! 42507: des_int(n_code, code, 0);
! 42508: xmlResetLastError();
! 42509: if (mem_base != xmlMemBlocks()) {
! 42510: printf("Leak of %d blocks found in xmlUCSIsYiRadicals",
! 42511: xmlMemBlocks() - mem_base);
! 42512: test_ret++;
! 42513: printf(" %d", n_code);
! 42514: printf("\n");
! 42515: }
! 42516: }
! 42517: function_tests++;
! 42518: #endif
! 42519:
! 42520: return(test_ret);
! 42521: }
! 42522:
! 42523:
! 42524: static int
! 42525: test_xmlUCSIsYiSyllables(void) {
! 42526: int test_ret = 0;
! 42527:
! 42528: #if defined(LIBXML_UNICODE_ENABLED)
! 42529: int mem_base;
! 42530: int ret_val;
! 42531: int code; /* UCS code point */
! 42532: int n_code;
! 42533:
! 42534: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 42535: mem_base = xmlMemBlocks();
! 42536: code = gen_int(n_code, 0);
! 42537:
! 42538: ret_val = xmlUCSIsYiSyllables(code);
! 42539: desret_int(ret_val);
! 42540: call_tests++;
! 42541: des_int(n_code, code, 0);
! 42542: xmlResetLastError();
! 42543: if (mem_base != xmlMemBlocks()) {
! 42544: printf("Leak of %d blocks found in xmlUCSIsYiSyllables",
! 42545: xmlMemBlocks() - mem_base);
! 42546: test_ret++;
! 42547: printf(" %d", n_code);
! 42548: printf("\n");
! 42549: }
! 42550: }
! 42551: function_tests++;
! 42552: #endif
! 42553:
! 42554: return(test_ret);
! 42555: }
! 42556:
! 42557:
! 42558: static int
! 42559: test_xmlUCSIsYijingHexagramSymbols(void) {
! 42560: int test_ret = 0;
! 42561:
! 42562: #if defined(LIBXML_UNICODE_ENABLED)
! 42563: int mem_base;
! 42564: int ret_val;
! 42565: int code; /* UCS code point */
! 42566: int n_code;
! 42567:
! 42568: for (n_code = 0;n_code < gen_nb_int;n_code++) {
! 42569: mem_base = xmlMemBlocks();
! 42570: code = gen_int(n_code, 0);
! 42571:
! 42572: ret_val = xmlUCSIsYijingHexagramSymbols(code);
! 42573: desret_int(ret_val);
! 42574: call_tests++;
! 42575: des_int(n_code, code, 0);
! 42576: xmlResetLastError();
! 42577: if (mem_base != xmlMemBlocks()) {
! 42578: printf("Leak of %d blocks found in xmlUCSIsYijingHexagramSymbols",
! 42579: xmlMemBlocks() - mem_base);
! 42580: test_ret++;
! 42581: printf(" %d", n_code);
! 42582: printf("\n");
! 42583: }
! 42584: }
! 42585: function_tests++;
! 42586: #endif
! 42587:
! 42588: return(test_ret);
! 42589: }
! 42590:
! 42591: static int
! 42592: test_xmlunicode(void) {
! 42593: int test_ret = 0;
! 42594:
! 42595: if (quiet == 0) printf("Testing xmlunicode : 166 of 166 functions ...\n");
! 42596: test_ret += test_xmlUCSIsAegeanNumbers();
! 42597: test_ret += test_xmlUCSIsAlphabeticPresentationForms();
! 42598: test_ret += test_xmlUCSIsArabic();
! 42599: test_ret += test_xmlUCSIsArabicPresentationFormsA();
! 42600: test_ret += test_xmlUCSIsArabicPresentationFormsB();
! 42601: test_ret += test_xmlUCSIsArmenian();
! 42602: test_ret += test_xmlUCSIsArrows();
! 42603: test_ret += test_xmlUCSIsBasicLatin();
! 42604: test_ret += test_xmlUCSIsBengali();
! 42605: test_ret += test_xmlUCSIsBlock();
! 42606: test_ret += test_xmlUCSIsBlockElements();
! 42607: test_ret += test_xmlUCSIsBopomofo();
! 42608: test_ret += test_xmlUCSIsBopomofoExtended();
! 42609: test_ret += test_xmlUCSIsBoxDrawing();
! 42610: test_ret += test_xmlUCSIsBraillePatterns();
! 42611: test_ret += test_xmlUCSIsBuhid();
! 42612: test_ret += test_xmlUCSIsByzantineMusicalSymbols();
! 42613: test_ret += test_xmlUCSIsCJKCompatibility();
! 42614: test_ret += test_xmlUCSIsCJKCompatibilityForms();
! 42615: test_ret += test_xmlUCSIsCJKCompatibilityIdeographs();
! 42616: test_ret += test_xmlUCSIsCJKCompatibilityIdeographsSupplement();
! 42617: test_ret += test_xmlUCSIsCJKRadicalsSupplement();
! 42618: test_ret += test_xmlUCSIsCJKSymbolsandPunctuation();
! 42619: test_ret += test_xmlUCSIsCJKUnifiedIdeographs();
! 42620: test_ret += test_xmlUCSIsCJKUnifiedIdeographsExtensionA();
! 42621: test_ret += test_xmlUCSIsCJKUnifiedIdeographsExtensionB();
! 42622: test_ret += test_xmlUCSIsCat();
! 42623: test_ret += test_xmlUCSIsCatC();
! 42624: test_ret += test_xmlUCSIsCatCc();
! 42625: test_ret += test_xmlUCSIsCatCf();
! 42626: test_ret += test_xmlUCSIsCatCo();
! 42627: test_ret += test_xmlUCSIsCatCs();
! 42628: test_ret += test_xmlUCSIsCatL();
! 42629: test_ret += test_xmlUCSIsCatLl();
! 42630: test_ret += test_xmlUCSIsCatLm();
! 42631: test_ret += test_xmlUCSIsCatLo();
! 42632: test_ret += test_xmlUCSIsCatLt();
! 42633: test_ret += test_xmlUCSIsCatLu();
! 42634: test_ret += test_xmlUCSIsCatM();
! 42635: test_ret += test_xmlUCSIsCatMc();
! 42636: test_ret += test_xmlUCSIsCatMe();
! 42637: test_ret += test_xmlUCSIsCatMn();
! 42638: test_ret += test_xmlUCSIsCatN();
! 42639: test_ret += test_xmlUCSIsCatNd();
! 42640: test_ret += test_xmlUCSIsCatNl();
! 42641: test_ret += test_xmlUCSIsCatNo();
! 42642: test_ret += test_xmlUCSIsCatP();
! 42643: test_ret += test_xmlUCSIsCatPc();
! 42644: test_ret += test_xmlUCSIsCatPd();
! 42645: test_ret += test_xmlUCSIsCatPe();
! 42646: test_ret += test_xmlUCSIsCatPf();
! 42647: test_ret += test_xmlUCSIsCatPi();
! 42648: test_ret += test_xmlUCSIsCatPo();
! 42649: test_ret += test_xmlUCSIsCatPs();
! 42650: test_ret += test_xmlUCSIsCatS();
! 42651: test_ret += test_xmlUCSIsCatSc();
! 42652: test_ret += test_xmlUCSIsCatSk();
! 42653: test_ret += test_xmlUCSIsCatSm();
! 42654: test_ret += test_xmlUCSIsCatSo();
! 42655: test_ret += test_xmlUCSIsCatZ();
! 42656: test_ret += test_xmlUCSIsCatZl();
! 42657: test_ret += test_xmlUCSIsCatZp();
! 42658: test_ret += test_xmlUCSIsCatZs();
! 42659: test_ret += test_xmlUCSIsCherokee();
! 42660: test_ret += test_xmlUCSIsCombiningDiacriticalMarks();
! 42661: test_ret += test_xmlUCSIsCombiningDiacriticalMarksforSymbols();
! 42662: test_ret += test_xmlUCSIsCombiningHalfMarks();
! 42663: test_ret += test_xmlUCSIsCombiningMarksforSymbols();
! 42664: test_ret += test_xmlUCSIsControlPictures();
! 42665: test_ret += test_xmlUCSIsCurrencySymbols();
! 42666: test_ret += test_xmlUCSIsCypriotSyllabary();
! 42667: test_ret += test_xmlUCSIsCyrillic();
! 42668: test_ret += test_xmlUCSIsCyrillicSupplement();
! 42669: test_ret += test_xmlUCSIsDeseret();
! 42670: test_ret += test_xmlUCSIsDevanagari();
! 42671: test_ret += test_xmlUCSIsDingbats();
! 42672: test_ret += test_xmlUCSIsEnclosedAlphanumerics();
! 42673: test_ret += test_xmlUCSIsEnclosedCJKLettersandMonths();
! 42674: test_ret += test_xmlUCSIsEthiopic();
! 42675: test_ret += test_xmlUCSIsGeneralPunctuation();
! 42676: test_ret += test_xmlUCSIsGeometricShapes();
! 42677: test_ret += test_xmlUCSIsGeorgian();
! 42678: test_ret += test_xmlUCSIsGothic();
! 42679: test_ret += test_xmlUCSIsGreek();
! 42680: test_ret += test_xmlUCSIsGreekExtended();
! 42681: test_ret += test_xmlUCSIsGreekandCoptic();
! 42682: test_ret += test_xmlUCSIsGujarati();
! 42683: test_ret += test_xmlUCSIsGurmukhi();
! 42684: test_ret += test_xmlUCSIsHalfwidthandFullwidthForms();
! 42685: test_ret += test_xmlUCSIsHangulCompatibilityJamo();
! 42686: test_ret += test_xmlUCSIsHangulJamo();
! 42687: test_ret += test_xmlUCSIsHangulSyllables();
! 42688: test_ret += test_xmlUCSIsHanunoo();
! 42689: test_ret += test_xmlUCSIsHebrew();
! 42690: test_ret += test_xmlUCSIsHighPrivateUseSurrogates();
! 42691: test_ret += test_xmlUCSIsHighSurrogates();
! 42692: test_ret += test_xmlUCSIsHiragana();
! 42693: test_ret += test_xmlUCSIsIPAExtensions();
! 42694: test_ret += test_xmlUCSIsIdeographicDescriptionCharacters();
! 42695: test_ret += test_xmlUCSIsKanbun();
! 42696: test_ret += test_xmlUCSIsKangxiRadicals();
! 42697: test_ret += test_xmlUCSIsKannada();
! 42698: test_ret += test_xmlUCSIsKatakana();
! 42699: test_ret += test_xmlUCSIsKatakanaPhoneticExtensions();
! 42700: test_ret += test_xmlUCSIsKhmer();
! 42701: test_ret += test_xmlUCSIsKhmerSymbols();
! 42702: test_ret += test_xmlUCSIsLao();
! 42703: test_ret += test_xmlUCSIsLatin1Supplement();
! 42704: test_ret += test_xmlUCSIsLatinExtendedA();
! 42705: test_ret += test_xmlUCSIsLatinExtendedAdditional();
! 42706: test_ret += test_xmlUCSIsLatinExtendedB();
! 42707: test_ret += test_xmlUCSIsLetterlikeSymbols();
! 42708: test_ret += test_xmlUCSIsLimbu();
! 42709: test_ret += test_xmlUCSIsLinearBIdeograms();
! 42710: test_ret += test_xmlUCSIsLinearBSyllabary();
! 42711: test_ret += test_xmlUCSIsLowSurrogates();
! 42712: test_ret += test_xmlUCSIsMalayalam();
! 42713: test_ret += test_xmlUCSIsMathematicalAlphanumericSymbols();
! 42714: test_ret += test_xmlUCSIsMathematicalOperators();
! 42715: test_ret += test_xmlUCSIsMiscellaneousMathematicalSymbolsA();
! 42716: test_ret += test_xmlUCSIsMiscellaneousMathematicalSymbolsB();
! 42717: test_ret += test_xmlUCSIsMiscellaneousSymbols();
! 42718: test_ret += test_xmlUCSIsMiscellaneousSymbolsandArrows();
! 42719: test_ret += test_xmlUCSIsMiscellaneousTechnical();
! 42720: test_ret += test_xmlUCSIsMongolian();
! 42721: test_ret += test_xmlUCSIsMusicalSymbols();
! 42722: test_ret += test_xmlUCSIsMyanmar();
! 42723: test_ret += test_xmlUCSIsNumberForms();
! 42724: test_ret += test_xmlUCSIsOgham();
! 42725: test_ret += test_xmlUCSIsOldItalic();
! 42726: test_ret += test_xmlUCSIsOpticalCharacterRecognition();
! 42727: test_ret += test_xmlUCSIsOriya();
! 42728: test_ret += test_xmlUCSIsOsmanya();
! 42729: test_ret += test_xmlUCSIsPhoneticExtensions();
! 42730: test_ret += test_xmlUCSIsPrivateUse();
! 42731: test_ret += test_xmlUCSIsPrivateUseArea();
! 42732: test_ret += test_xmlUCSIsRunic();
! 42733: test_ret += test_xmlUCSIsShavian();
! 42734: test_ret += test_xmlUCSIsSinhala();
! 42735: test_ret += test_xmlUCSIsSmallFormVariants();
! 42736: test_ret += test_xmlUCSIsSpacingModifierLetters();
! 42737: test_ret += test_xmlUCSIsSpecials();
! 42738: test_ret += test_xmlUCSIsSuperscriptsandSubscripts();
! 42739: test_ret += test_xmlUCSIsSupplementalArrowsA();
! 42740: test_ret += test_xmlUCSIsSupplementalArrowsB();
! 42741: test_ret += test_xmlUCSIsSupplementalMathematicalOperators();
! 42742: test_ret += test_xmlUCSIsSupplementaryPrivateUseAreaA();
! 42743: test_ret += test_xmlUCSIsSupplementaryPrivateUseAreaB();
! 42744: test_ret += test_xmlUCSIsSyriac();
! 42745: test_ret += test_xmlUCSIsTagalog();
! 42746: test_ret += test_xmlUCSIsTagbanwa();
! 42747: test_ret += test_xmlUCSIsTags();
! 42748: test_ret += test_xmlUCSIsTaiLe();
! 42749: test_ret += test_xmlUCSIsTaiXuanJingSymbols();
! 42750: test_ret += test_xmlUCSIsTamil();
! 42751: test_ret += test_xmlUCSIsTelugu();
! 42752: test_ret += test_xmlUCSIsThaana();
! 42753: test_ret += test_xmlUCSIsThai();
! 42754: test_ret += test_xmlUCSIsTibetan();
! 42755: test_ret += test_xmlUCSIsUgaritic();
! 42756: test_ret += test_xmlUCSIsUnifiedCanadianAboriginalSyllabics();
! 42757: test_ret += test_xmlUCSIsVariationSelectors();
! 42758: test_ret += test_xmlUCSIsVariationSelectorsSupplement();
! 42759: test_ret += test_xmlUCSIsYiRadicals();
! 42760: test_ret += test_xmlUCSIsYiSyllables();
! 42761: test_ret += test_xmlUCSIsYijingHexagramSymbols();
! 42762:
! 42763: if (test_ret != 0)
! 42764: printf("Module xmlunicode: %d errors\n", test_ret);
! 42765: return(test_ret);
! 42766: }
! 42767:
! 42768: static int
! 42769: test_xmlNewTextWriter(void) {
! 42770: int test_ret = 0;
! 42771:
! 42772: #if defined(LIBXML_WRITER_ENABLED)
! 42773: int mem_base;
! 42774: xmlTextWriterPtr ret_val;
! 42775: xmlOutputBufferPtr out; /* an xmlOutputBufferPtr */
! 42776: int n_out;
! 42777:
! 42778: for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
! 42779: mem_base = xmlMemBlocks();
! 42780: out = gen_xmlOutputBufferPtr(n_out, 0);
! 42781:
! 42782: ret_val = xmlNewTextWriter(out);
! 42783: if (ret_val != NULL) out = NULL;
! 42784: desret_xmlTextWriterPtr(ret_val);
! 42785: call_tests++;
! 42786: des_xmlOutputBufferPtr(n_out, out, 0);
! 42787: xmlResetLastError();
! 42788: if (mem_base != xmlMemBlocks()) {
! 42789: printf("Leak of %d blocks found in xmlNewTextWriter",
! 42790: xmlMemBlocks() - mem_base);
! 42791: test_ret++;
! 42792: printf(" %d", n_out);
! 42793: printf("\n");
! 42794: }
! 42795: }
! 42796: function_tests++;
! 42797: #endif
! 42798:
! 42799: return(test_ret);
! 42800: }
! 42801:
! 42802:
! 42803: static int
! 42804: test_xmlNewTextWriterFilename(void) {
! 42805: int test_ret = 0;
! 42806:
! 42807: #if defined(LIBXML_WRITER_ENABLED)
! 42808: int mem_base;
! 42809: xmlTextWriterPtr ret_val;
! 42810: const char * uri; /* the URI of the resource for the output */
! 42811: int n_uri;
! 42812: int compression; /* compress the output? */
! 42813: int n_compression;
! 42814:
! 42815: for (n_uri = 0;n_uri < gen_nb_fileoutput;n_uri++) {
! 42816: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
! 42817: mem_base = xmlMemBlocks();
! 42818: uri = gen_fileoutput(n_uri, 0);
! 42819: compression = gen_int(n_compression, 1);
! 42820:
! 42821: ret_val = xmlNewTextWriterFilename(uri, compression);
! 42822: desret_xmlTextWriterPtr(ret_val);
! 42823: call_tests++;
! 42824: des_fileoutput(n_uri, uri, 0);
! 42825: des_int(n_compression, compression, 1);
! 42826: xmlResetLastError();
! 42827: if (mem_base != xmlMemBlocks()) {
! 42828: printf("Leak of %d blocks found in xmlNewTextWriterFilename",
! 42829: xmlMemBlocks() - mem_base);
! 42830: test_ret++;
! 42831: printf(" %d", n_uri);
! 42832: printf(" %d", n_compression);
! 42833: printf("\n");
! 42834: }
! 42835: }
! 42836: }
! 42837: function_tests++;
! 42838: #endif
! 42839:
! 42840: return(test_ret);
! 42841: }
! 42842:
! 42843:
! 42844: static int
! 42845: test_xmlNewTextWriterMemory(void) {
! 42846: int test_ret = 0;
! 42847:
! 42848: #if defined(LIBXML_WRITER_ENABLED)
! 42849: int mem_base;
! 42850: xmlTextWriterPtr ret_val;
! 42851: xmlBufferPtr buf; /* xmlBufferPtr */
! 42852: int n_buf;
! 42853: int compression; /* compress the output? */
! 42854: int n_compression;
! 42855:
! 42856: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 42857: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
! 42858: mem_base = xmlMemBlocks();
! 42859: buf = gen_xmlBufferPtr(n_buf, 0);
! 42860: compression = gen_int(n_compression, 1);
! 42861:
! 42862: ret_val = xmlNewTextWriterMemory(buf, compression);
! 42863: desret_xmlTextWriterPtr(ret_val);
! 42864: call_tests++;
! 42865: des_xmlBufferPtr(n_buf, buf, 0);
! 42866: des_int(n_compression, compression, 1);
! 42867: xmlResetLastError();
! 42868: if (mem_base != xmlMemBlocks()) {
! 42869: printf("Leak of %d blocks found in xmlNewTextWriterMemory",
! 42870: xmlMemBlocks() - mem_base);
! 42871: test_ret++;
! 42872: printf(" %d", n_buf);
! 42873: printf(" %d", n_compression);
! 42874: printf("\n");
! 42875: }
! 42876: }
! 42877: }
! 42878: function_tests++;
! 42879: #endif
! 42880:
! 42881: return(test_ret);
! 42882: }
! 42883:
! 42884:
! 42885: static int
! 42886: test_xmlNewTextWriterPushParser(void) {
! 42887: int test_ret = 0;
! 42888:
! 42889: #if defined(LIBXML_WRITER_ENABLED)
! 42890: int mem_base;
! 42891: xmlTextWriterPtr ret_val;
! 42892: xmlParserCtxtPtr ctxt; /* xmlParserCtxtPtr to hold the new XML document tree */
! 42893: int n_ctxt;
! 42894: int compression; /* compress the output? */
! 42895: int n_compression;
! 42896:
! 42897: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
! 42898: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
! 42899: mem_base = xmlMemBlocks();
! 42900: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
! 42901: compression = gen_int(n_compression, 1);
! 42902:
! 42903: ret_val = xmlNewTextWriterPushParser(ctxt, compression);
! 42904: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;} if (ret_val != NULL) ctxt = NULL;
! 42905: desret_xmlTextWriterPtr(ret_val);
! 42906: call_tests++;
! 42907: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
! 42908: des_int(n_compression, compression, 1);
! 42909: xmlResetLastError();
! 42910: if (mem_base != xmlMemBlocks()) {
! 42911: printf("Leak of %d blocks found in xmlNewTextWriterPushParser",
! 42912: xmlMemBlocks() - mem_base);
! 42913: test_ret++;
! 42914: printf(" %d", n_ctxt);
! 42915: printf(" %d", n_compression);
! 42916: printf("\n");
! 42917: }
! 42918: }
! 42919: }
! 42920: function_tests++;
! 42921: #endif
! 42922:
! 42923: return(test_ret);
! 42924: }
! 42925:
! 42926:
! 42927: static int
! 42928: test_xmlNewTextWriterTree(void) {
! 42929: int test_ret = 0;
! 42930:
! 42931: #if defined(LIBXML_WRITER_ENABLED)
! 42932: int mem_base;
! 42933: xmlTextWriterPtr ret_val;
! 42934: xmlDocPtr doc; /* xmlDocPtr */
! 42935: int n_doc;
! 42936: xmlNodePtr node; /* xmlNodePtr or NULL for doc->children */
! 42937: int n_node;
! 42938: int compression; /* compress the output? */
! 42939: int n_compression;
! 42940:
! 42941: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 42942: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 42943: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
! 42944: mem_base = xmlMemBlocks();
! 42945: doc = gen_xmlDocPtr(n_doc, 0);
! 42946: node = gen_xmlNodePtr(n_node, 1);
! 42947: compression = gen_int(n_compression, 2);
! 42948:
! 42949: ret_val = xmlNewTextWriterTree(doc, node, compression);
! 42950: desret_xmlTextWriterPtr(ret_val);
! 42951: call_tests++;
! 42952: des_xmlDocPtr(n_doc, doc, 0);
! 42953: des_xmlNodePtr(n_node, node, 1);
! 42954: des_int(n_compression, compression, 2);
! 42955: xmlResetLastError();
! 42956: if (mem_base != xmlMemBlocks()) {
! 42957: printf("Leak of %d blocks found in xmlNewTextWriterTree",
! 42958: xmlMemBlocks() - mem_base);
! 42959: test_ret++;
! 42960: printf(" %d", n_doc);
! 42961: printf(" %d", n_node);
! 42962: printf(" %d", n_compression);
! 42963: printf("\n");
! 42964: }
! 42965: }
! 42966: }
! 42967: }
! 42968: function_tests++;
! 42969: #endif
! 42970:
! 42971: return(test_ret);
! 42972: }
! 42973:
! 42974:
! 42975: static int
! 42976: test_xmlTextWriterEndAttribute(void) {
! 42977: int test_ret = 0;
! 42978:
! 42979: #if defined(LIBXML_WRITER_ENABLED)
! 42980: int mem_base;
! 42981: int ret_val;
! 42982: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 42983: int n_writer;
! 42984:
! 42985: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 42986: mem_base = xmlMemBlocks();
! 42987: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 42988:
! 42989: ret_val = xmlTextWriterEndAttribute(writer);
! 42990: desret_int(ret_val);
! 42991: call_tests++;
! 42992: des_xmlTextWriterPtr(n_writer, writer, 0);
! 42993: xmlResetLastError();
! 42994: if (mem_base != xmlMemBlocks()) {
! 42995: printf("Leak of %d blocks found in xmlTextWriterEndAttribute",
! 42996: xmlMemBlocks() - mem_base);
! 42997: test_ret++;
! 42998: printf(" %d", n_writer);
! 42999: printf("\n");
! 43000: }
! 43001: }
! 43002: function_tests++;
! 43003: #endif
! 43004:
! 43005: return(test_ret);
! 43006: }
! 43007:
! 43008:
! 43009: static int
! 43010: test_xmlTextWriterEndCDATA(void) {
! 43011: int test_ret = 0;
! 43012:
! 43013: #if defined(LIBXML_WRITER_ENABLED)
! 43014: int mem_base;
! 43015: int ret_val;
! 43016: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43017: int n_writer;
! 43018:
! 43019: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43020: mem_base = xmlMemBlocks();
! 43021: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43022:
! 43023: ret_val = xmlTextWriterEndCDATA(writer);
! 43024: desret_int(ret_val);
! 43025: call_tests++;
! 43026: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43027: xmlResetLastError();
! 43028: if (mem_base != xmlMemBlocks()) {
! 43029: printf("Leak of %d blocks found in xmlTextWriterEndCDATA",
! 43030: xmlMemBlocks() - mem_base);
! 43031: test_ret++;
! 43032: printf(" %d", n_writer);
! 43033: printf("\n");
! 43034: }
! 43035: }
! 43036: function_tests++;
! 43037: #endif
! 43038:
! 43039: return(test_ret);
! 43040: }
! 43041:
! 43042:
! 43043: static int
! 43044: test_xmlTextWriterEndComment(void) {
! 43045: int test_ret = 0;
! 43046:
! 43047: #if defined(LIBXML_WRITER_ENABLED)
! 43048: int mem_base;
! 43049: int ret_val;
! 43050: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43051: int n_writer;
! 43052:
! 43053: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43054: mem_base = xmlMemBlocks();
! 43055: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43056:
! 43057: ret_val = xmlTextWriterEndComment(writer);
! 43058: desret_int(ret_val);
! 43059: call_tests++;
! 43060: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43061: xmlResetLastError();
! 43062: if (mem_base != xmlMemBlocks()) {
! 43063: printf("Leak of %d blocks found in xmlTextWriterEndComment",
! 43064: xmlMemBlocks() - mem_base);
! 43065: test_ret++;
! 43066: printf(" %d", n_writer);
! 43067: printf("\n");
! 43068: }
! 43069: }
! 43070: function_tests++;
! 43071: #endif
! 43072:
! 43073: return(test_ret);
! 43074: }
! 43075:
! 43076:
! 43077: static int
! 43078: test_xmlTextWriterEndDTD(void) {
! 43079: int test_ret = 0;
! 43080:
! 43081: #if defined(LIBXML_WRITER_ENABLED)
! 43082: int mem_base;
! 43083: int ret_val;
! 43084: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43085: int n_writer;
! 43086:
! 43087: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43088: mem_base = xmlMemBlocks();
! 43089: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43090:
! 43091: ret_val = xmlTextWriterEndDTD(writer);
! 43092: desret_int(ret_val);
! 43093: call_tests++;
! 43094: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43095: xmlResetLastError();
! 43096: if (mem_base != xmlMemBlocks()) {
! 43097: printf("Leak of %d blocks found in xmlTextWriterEndDTD",
! 43098: xmlMemBlocks() - mem_base);
! 43099: test_ret++;
! 43100: printf(" %d", n_writer);
! 43101: printf("\n");
! 43102: }
! 43103: }
! 43104: function_tests++;
! 43105: #endif
! 43106:
! 43107: return(test_ret);
! 43108: }
! 43109:
! 43110:
! 43111: static int
! 43112: test_xmlTextWriterEndDTDAttlist(void) {
! 43113: int test_ret = 0;
! 43114:
! 43115: #if defined(LIBXML_WRITER_ENABLED)
! 43116: int mem_base;
! 43117: int ret_val;
! 43118: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43119: int n_writer;
! 43120:
! 43121: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43122: mem_base = xmlMemBlocks();
! 43123: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43124:
! 43125: ret_val = xmlTextWriterEndDTDAttlist(writer);
! 43126: desret_int(ret_val);
! 43127: call_tests++;
! 43128: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43129: xmlResetLastError();
! 43130: if (mem_base != xmlMemBlocks()) {
! 43131: printf("Leak of %d blocks found in xmlTextWriterEndDTDAttlist",
! 43132: xmlMemBlocks() - mem_base);
! 43133: test_ret++;
! 43134: printf(" %d", n_writer);
! 43135: printf("\n");
! 43136: }
! 43137: }
! 43138: function_tests++;
! 43139: #endif
! 43140:
! 43141: return(test_ret);
! 43142: }
! 43143:
! 43144:
! 43145: static int
! 43146: test_xmlTextWriterEndDTDElement(void) {
! 43147: int test_ret = 0;
! 43148:
! 43149: #if defined(LIBXML_WRITER_ENABLED)
! 43150: int mem_base;
! 43151: int ret_val;
! 43152: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43153: int n_writer;
! 43154:
! 43155: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43156: mem_base = xmlMemBlocks();
! 43157: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43158:
! 43159: ret_val = xmlTextWriterEndDTDElement(writer);
! 43160: desret_int(ret_val);
! 43161: call_tests++;
! 43162: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43163: xmlResetLastError();
! 43164: if (mem_base != xmlMemBlocks()) {
! 43165: printf("Leak of %d blocks found in xmlTextWriterEndDTDElement",
! 43166: xmlMemBlocks() - mem_base);
! 43167: test_ret++;
! 43168: printf(" %d", n_writer);
! 43169: printf("\n");
! 43170: }
! 43171: }
! 43172: function_tests++;
! 43173: #endif
! 43174:
! 43175: return(test_ret);
! 43176: }
! 43177:
! 43178:
! 43179: static int
! 43180: test_xmlTextWriterEndDTDEntity(void) {
! 43181: int test_ret = 0;
! 43182:
! 43183: #if defined(LIBXML_WRITER_ENABLED)
! 43184: int mem_base;
! 43185: int ret_val;
! 43186: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43187: int n_writer;
! 43188:
! 43189: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43190: mem_base = xmlMemBlocks();
! 43191: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43192:
! 43193: ret_val = xmlTextWriterEndDTDEntity(writer);
! 43194: desret_int(ret_val);
! 43195: call_tests++;
! 43196: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43197: xmlResetLastError();
! 43198: if (mem_base != xmlMemBlocks()) {
! 43199: printf("Leak of %d blocks found in xmlTextWriterEndDTDEntity",
! 43200: xmlMemBlocks() - mem_base);
! 43201: test_ret++;
! 43202: printf(" %d", n_writer);
! 43203: printf("\n");
! 43204: }
! 43205: }
! 43206: function_tests++;
! 43207: #endif
! 43208:
! 43209: return(test_ret);
! 43210: }
! 43211:
! 43212:
! 43213: static int
! 43214: test_xmlTextWriterEndDocument(void) {
! 43215: int test_ret = 0;
! 43216:
! 43217: #if defined(LIBXML_WRITER_ENABLED)
! 43218: int mem_base;
! 43219: int ret_val;
! 43220: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43221: int n_writer;
! 43222:
! 43223: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43224: mem_base = xmlMemBlocks();
! 43225: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43226:
! 43227: ret_val = xmlTextWriterEndDocument(writer);
! 43228: desret_int(ret_val);
! 43229: call_tests++;
! 43230: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43231: xmlResetLastError();
! 43232: if (mem_base != xmlMemBlocks()) {
! 43233: printf("Leak of %d blocks found in xmlTextWriterEndDocument",
! 43234: xmlMemBlocks() - mem_base);
! 43235: test_ret++;
! 43236: printf(" %d", n_writer);
! 43237: printf("\n");
! 43238: }
! 43239: }
! 43240: function_tests++;
! 43241: #endif
! 43242:
! 43243: return(test_ret);
! 43244: }
! 43245:
! 43246:
! 43247: static int
! 43248: test_xmlTextWriterEndElement(void) {
! 43249: int test_ret = 0;
! 43250:
! 43251: #if defined(LIBXML_WRITER_ENABLED)
! 43252: int mem_base;
! 43253: int ret_val;
! 43254: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43255: int n_writer;
! 43256:
! 43257: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43258: mem_base = xmlMemBlocks();
! 43259: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43260:
! 43261: ret_val = xmlTextWriterEndElement(writer);
! 43262: desret_int(ret_val);
! 43263: call_tests++;
! 43264: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43265: xmlResetLastError();
! 43266: if (mem_base != xmlMemBlocks()) {
! 43267: printf("Leak of %d blocks found in xmlTextWriterEndElement",
! 43268: xmlMemBlocks() - mem_base);
! 43269: test_ret++;
! 43270: printf(" %d", n_writer);
! 43271: printf("\n");
! 43272: }
! 43273: }
! 43274: function_tests++;
! 43275: #endif
! 43276:
! 43277: return(test_ret);
! 43278: }
! 43279:
! 43280:
! 43281: static int
! 43282: test_xmlTextWriterEndPI(void) {
! 43283: int test_ret = 0;
! 43284:
! 43285: #if defined(LIBXML_WRITER_ENABLED)
! 43286: int mem_base;
! 43287: int ret_val;
! 43288: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43289: int n_writer;
! 43290:
! 43291: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43292: mem_base = xmlMemBlocks();
! 43293: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43294:
! 43295: ret_val = xmlTextWriterEndPI(writer);
! 43296: desret_int(ret_val);
! 43297: call_tests++;
! 43298: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43299: xmlResetLastError();
! 43300: if (mem_base != xmlMemBlocks()) {
! 43301: printf("Leak of %d blocks found in xmlTextWriterEndPI",
! 43302: xmlMemBlocks() - mem_base);
! 43303: test_ret++;
! 43304: printf(" %d", n_writer);
! 43305: printf("\n");
! 43306: }
! 43307: }
! 43308: function_tests++;
! 43309: #endif
! 43310:
! 43311: return(test_ret);
! 43312: }
! 43313:
! 43314:
! 43315: static int
! 43316: test_xmlTextWriterFlush(void) {
! 43317: int test_ret = 0;
! 43318:
! 43319: #if defined(LIBXML_WRITER_ENABLED)
! 43320: int mem_base;
! 43321: int ret_val;
! 43322: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43323: int n_writer;
! 43324:
! 43325: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43326: mem_base = xmlMemBlocks();
! 43327: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43328:
! 43329: ret_val = xmlTextWriterFlush(writer);
! 43330: desret_int(ret_val);
! 43331: call_tests++;
! 43332: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43333: xmlResetLastError();
! 43334: if (mem_base != xmlMemBlocks()) {
! 43335: printf("Leak of %d blocks found in xmlTextWriterFlush",
! 43336: xmlMemBlocks() - mem_base);
! 43337: test_ret++;
! 43338: printf(" %d", n_writer);
! 43339: printf("\n");
! 43340: }
! 43341: }
! 43342: function_tests++;
! 43343: #endif
! 43344:
! 43345: return(test_ret);
! 43346: }
! 43347:
! 43348:
! 43349: static int
! 43350: test_xmlTextWriterFullEndElement(void) {
! 43351: int test_ret = 0;
! 43352:
! 43353: #if defined(LIBXML_WRITER_ENABLED)
! 43354: int mem_base;
! 43355: int ret_val;
! 43356: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43357: int n_writer;
! 43358:
! 43359: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43360: mem_base = xmlMemBlocks();
! 43361: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43362:
! 43363: ret_val = xmlTextWriterFullEndElement(writer);
! 43364: desret_int(ret_val);
! 43365: call_tests++;
! 43366: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43367: xmlResetLastError();
! 43368: if (mem_base != xmlMemBlocks()) {
! 43369: printf("Leak of %d blocks found in xmlTextWriterFullEndElement",
! 43370: xmlMemBlocks() - mem_base);
! 43371: test_ret++;
! 43372: printf(" %d", n_writer);
! 43373: printf("\n");
! 43374: }
! 43375: }
! 43376: function_tests++;
! 43377: #endif
! 43378:
! 43379: return(test_ret);
! 43380: }
! 43381:
! 43382:
! 43383: static int
! 43384: test_xmlTextWriterSetIndent(void) {
! 43385: int test_ret = 0;
! 43386:
! 43387: #if defined(LIBXML_WRITER_ENABLED)
! 43388: int mem_base;
! 43389: int ret_val;
! 43390: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43391: int n_writer;
! 43392: int indent; /* do indentation? */
! 43393: int n_indent;
! 43394:
! 43395: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43396: for (n_indent = 0;n_indent < gen_nb_int;n_indent++) {
! 43397: mem_base = xmlMemBlocks();
! 43398: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43399: indent = gen_int(n_indent, 1);
! 43400:
! 43401: ret_val = xmlTextWriterSetIndent(writer, indent);
! 43402: desret_int(ret_val);
! 43403: call_tests++;
! 43404: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43405: des_int(n_indent, indent, 1);
! 43406: xmlResetLastError();
! 43407: if (mem_base != xmlMemBlocks()) {
! 43408: printf("Leak of %d blocks found in xmlTextWriterSetIndent",
! 43409: xmlMemBlocks() - mem_base);
! 43410: test_ret++;
! 43411: printf(" %d", n_writer);
! 43412: printf(" %d", n_indent);
! 43413: printf("\n");
! 43414: }
! 43415: }
! 43416: }
! 43417: function_tests++;
! 43418: #endif
! 43419:
! 43420: return(test_ret);
! 43421: }
! 43422:
! 43423:
! 43424: static int
! 43425: test_xmlTextWriterSetIndentString(void) {
! 43426: int test_ret = 0;
! 43427:
! 43428: #if defined(LIBXML_WRITER_ENABLED)
! 43429: int mem_base;
! 43430: int ret_val;
! 43431: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43432: int n_writer;
! 43433: xmlChar * str; /* the xmlChar string */
! 43434: int n_str;
! 43435:
! 43436: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43437: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 43438: mem_base = xmlMemBlocks();
! 43439: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43440: str = gen_const_xmlChar_ptr(n_str, 1);
! 43441:
! 43442: ret_val = xmlTextWriterSetIndentString(writer, (const xmlChar *)str);
! 43443: desret_int(ret_val);
! 43444: call_tests++;
! 43445: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43446: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
! 43447: xmlResetLastError();
! 43448: if (mem_base != xmlMemBlocks()) {
! 43449: printf("Leak of %d blocks found in xmlTextWriterSetIndentString",
! 43450: xmlMemBlocks() - mem_base);
! 43451: test_ret++;
! 43452: printf(" %d", n_writer);
! 43453: printf(" %d", n_str);
! 43454: printf("\n");
! 43455: }
! 43456: }
! 43457: }
! 43458: function_tests++;
! 43459: #endif
! 43460:
! 43461: return(test_ret);
! 43462: }
! 43463:
! 43464:
! 43465: static int
! 43466: test_xmlTextWriterStartAttribute(void) {
! 43467: int test_ret = 0;
! 43468:
! 43469: #if defined(LIBXML_WRITER_ENABLED)
! 43470: int mem_base;
! 43471: int ret_val;
! 43472: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43473: int n_writer;
! 43474: xmlChar * name; /* element name */
! 43475: int n_name;
! 43476:
! 43477: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43478: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 43479: mem_base = xmlMemBlocks();
! 43480: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43481: name = gen_const_xmlChar_ptr(n_name, 1);
! 43482:
! 43483: ret_val = xmlTextWriterStartAttribute(writer, (const xmlChar *)name);
! 43484: desret_int(ret_val);
! 43485: call_tests++;
! 43486: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43487: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 43488: xmlResetLastError();
! 43489: if (mem_base != xmlMemBlocks()) {
! 43490: printf("Leak of %d blocks found in xmlTextWriterStartAttribute",
! 43491: xmlMemBlocks() - mem_base);
! 43492: test_ret++;
! 43493: printf(" %d", n_writer);
! 43494: printf(" %d", n_name);
! 43495: printf("\n");
! 43496: }
! 43497: }
! 43498: }
! 43499: function_tests++;
! 43500: #endif
! 43501:
! 43502: return(test_ret);
! 43503: }
! 43504:
! 43505:
! 43506: static int
! 43507: test_xmlTextWriterStartAttributeNS(void) {
! 43508: int test_ret = 0;
! 43509:
! 43510: #if defined(LIBXML_WRITER_ENABLED)
! 43511: int mem_base;
! 43512: int ret_val;
! 43513: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43514: int n_writer;
! 43515: xmlChar * prefix; /* namespace prefix or NULL */
! 43516: int n_prefix;
! 43517: xmlChar * name; /* element local name */
! 43518: int n_name;
! 43519: xmlChar * namespaceURI; /* namespace URI or NULL */
! 43520: int n_namespaceURI;
! 43521:
! 43522: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43523: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
! 43524: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 43525: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
! 43526: mem_base = xmlMemBlocks();
! 43527: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43528: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
! 43529: name = gen_const_xmlChar_ptr(n_name, 2);
! 43530: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
! 43531:
! 43532: ret_val = xmlTextWriterStartAttributeNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI);
! 43533: desret_int(ret_val);
! 43534: call_tests++;
! 43535: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43536: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
! 43537: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 43538: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3);
! 43539: xmlResetLastError();
! 43540: if (mem_base != xmlMemBlocks()) {
! 43541: printf("Leak of %d blocks found in xmlTextWriterStartAttributeNS",
! 43542: xmlMemBlocks() - mem_base);
! 43543: test_ret++;
! 43544: printf(" %d", n_writer);
! 43545: printf(" %d", n_prefix);
! 43546: printf(" %d", n_name);
! 43547: printf(" %d", n_namespaceURI);
! 43548: printf("\n");
! 43549: }
! 43550: }
! 43551: }
! 43552: }
! 43553: }
! 43554: function_tests++;
! 43555: #endif
! 43556:
! 43557: return(test_ret);
! 43558: }
! 43559:
! 43560:
! 43561: static int
! 43562: test_xmlTextWriterStartCDATA(void) {
! 43563: int test_ret = 0;
! 43564:
! 43565: #if defined(LIBXML_WRITER_ENABLED)
! 43566: int mem_base;
! 43567: int ret_val;
! 43568: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43569: int n_writer;
! 43570:
! 43571: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43572: mem_base = xmlMemBlocks();
! 43573: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43574:
! 43575: ret_val = xmlTextWriterStartCDATA(writer);
! 43576: desret_int(ret_val);
! 43577: call_tests++;
! 43578: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43579: xmlResetLastError();
! 43580: if (mem_base != xmlMemBlocks()) {
! 43581: printf("Leak of %d blocks found in xmlTextWriterStartCDATA",
! 43582: xmlMemBlocks() - mem_base);
! 43583: test_ret++;
! 43584: printf(" %d", n_writer);
! 43585: printf("\n");
! 43586: }
! 43587: }
! 43588: function_tests++;
! 43589: #endif
! 43590:
! 43591: return(test_ret);
! 43592: }
! 43593:
! 43594:
! 43595: static int
! 43596: test_xmlTextWriterStartComment(void) {
! 43597: int test_ret = 0;
! 43598:
! 43599: #if defined(LIBXML_WRITER_ENABLED)
! 43600: int mem_base;
! 43601: int ret_val;
! 43602: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43603: int n_writer;
! 43604:
! 43605: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43606: mem_base = xmlMemBlocks();
! 43607: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43608:
! 43609: ret_val = xmlTextWriterStartComment(writer);
! 43610: desret_int(ret_val);
! 43611: call_tests++;
! 43612: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43613: xmlResetLastError();
! 43614: if (mem_base != xmlMemBlocks()) {
! 43615: printf("Leak of %d blocks found in xmlTextWriterStartComment",
! 43616: xmlMemBlocks() - mem_base);
! 43617: test_ret++;
! 43618: printf(" %d", n_writer);
! 43619: printf("\n");
! 43620: }
! 43621: }
! 43622: function_tests++;
! 43623: #endif
! 43624:
! 43625: return(test_ret);
! 43626: }
! 43627:
! 43628:
! 43629: static int
! 43630: test_xmlTextWriterStartDTD(void) {
! 43631: int test_ret = 0;
! 43632:
! 43633: #if defined(LIBXML_WRITER_ENABLED)
! 43634: int mem_base;
! 43635: int ret_val;
! 43636: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43637: int n_writer;
! 43638: xmlChar * name; /* the name of the DTD */
! 43639: int n_name;
! 43640: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
! 43641: int n_pubid;
! 43642: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
! 43643: int n_sysid;
! 43644:
! 43645: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43646: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 43647: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
! 43648: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
! 43649: mem_base = xmlMemBlocks();
! 43650: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43651: name = gen_const_xmlChar_ptr(n_name, 1);
! 43652: pubid = gen_const_xmlChar_ptr(n_pubid, 2);
! 43653: sysid = gen_const_xmlChar_ptr(n_sysid, 3);
! 43654:
! 43655: ret_val = xmlTextWriterStartDTD(writer, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid);
! 43656: desret_int(ret_val);
! 43657: call_tests++;
! 43658: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43659: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 43660: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 2);
! 43661: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 3);
! 43662: xmlResetLastError();
! 43663: if (mem_base != xmlMemBlocks()) {
! 43664: printf("Leak of %d blocks found in xmlTextWriterStartDTD",
! 43665: xmlMemBlocks() - mem_base);
! 43666: test_ret++;
! 43667: printf(" %d", n_writer);
! 43668: printf(" %d", n_name);
! 43669: printf(" %d", n_pubid);
! 43670: printf(" %d", n_sysid);
! 43671: printf("\n");
! 43672: }
! 43673: }
! 43674: }
! 43675: }
! 43676: }
! 43677: function_tests++;
! 43678: #endif
! 43679:
! 43680: return(test_ret);
! 43681: }
! 43682:
! 43683:
! 43684: static int
! 43685: test_xmlTextWriterStartDTDAttlist(void) {
! 43686: int test_ret = 0;
! 43687:
! 43688: #if defined(LIBXML_WRITER_ENABLED)
! 43689: int mem_base;
! 43690: int ret_val;
! 43691: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43692: int n_writer;
! 43693: xmlChar * name; /* the name of the DTD ATTLIST */
! 43694: int n_name;
! 43695:
! 43696: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43697: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 43698: mem_base = xmlMemBlocks();
! 43699: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43700: name = gen_const_xmlChar_ptr(n_name, 1);
! 43701:
! 43702: ret_val = xmlTextWriterStartDTDAttlist(writer, (const xmlChar *)name);
! 43703: desret_int(ret_val);
! 43704: call_tests++;
! 43705: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43706: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 43707: xmlResetLastError();
! 43708: if (mem_base != xmlMemBlocks()) {
! 43709: printf("Leak of %d blocks found in xmlTextWriterStartDTDAttlist",
! 43710: xmlMemBlocks() - mem_base);
! 43711: test_ret++;
! 43712: printf(" %d", n_writer);
! 43713: printf(" %d", n_name);
! 43714: printf("\n");
! 43715: }
! 43716: }
! 43717: }
! 43718: function_tests++;
! 43719: #endif
! 43720:
! 43721: return(test_ret);
! 43722: }
! 43723:
! 43724:
! 43725: static int
! 43726: test_xmlTextWriterStartDTDElement(void) {
! 43727: int test_ret = 0;
! 43728:
! 43729: #if defined(LIBXML_WRITER_ENABLED)
! 43730: int mem_base;
! 43731: int ret_val;
! 43732: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43733: int n_writer;
! 43734: xmlChar * name; /* the name of the DTD element */
! 43735: int n_name;
! 43736:
! 43737: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43738: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 43739: mem_base = xmlMemBlocks();
! 43740: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43741: name = gen_const_xmlChar_ptr(n_name, 1);
! 43742:
! 43743: ret_val = xmlTextWriterStartDTDElement(writer, (const xmlChar *)name);
! 43744: desret_int(ret_val);
! 43745: call_tests++;
! 43746: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43747: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 43748: xmlResetLastError();
! 43749: if (mem_base != xmlMemBlocks()) {
! 43750: printf("Leak of %d blocks found in xmlTextWriterStartDTDElement",
! 43751: xmlMemBlocks() - mem_base);
! 43752: test_ret++;
! 43753: printf(" %d", n_writer);
! 43754: printf(" %d", n_name);
! 43755: printf("\n");
! 43756: }
! 43757: }
! 43758: }
! 43759: function_tests++;
! 43760: #endif
! 43761:
! 43762: return(test_ret);
! 43763: }
! 43764:
! 43765:
! 43766: static int
! 43767: test_xmlTextWriterStartDTDEntity(void) {
! 43768: int test_ret = 0;
! 43769:
! 43770: #if defined(LIBXML_WRITER_ENABLED)
! 43771: int mem_base;
! 43772: int ret_val;
! 43773: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43774: int n_writer;
! 43775: int pe; /* TRUE if this is a parameter entity, FALSE if not */
! 43776: int n_pe;
! 43777: xmlChar * name; /* the name of the DTD ATTLIST */
! 43778: int n_name;
! 43779:
! 43780: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43781: for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
! 43782: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 43783: mem_base = xmlMemBlocks();
! 43784: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43785: pe = gen_int(n_pe, 1);
! 43786: name = gen_const_xmlChar_ptr(n_name, 2);
! 43787:
! 43788: ret_val = xmlTextWriterStartDTDEntity(writer, pe, (const xmlChar *)name);
! 43789: desret_int(ret_val);
! 43790: call_tests++;
! 43791: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43792: des_int(n_pe, pe, 1);
! 43793: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 43794: xmlResetLastError();
! 43795: if (mem_base != xmlMemBlocks()) {
! 43796: printf("Leak of %d blocks found in xmlTextWriterStartDTDEntity",
! 43797: xmlMemBlocks() - mem_base);
! 43798: test_ret++;
! 43799: printf(" %d", n_writer);
! 43800: printf(" %d", n_pe);
! 43801: printf(" %d", n_name);
! 43802: printf("\n");
! 43803: }
! 43804: }
! 43805: }
! 43806: }
! 43807: function_tests++;
! 43808: #endif
! 43809:
! 43810: return(test_ret);
! 43811: }
! 43812:
! 43813:
! 43814: static int
! 43815: test_xmlTextWriterStartDocument(void) {
! 43816: int test_ret = 0;
! 43817:
! 43818: #if defined(LIBXML_WRITER_ENABLED)
! 43819: int mem_base;
! 43820: int ret_val;
! 43821: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43822: int n_writer;
! 43823: char * version; /* the xml version ("1.0") or NULL for default ("1.0") */
! 43824: int n_version;
! 43825: char * encoding; /* the encoding or NULL for default */
! 43826: int n_encoding;
! 43827: char * standalone; /* "yes" or "no" or NULL for default */
! 43828: int n_standalone;
! 43829:
! 43830: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43831: for (n_version = 0;n_version < gen_nb_const_char_ptr;n_version++) {
! 43832: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
! 43833: for (n_standalone = 0;n_standalone < gen_nb_const_char_ptr;n_standalone++) {
! 43834: mem_base = xmlMemBlocks();
! 43835: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43836: version = gen_const_char_ptr(n_version, 1);
! 43837: encoding = gen_const_char_ptr(n_encoding, 2);
! 43838: standalone = gen_const_char_ptr(n_standalone, 3);
! 43839:
! 43840: ret_val = xmlTextWriterStartDocument(writer, (const char *)version, (const char *)encoding, (const char *)standalone);
! 43841: desret_int(ret_val);
! 43842: call_tests++;
! 43843: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43844: des_const_char_ptr(n_version, (const char *)version, 1);
! 43845: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
! 43846: des_const_char_ptr(n_standalone, (const char *)standalone, 3);
! 43847: xmlResetLastError();
! 43848: if (mem_base != xmlMemBlocks()) {
! 43849: printf("Leak of %d blocks found in xmlTextWriterStartDocument",
! 43850: xmlMemBlocks() - mem_base);
! 43851: test_ret++;
! 43852: printf(" %d", n_writer);
! 43853: printf(" %d", n_version);
! 43854: printf(" %d", n_encoding);
! 43855: printf(" %d", n_standalone);
! 43856: printf("\n");
! 43857: }
! 43858: }
! 43859: }
! 43860: }
! 43861: }
! 43862: function_tests++;
! 43863: #endif
! 43864:
! 43865: return(test_ret);
! 43866: }
! 43867:
! 43868:
! 43869: static int
! 43870: test_xmlTextWriterStartElement(void) {
! 43871: int test_ret = 0;
! 43872:
! 43873: #if defined(LIBXML_WRITER_ENABLED)
! 43874: int mem_base;
! 43875: int ret_val;
! 43876: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43877: int n_writer;
! 43878: xmlChar * name; /* element name */
! 43879: int n_name;
! 43880:
! 43881: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43882: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 43883: mem_base = xmlMemBlocks();
! 43884: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43885: name = gen_const_xmlChar_ptr(n_name, 1);
! 43886:
! 43887: ret_val = xmlTextWriterStartElement(writer, (const xmlChar *)name);
! 43888: desret_int(ret_val);
! 43889: call_tests++;
! 43890: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43891: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 43892: xmlResetLastError();
! 43893: if (mem_base != xmlMemBlocks()) {
! 43894: printf("Leak of %d blocks found in xmlTextWriterStartElement",
! 43895: xmlMemBlocks() - mem_base);
! 43896: test_ret++;
! 43897: printf(" %d", n_writer);
! 43898: printf(" %d", n_name);
! 43899: printf("\n");
! 43900: }
! 43901: }
! 43902: }
! 43903: function_tests++;
! 43904: #endif
! 43905:
! 43906: return(test_ret);
! 43907: }
! 43908:
! 43909:
! 43910: static int
! 43911: test_xmlTextWriterStartElementNS(void) {
! 43912: int test_ret = 0;
! 43913:
! 43914: #if defined(LIBXML_WRITER_ENABLED)
! 43915: int mem_base;
! 43916: int ret_val;
! 43917: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43918: int n_writer;
! 43919: xmlChar * prefix; /* namespace prefix or NULL */
! 43920: int n_prefix;
! 43921: xmlChar * name; /* element local name */
! 43922: int n_name;
! 43923: xmlChar * namespaceURI; /* namespace URI or NULL */
! 43924: int n_namespaceURI;
! 43925:
! 43926: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43927: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
! 43928: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 43929: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
! 43930: mem_base = xmlMemBlocks();
! 43931: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43932: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
! 43933: name = gen_const_xmlChar_ptr(n_name, 2);
! 43934: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
! 43935:
! 43936: ret_val = xmlTextWriterStartElementNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI);
! 43937: desret_int(ret_val);
! 43938: call_tests++;
! 43939: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43940: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
! 43941: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 43942: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3);
! 43943: xmlResetLastError();
! 43944: if (mem_base != xmlMemBlocks()) {
! 43945: printf("Leak of %d blocks found in xmlTextWriterStartElementNS",
! 43946: xmlMemBlocks() - mem_base);
! 43947: test_ret++;
! 43948: printf(" %d", n_writer);
! 43949: printf(" %d", n_prefix);
! 43950: printf(" %d", n_name);
! 43951: printf(" %d", n_namespaceURI);
! 43952: printf("\n");
! 43953: }
! 43954: }
! 43955: }
! 43956: }
! 43957: }
! 43958: function_tests++;
! 43959: #endif
! 43960:
! 43961: return(test_ret);
! 43962: }
! 43963:
! 43964:
! 43965: static int
! 43966: test_xmlTextWriterStartPI(void) {
! 43967: int test_ret = 0;
! 43968:
! 43969: #if defined(LIBXML_WRITER_ENABLED)
! 43970: int mem_base;
! 43971: int ret_val;
! 43972: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43973: int n_writer;
! 43974: xmlChar * target; /* PI target */
! 43975: int n_target;
! 43976:
! 43977: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43978: for (n_target = 0;n_target < gen_nb_const_xmlChar_ptr;n_target++) {
! 43979: mem_base = xmlMemBlocks();
! 43980: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43981: target = gen_const_xmlChar_ptr(n_target, 1);
! 43982:
! 43983: ret_val = xmlTextWriterStartPI(writer, (const xmlChar *)target);
! 43984: desret_int(ret_val);
! 43985: call_tests++;
! 43986: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43987: des_const_xmlChar_ptr(n_target, (const xmlChar *)target, 1);
! 43988: xmlResetLastError();
! 43989: if (mem_base != xmlMemBlocks()) {
! 43990: printf("Leak of %d blocks found in xmlTextWriterStartPI",
! 43991: xmlMemBlocks() - mem_base);
! 43992: test_ret++;
! 43993: printf(" %d", n_writer);
! 43994: printf(" %d", n_target);
! 43995: printf("\n");
! 43996: }
! 43997: }
! 43998: }
! 43999: function_tests++;
! 44000: #endif
! 44001:
! 44002: return(test_ret);
! 44003: }
! 44004:
! 44005:
! 44006: static int
! 44007: test_xmlTextWriterWriteAttribute(void) {
! 44008: int test_ret = 0;
! 44009:
! 44010: #if defined(LIBXML_WRITER_ENABLED)
! 44011: int mem_base;
! 44012: int ret_val;
! 44013: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 44014: int n_writer;
! 44015: xmlChar * name; /* attribute name */
! 44016: int n_name;
! 44017: xmlChar * content; /* attribute content */
! 44018: int n_content;
! 44019:
! 44020: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 44021: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 44022: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 44023: mem_base = xmlMemBlocks();
! 44024: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 44025: name = gen_const_xmlChar_ptr(n_name, 1);
! 44026: content = gen_const_xmlChar_ptr(n_content, 2);
! 44027:
! 44028: ret_val = xmlTextWriterWriteAttribute(writer, (const xmlChar *)name, (const xmlChar *)content);
! 44029: desret_int(ret_val);
! 44030: call_tests++;
! 44031: des_xmlTextWriterPtr(n_writer, writer, 0);
! 44032: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 44033: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
! 44034: xmlResetLastError();
! 44035: if (mem_base != xmlMemBlocks()) {
! 44036: printf("Leak of %d blocks found in xmlTextWriterWriteAttribute",
! 44037: xmlMemBlocks() - mem_base);
! 44038: test_ret++;
! 44039: printf(" %d", n_writer);
! 44040: printf(" %d", n_name);
! 44041: printf(" %d", n_content);
! 44042: printf("\n");
! 44043: }
! 44044: }
! 44045: }
! 44046: }
! 44047: function_tests++;
! 44048: #endif
! 44049:
! 44050: return(test_ret);
! 44051: }
! 44052:
! 44053:
! 44054: static int
! 44055: test_xmlTextWriterWriteAttributeNS(void) {
! 44056: int test_ret = 0;
! 44057:
! 44058: #if defined(LIBXML_WRITER_ENABLED)
! 44059: int mem_base;
! 44060: int ret_val;
! 44061: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 44062: int n_writer;
! 44063: xmlChar * prefix; /* namespace prefix */
! 44064: int n_prefix;
! 44065: xmlChar * name; /* attribute local name */
! 44066: int n_name;
! 44067: xmlChar * namespaceURI; /* namespace URI */
! 44068: int n_namespaceURI;
! 44069: xmlChar * content; /* attribute content */
! 44070: int n_content;
! 44071:
! 44072: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 44073: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
! 44074: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 44075: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
! 44076: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 44077: mem_base = xmlMemBlocks();
! 44078: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 44079: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
! 44080: name = gen_const_xmlChar_ptr(n_name, 2);
! 44081: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
! 44082: content = gen_const_xmlChar_ptr(n_content, 4);
! 44083:
! 44084: ret_val = xmlTextWriterWriteAttributeNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI, (const xmlChar *)content);
! 44085: desret_int(ret_val);
! 44086: call_tests++;
! 44087: des_xmlTextWriterPtr(n_writer, writer, 0);
! 44088: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
! 44089: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 44090: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3);
! 44091: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 4);
! 44092: xmlResetLastError();
! 44093: if (mem_base != xmlMemBlocks()) {
! 44094: printf("Leak of %d blocks found in xmlTextWriterWriteAttributeNS",
! 44095: xmlMemBlocks() - mem_base);
! 44096: test_ret++;
! 44097: printf(" %d", n_writer);
! 44098: printf(" %d", n_prefix);
! 44099: printf(" %d", n_name);
! 44100: printf(" %d", n_namespaceURI);
! 44101: printf(" %d", n_content);
! 44102: printf("\n");
! 44103: }
! 44104: }
! 44105: }
! 44106: }
! 44107: }
! 44108: }
! 44109: function_tests++;
! 44110: #endif
! 44111:
! 44112: return(test_ret);
! 44113: }
! 44114:
! 44115:
! 44116: static int
! 44117: test_xmlTextWriterWriteBase64(void) {
! 44118: int test_ret = 0;
! 44119:
! 44120: #if defined(LIBXML_WRITER_ENABLED)
! 44121: int mem_base;
! 44122: int ret_val;
! 44123: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 44124: int n_writer;
! 44125: char * data; /* binary data */
! 44126: int n_data;
! 44127: int start; /* the position within the data of the first byte to encode */
! 44128: int n_start;
! 44129: int len; /* the number of bytes to encode */
! 44130: int n_len;
! 44131:
! 44132: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 44133: for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) {
! 44134: for (n_start = 0;n_start < gen_nb_int;n_start++) {
! 44135: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 44136: mem_base = xmlMemBlocks();
! 44137: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 44138: data = gen_const_char_ptr(n_data, 1);
! 44139: start = gen_int(n_start, 2);
! 44140: len = gen_int(n_len, 3);
! 44141:
! 44142: ret_val = xmlTextWriterWriteBase64(writer, (const char *)data, start, len);
! 44143: desret_int(ret_val);
! 44144: call_tests++;
! 44145: des_xmlTextWriterPtr(n_writer, writer, 0);
! 44146: des_const_char_ptr(n_data, (const char *)data, 1);
! 44147: des_int(n_start, start, 2);
! 44148: des_int(n_len, len, 3);
! 44149: xmlResetLastError();
! 44150: if (mem_base != xmlMemBlocks()) {
! 44151: printf("Leak of %d blocks found in xmlTextWriterWriteBase64",
! 44152: xmlMemBlocks() - mem_base);
! 44153: test_ret++;
! 44154: printf(" %d", n_writer);
! 44155: printf(" %d", n_data);
! 44156: printf(" %d", n_start);
! 44157: printf(" %d", n_len);
! 44158: printf("\n");
! 44159: }
! 44160: }
! 44161: }
! 44162: }
! 44163: }
! 44164: function_tests++;
! 44165: #endif
! 44166:
! 44167: return(test_ret);
! 44168: }
! 44169:
! 44170:
! 44171: static int
! 44172: test_xmlTextWriterWriteBinHex(void) {
! 44173: int test_ret = 0;
! 44174:
! 44175: #if defined(LIBXML_WRITER_ENABLED)
! 44176: int mem_base;
! 44177: int ret_val;
! 44178: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 44179: int n_writer;
! 44180: char * data; /* binary data */
! 44181: int n_data;
! 44182: int start; /* the position within the data of the first byte to encode */
! 44183: int n_start;
! 44184: int len; /* the number of bytes to encode */
! 44185: int n_len;
! 44186:
! 44187: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 44188: for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) {
! 44189: for (n_start = 0;n_start < gen_nb_int;n_start++) {
! 44190: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 44191: mem_base = xmlMemBlocks();
! 44192: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 44193: data = gen_const_char_ptr(n_data, 1);
! 44194: start = gen_int(n_start, 2);
! 44195: len = gen_int(n_len, 3);
! 44196:
! 44197: ret_val = xmlTextWriterWriteBinHex(writer, (const char *)data, start, len);
! 44198: desret_int(ret_val);
! 44199: call_tests++;
! 44200: des_xmlTextWriterPtr(n_writer, writer, 0);
! 44201: des_const_char_ptr(n_data, (const char *)data, 1);
! 44202: des_int(n_start, start, 2);
! 44203: des_int(n_len, len, 3);
! 44204: xmlResetLastError();
! 44205: if (mem_base != xmlMemBlocks()) {
! 44206: printf("Leak of %d blocks found in xmlTextWriterWriteBinHex",
! 44207: xmlMemBlocks() - mem_base);
! 44208: test_ret++;
! 44209: printf(" %d", n_writer);
! 44210: printf(" %d", n_data);
! 44211: printf(" %d", n_start);
! 44212: printf(" %d", n_len);
! 44213: printf("\n");
! 44214: }
! 44215: }
! 44216: }
! 44217: }
! 44218: }
! 44219: function_tests++;
! 44220: #endif
! 44221:
! 44222: return(test_ret);
! 44223: }
! 44224:
! 44225:
! 44226: static int
! 44227: test_xmlTextWriterWriteCDATA(void) {
! 44228: int test_ret = 0;
! 44229:
! 44230: #if defined(LIBXML_WRITER_ENABLED)
! 44231: int mem_base;
! 44232: int ret_val;
! 44233: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 44234: int n_writer;
! 44235: xmlChar * content; /* CDATA content */
! 44236: int n_content;
! 44237:
! 44238: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 44239: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 44240: mem_base = xmlMemBlocks();
! 44241: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 44242: content = gen_const_xmlChar_ptr(n_content, 1);
! 44243:
! 44244: ret_val = xmlTextWriterWriteCDATA(writer, (const xmlChar *)content);
! 44245: desret_int(ret_val);
! 44246: call_tests++;
! 44247: des_xmlTextWriterPtr(n_writer, writer, 0);
! 44248: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
! 44249: xmlResetLastError();
! 44250: if (mem_base != xmlMemBlocks()) {
! 44251: printf("Leak of %d blocks found in xmlTextWriterWriteCDATA",
! 44252: xmlMemBlocks() - mem_base);
! 44253: test_ret++;
! 44254: printf(" %d", n_writer);
! 44255: printf(" %d", n_content);
! 44256: printf("\n");
! 44257: }
! 44258: }
! 44259: }
! 44260: function_tests++;
! 44261: #endif
! 44262:
! 44263: return(test_ret);
! 44264: }
! 44265:
! 44266:
! 44267: static int
! 44268: test_xmlTextWriterWriteComment(void) {
! 44269: int test_ret = 0;
! 44270:
! 44271: #if defined(LIBXML_WRITER_ENABLED)
! 44272: int mem_base;
! 44273: int ret_val;
! 44274: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 44275: int n_writer;
! 44276: xmlChar * content; /* comment string */
! 44277: int n_content;
! 44278:
! 44279: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 44280: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 44281: mem_base = xmlMemBlocks();
! 44282: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 44283: content = gen_const_xmlChar_ptr(n_content, 1);
! 44284:
! 44285: ret_val = xmlTextWriterWriteComment(writer, (const xmlChar *)content);
! 44286: desret_int(ret_val);
! 44287: call_tests++;
! 44288: des_xmlTextWriterPtr(n_writer, writer, 0);
! 44289: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
! 44290: xmlResetLastError();
! 44291: if (mem_base != xmlMemBlocks()) {
! 44292: printf("Leak of %d blocks found in xmlTextWriterWriteComment",
! 44293: xmlMemBlocks() - mem_base);
! 44294: test_ret++;
! 44295: printf(" %d", n_writer);
! 44296: printf(" %d", n_content);
! 44297: printf("\n");
! 44298: }
! 44299: }
! 44300: }
! 44301: function_tests++;
! 44302: #endif
! 44303:
! 44304: return(test_ret);
! 44305: }
! 44306:
! 44307:
! 44308: static int
! 44309: test_xmlTextWriterWriteDTD(void) {
! 44310: int test_ret = 0;
! 44311:
! 44312: #if defined(LIBXML_WRITER_ENABLED)
! 44313: int mem_base;
! 44314: int ret_val;
! 44315: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 44316: int n_writer;
! 44317: xmlChar * name; /* the name of the DTD */
! 44318: int n_name;
! 44319: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
! 44320: int n_pubid;
! 44321: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
! 44322: int n_sysid;
! 44323: xmlChar * subset; /* string content of the DTD */
! 44324: int n_subset;
! 44325:
! 44326: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 44327: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 44328: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
! 44329: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
! 44330: for (n_subset = 0;n_subset < gen_nb_const_xmlChar_ptr;n_subset++) {
! 44331: mem_base = xmlMemBlocks();
! 44332: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 44333: name = gen_const_xmlChar_ptr(n_name, 1);
! 44334: pubid = gen_const_xmlChar_ptr(n_pubid, 2);
! 44335: sysid = gen_const_xmlChar_ptr(n_sysid, 3);
! 44336: subset = gen_const_xmlChar_ptr(n_subset, 4);
! 44337:
! 44338: ret_val = xmlTextWriterWriteDTD(writer, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)subset);
! 44339: desret_int(ret_val);
! 44340: call_tests++;
! 44341: des_xmlTextWriterPtr(n_writer, writer, 0);
! 44342: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 44343: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 2);
! 44344: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 3);
! 44345: des_const_xmlChar_ptr(n_subset, (const xmlChar *)subset, 4);
! 44346: xmlResetLastError();
! 44347: if (mem_base != xmlMemBlocks()) {
! 44348: printf("Leak of %d blocks found in xmlTextWriterWriteDTD",
! 44349: xmlMemBlocks() - mem_base);
! 44350: test_ret++;
! 44351: printf(" %d", n_writer);
! 44352: printf(" %d", n_name);
! 44353: printf(" %d", n_pubid);
! 44354: printf(" %d", n_sysid);
! 44355: printf(" %d", n_subset);
! 44356: printf("\n");
! 44357: }
! 44358: }
! 44359: }
! 44360: }
! 44361: }
! 44362: }
! 44363: function_tests++;
! 44364: #endif
! 44365:
! 44366: return(test_ret);
! 44367: }
! 44368:
! 44369:
! 44370: static int
! 44371: test_xmlTextWriterWriteDTDAttlist(void) {
! 44372: int test_ret = 0;
! 44373:
! 44374: #if defined(LIBXML_WRITER_ENABLED)
! 44375: int mem_base;
! 44376: int ret_val;
! 44377: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 44378: int n_writer;
! 44379: xmlChar * name; /* the name of the DTD ATTLIST */
! 44380: int n_name;
! 44381: xmlChar * content; /* content of the ATTLIST */
! 44382: int n_content;
! 44383:
! 44384: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 44385: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 44386: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 44387: mem_base = xmlMemBlocks();
! 44388: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 44389: name = gen_const_xmlChar_ptr(n_name, 1);
! 44390: content = gen_const_xmlChar_ptr(n_content, 2);
! 44391:
! 44392: ret_val = xmlTextWriterWriteDTDAttlist(writer, (const xmlChar *)name, (const xmlChar *)content);
! 44393: desret_int(ret_val);
! 44394: call_tests++;
! 44395: des_xmlTextWriterPtr(n_writer, writer, 0);
! 44396: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 44397: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
! 44398: xmlResetLastError();
! 44399: if (mem_base != xmlMemBlocks()) {
! 44400: printf("Leak of %d blocks found in xmlTextWriterWriteDTDAttlist",
! 44401: xmlMemBlocks() - mem_base);
! 44402: test_ret++;
! 44403: printf(" %d", n_writer);
! 44404: printf(" %d", n_name);
! 44405: printf(" %d", n_content);
! 44406: printf("\n");
! 44407: }
! 44408: }
! 44409: }
! 44410: }
! 44411: function_tests++;
! 44412: #endif
! 44413:
! 44414: return(test_ret);
! 44415: }
! 44416:
! 44417:
! 44418: static int
! 44419: test_xmlTextWriterWriteDTDElement(void) {
! 44420: int test_ret = 0;
! 44421:
! 44422: #if defined(LIBXML_WRITER_ENABLED)
! 44423: int mem_base;
! 44424: int ret_val;
! 44425: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 44426: int n_writer;
! 44427: xmlChar * name; /* the name of the DTD element */
! 44428: int n_name;
! 44429: xmlChar * content; /* content of the element */
! 44430: int n_content;
! 44431:
! 44432: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 44433: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 44434: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 44435: mem_base = xmlMemBlocks();
! 44436: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 44437: name = gen_const_xmlChar_ptr(n_name, 1);
! 44438: content = gen_const_xmlChar_ptr(n_content, 2);
! 44439:
! 44440: ret_val = xmlTextWriterWriteDTDElement(writer, (const xmlChar *)name, (const xmlChar *)content);
! 44441: desret_int(ret_val);
! 44442: call_tests++;
! 44443: des_xmlTextWriterPtr(n_writer, writer, 0);
! 44444: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 44445: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
! 44446: xmlResetLastError();
! 44447: if (mem_base != xmlMemBlocks()) {
! 44448: printf("Leak of %d blocks found in xmlTextWriterWriteDTDElement",
! 44449: xmlMemBlocks() - mem_base);
! 44450: test_ret++;
! 44451: printf(" %d", n_writer);
! 44452: printf(" %d", n_name);
! 44453: printf(" %d", n_content);
! 44454: printf("\n");
! 44455: }
! 44456: }
! 44457: }
! 44458: }
! 44459: function_tests++;
! 44460: #endif
! 44461:
! 44462: return(test_ret);
! 44463: }
! 44464:
! 44465:
! 44466: static int
! 44467: test_xmlTextWriterWriteDTDEntity(void) {
! 44468: int test_ret = 0;
! 44469:
! 44470: #if defined(LIBXML_WRITER_ENABLED)
! 44471: int mem_base;
! 44472: int ret_val;
! 44473: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 44474: int n_writer;
! 44475: int pe; /* TRUE if this is a parameter entity, FALSE if not */
! 44476: int n_pe;
! 44477: xmlChar * name; /* the name of the DTD entity */
! 44478: int n_name;
! 44479: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
! 44480: int n_pubid;
! 44481: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
! 44482: int n_sysid;
! 44483: xmlChar * ndataid; /* the xml notation name. */
! 44484: int n_ndataid;
! 44485: xmlChar * content; /* content of the entity */
! 44486: int n_content;
! 44487:
! 44488: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 44489: for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
! 44490: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 44491: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
! 44492: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
! 44493: for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) {
! 44494: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 44495: mem_base = xmlMemBlocks();
! 44496: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 44497: pe = gen_int(n_pe, 1);
! 44498: name = gen_const_xmlChar_ptr(n_name, 2);
! 44499: pubid = gen_const_xmlChar_ptr(n_pubid, 3);
! 44500: sysid = gen_const_xmlChar_ptr(n_sysid, 4);
! 44501: ndataid = gen_const_xmlChar_ptr(n_ndataid, 5);
! 44502: content = gen_const_xmlChar_ptr(n_content, 6);
! 44503:
! 44504: ret_val = xmlTextWriterWriteDTDEntity(writer, pe, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)ndataid, (const xmlChar *)content);
! 44505: desret_int(ret_val);
! 44506: call_tests++;
! 44507: des_xmlTextWriterPtr(n_writer, writer, 0);
! 44508: des_int(n_pe, pe, 1);
! 44509: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 44510: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 3);
! 44511: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 4);
! 44512: des_const_xmlChar_ptr(n_ndataid, (const xmlChar *)ndataid, 5);
! 44513: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 6);
! 44514: xmlResetLastError();
! 44515: if (mem_base != xmlMemBlocks()) {
! 44516: printf("Leak of %d blocks found in xmlTextWriterWriteDTDEntity",
! 44517: xmlMemBlocks() - mem_base);
! 44518: test_ret++;
! 44519: printf(" %d", n_writer);
! 44520: printf(" %d", n_pe);
! 44521: printf(" %d", n_name);
! 44522: printf(" %d", n_pubid);
! 44523: printf(" %d", n_sysid);
! 44524: printf(" %d", n_ndataid);
! 44525: printf(" %d", n_content);
! 44526: printf("\n");
! 44527: }
! 44528: }
! 44529: }
! 44530: }
! 44531: }
! 44532: }
! 44533: }
! 44534: }
! 44535: function_tests++;
! 44536: #endif
! 44537:
! 44538: return(test_ret);
! 44539: }
! 44540:
! 44541:
! 44542: static int
! 44543: test_xmlTextWriterWriteDTDExternalEntity(void) {
! 44544: int test_ret = 0;
! 44545:
! 44546: #if defined(LIBXML_WRITER_ENABLED)
! 44547: int mem_base;
! 44548: int ret_val;
! 44549: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 44550: int n_writer;
! 44551: int pe; /* TRUE if this is a parameter entity, FALSE if not */
! 44552: int n_pe;
! 44553: xmlChar * name; /* the name of the DTD entity */
! 44554: int n_name;
! 44555: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
! 44556: int n_pubid;
! 44557: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
! 44558: int n_sysid;
! 44559: xmlChar * ndataid; /* the xml notation name. */
! 44560: int n_ndataid;
! 44561:
! 44562: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 44563: for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
! 44564: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 44565: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
! 44566: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
! 44567: for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) {
! 44568: mem_base = xmlMemBlocks();
! 44569: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 44570: pe = gen_int(n_pe, 1);
! 44571: name = gen_const_xmlChar_ptr(n_name, 2);
! 44572: pubid = gen_const_xmlChar_ptr(n_pubid, 3);
! 44573: sysid = gen_const_xmlChar_ptr(n_sysid, 4);
! 44574: ndataid = gen_const_xmlChar_ptr(n_ndataid, 5);
! 44575:
! 44576: ret_val = xmlTextWriterWriteDTDExternalEntity(writer, pe, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)ndataid);
! 44577: desret_int(ret_val);
! 44578: call_tests++;
! 44579: des_xmlTextWriterPtr(n_writer, writer, 0);
! 44580: des_int(n_pe, pe, 1);
! 44581: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 44582: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 3);
! 44583: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 4);
! 44584: des_const_xmlChar_ptr(n_ndataid, (const xmlChar *)ndataid, 5);
! 44585: xmlResetLastError();
! 44586: if (mem_base != xmlMemBlocks()) {
! 44587: printf("Leak of %d blocks found in xmlTextWriterWriteDTDExternalEntity",
! 44588: xmlMemBlocks() - mem_base);
! 44589: test_ret++;
! 44590: printf(" %d", n_writer);
! 44591: printf(" %d", n_pe);
! 44592: printf(" %d", n_name);
! 44593: printf(" %d", n_pubid);
! 44594: printf(" %d", n_sysid);
! 44595: printf(" %d", n_ndataid);
! 44596: printf("\n");
! 44597: }
! 44598: }
! 44599: }
! 44600: }
! 44601: }
! 44602: }
! 44603: }
! 44604: function_tests++;
! 44605: #endif
! 44606:
! 44607: return(test_ret);
! 44608: }
! 44609:
! 44610:
! 44611: static int
! 44612: test_xmlTextWriterWriteDTDExternalEntityContents(void) {
! 44613: int test_ret = 0;
! 44614:
! 44615: #if defined(LIBXML_WRITER_ENABLED)
! 44616: int mem_base;
! 44617: int ret_val;
! 44618: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 44619: int n_writer;
! 44620: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
! 44621: int n_pubid;
! 44622: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
! 44623: int n_sysid;
! 44624: xmlChar * ndataid; /* the xml notation name. */
! 44625: int n_ndataid;
! 44626:
! 44627: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 44628: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
! 44629: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
! 44630: for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) {
! 44631: mem_base = xmlMemBlocks();
! 44632: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 44633: pubid = gen_const_xmlChar_ptr(n_pubid, 1);
! 44634: sysid = gen_const_xmlChar_ptr(n_sysid, 2);
! 44635: ndataid = gen_const_xmlChar_ptr(n_ndataid, 3);
! 44636:
! 44637: ret_val = xmlTextWriterWriteDTDExternalEntityContents(writer, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)ndataid);
! 44638: desret_int(ret_val);
! 44639: call_tests++;
! 44640: des_xmlTextWriterPtr(n_writer, writer, 0);
! 44641: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 1);
! 44642: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 2);
! 44643: des_const_xmlChar_ptr(n_ndataid, (const xmlChar *)ndataid, 3);
! 44644: xmlResetLastError();
! 44645: if (mem_base != xmlMemBlocks()) {
! 44646: printf("Leak of %d blocks found in xmlTextWriterWriteDTDExternalEntityContents",
! 44647: xmlMemBlocks() - mem_base);
! 44648: test_ret++;
! 44649: printf(" %d", n_writer);
! 44650: printf(" %d", n_pubid);
! 44651: printf(" %d", n_sysid);
! 44652: printf(" %d", n_ndataid);
! 44653: printf("\n");
! 44654: }
! 44655: }
! 44656: }
! 44657: }
! 44658: }
! 44659: function_tests++;
! 44660: #endif
! 44661:
! 44662: return(test_ret);
! 44663: }
! 44664:
! 44665:
! 44666: static int
! 44667: test_xmlTextWriterWriteDTDInternalEntity(void) {
! 44668: int test_ret = 0;
! 44669:
! 44670: #if defined(LIBXML_WRITER_ENABLED)
! 44671: int mem_base;
! 44672: int ret_val;
! 44673: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 44674: int n_writer;
! 44675: int pe; /* TRUE if this is a parameter entity, FALSE if not */
! 44676: int n_pe;
! 44677: xmlChar * name; /* the name of the DTD entity */
! 44678: int n_name;
! 44679: xmlChar * content; /* content of the entity */
! 44680: int n_content;
! 44681:
! 44682: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 44683: for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
! 44684: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 44685: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 44686: mem_base = xmlMemBlocks();
! 44687: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 44688: pe = gen_int(n_pe, 1);
! 44689: name = gen_const_xmlChar_ptr(n_name, 2);
! 44690: content = gen_const_xmlChar_ptr(n_content, 3);
! 44691:
! 44692: ret_val = xmlTextWriterWriteDTDInternalEntity(writer, pe, (const xmlChar *)name, (const xmlChar *)content);
! 44693: desret_int(ret_val);
! 44694: call_tests++;
! 44695: des_xmlTextWriterPtr(n_writer, writer, 0);
! 44696: des_int(n_pe, pe, 1);
! 44697: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 44698: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
! 44699: xmlResetLastError();
! 44700: if (mem_base != xmlMemBlocks()) {
! 44701: printf("Leak of %d blocks found in xmlTextWriterWriteDTDInternalEntity",
! 44702: xmlMemBlocks() - mem_base);
! 44703: test_ret++;
! 44704: printf(" %d", n_writer);
! 44705: printf(" %d", n_pe);
! 44706: printf(" %d", n_name);
! 44707: printf(" %d", n_content);
! 44708: printf("\n");
! 44709: }
! 44710: }
! 44711: }
! 44712: }
! 44713: }
! 44714: function_tests++;
! 44715: #endif
! 44716:
! 44717: return(test_ret);
! 44718: }
! 44719:
! 44720:
! 44721: static int
! 44722: test_xmlTextWriterWriteDTDNotation(void) {
! 44723: int test_ret = 0;
! 44724:
! 44725: #if defined(LIBXML_WRITER_ENABLED)
! 44726: int mem_base;
! 44727: int ret_val;
! 44728: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 44729: int n_writer;
! 44730: xmlChar * name; /* the name of the xml notation */
! 44731: int n_name;
! 44732: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
! 44733: int n_pubid;
! 44734: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
! 44735: int n_sysid;
! 44736:
! 44737: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 44738: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 44739: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
! 44740: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
! 44741: mem_base = xmlMemBlocks();
! 44742: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 44743: name = gen_const_xmlChar_ptr(n_name, 1);
! 44744: pubid = gen_const_xmlChar_ptr(n_pubid, 2);
! 44745: sysid = gen_const_xmlChar_ptr(n_sysid, 3);
! 44746:
! 44747: ret_val = xmlTextWriterWriteDTDNotation(writer, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid);
! 44748: desret_int(ret_val);
! 44749: call_tests++;
! 44750: des_xmlTextWriterPtr(n_writer, writer, 0);
! 44751: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 44752: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 2);
! 44753: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 3);
! 44754: xmlResetLastError();
! 44755: if (mem_base != xmlMemBlocks()) {
! 44756: printf("Leak of %d blocks found in xmlTextWriterWriteDTDNotation",
! 44757: xmlMemBlocks() - mem_base);
! 44758: test_ret++;
! 44759: printf(" %d", n_writer);
! 44760: printf(" %d", n_name);
! 44761: printf(" %d", n_pubid);
! 44762: printf(" %d", n_sysid);
! 44763: printf("\n");
! 44764: }
! 44765: }
! 44766: }
! 44767: }
! 44768: }
! 44769: function_tests++;
! 44770: #endif
! 44771:
! 44772: return(test_ret);
! 44773: }
! 44774:
! 44775:
! 44776: static int
! 44777: test_xmlTextWriterWriteElement(void) {
! 44778: int test_ret = 0;
! 44779:
! 44780: #if defined(LIBXML_WRITER_ENABLED)
! 44781: int mem_base;
! 44782: int ret_val;
! 44783: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 44784: int n_writer;
! 44785: xmlChar * name; /* element name */
! 44786: int n_name;
! 44787: xmlChar * content; /* element content */
! 44788: int n_content;
! 44789:
! 44790: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 44791: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 44792: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 44793: mem_base = xmlMemBlocks();
! 44794: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 44795: name = gen_const_xmlChar_ptr(n_name, 1);
! 44796: content = gen_const_xmlChar_ptr(n_content, 2);
! 44797:
! 44798: ret_val = xmlTextWriterWriteElement(writer, (const xmlChar *)name, (const xmlChar *)content);
! 44799: desret_int(ret_val);
! 44800: call_tests++;
! 44801: des_xmlTextWriterPtr(n_writer, writer, 0);
! 44802: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 44803: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
! 44804: xmlResetLastError();
! 44805: if (mem_base != xmlMemBlocks()) {
! 44806: printf("Leak of %d blocks found in xmlTextWriterWriteElement",
! 44807: xmlMemBlocks() - mem_base);
! 44808: test_ret++;
! 44809: printf(" %d", n_writer);
! 44810: printf(" %d", n_name);
! 44811: printf(" %d", n_content);
! 44812: printf("\n");
! 44813: }
! 44814: }
! 44815: }
! 44816: }
! 44817: function_tests++;
! 44818: #endif
! 44819:
! 44820: return(test_ret);
! 44821: }
! 44822:
! 44823:
! 44824: static int
! 44825: test_xmlTextWriterWriteElementNS(void) {
! 44826: int test_ret = 0;
! 44827:
! 44828: #if defined(LIBXML_WRITER_ENABLED)
! 44829: int mem_base;
! 44830: int ret_val;
! 44831: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 44832: int n_writer;
! 44833: xmlChar * prefix; /* namespace prefix */
! 44834: int n_prefix;
! 44835: xmlChar * name; /* element local name */
! 44836: int n_name;
! 44837: xmlChar * namespaceURI; /* namespace URI */
! 44838: int n_namespaceURI;
! 44839: xmlChar * content; /* element content */
! 44840: int n_content;
! 44841:
! 44842: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 44843: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
! 44844: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 44845: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
! 44846: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 44847: mem_base = xmlMemBlocks();
! 44848: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 44849: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
! 44850: name = gen_const_xmlChar_ptr(n_name, 2);
! 44851: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
! 44852: content = gen_const_xmlChar_ptr(n_content, 4);
! 44853:
! 44854: ret_val = xmlTextWriterWriteElementNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI, (const xmlChar *)content);
! 44855: desret_int(ret_val);
! 44856: call_tests++;
! 44857: des_xmlTextWriterPtr(n_writer, writer, 0);
! 44858: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
! 44859: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
! 44860: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3);
! 44861: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 4);
! 44862: xmlResetLastError();
! 44863: if (mem_base != xmlMemBlocks()) {
! 44864: printf("Leak of %d blocks found in xmlTextWriterWriteElementNS",
! 44865: xmlMemBlocks() - mem_base);
! 44866: test_ret++;
! 44867: printf(" %d", n_writer);
! 44868: printf(" %d", n_prefix);
! 44869: printf(" %d", n_name);
! 44870: printf(" %d", n_namespaceURI);
! 44871: printf(" %d", n_content);
! 44872: printf("\n");
! 44873: }
! 44874: }
! 44875: }
! 44876: }
! 44877: }
! 44878: }
! 44879: function_tests++;
! 44880: #endif
! 44881:
! 44882: return(test_ret);
! 44883: }
! 44884:
! 44885:
! 44886: static int
! 44887: test_xmlTextWriterWriteFormatAttribute(void) {
! 44888: int test_ret = 0;
! 44889:
! 44890:
! 44891: /* missing type support */
! 44892: return(test_ret);
! 44893: }
! 44894:
! 44895:
! 44896: static int
! 44897: test_xmlTextWriterWriteFormatAttributeNS(void) {
! 44898: int test_ret = 0;
! 44899:
! 44900:
! 44901: /* missing type support */
! 44902: return(test_ret);
! 44903: }
! 44904:
! 44905:
! 44906: static int
! 44907: test_xmlTextWriterWriteFormatCDATA(void) {
! 44908: int test_ret = 0;
! 44909:
! 44910:
! 44911: /* missing type support */
! 44912: return(test_ret);
! 44913: }
! 44914:
! 44915:
! 44916: static int
! 44917: test_xmlTextWriterWriteFormatComment(void) {
! 44918: int test_ret = 0;
! 44919:
! 44920:
! 44921: /* missing type support */
! 44922: return(test_ret);
! 44923: }
! 44924:
! 44925:
! 44926: static int
! 44927: test_xmlTextWriterWriteFormatDTD(void) {
! 44928: int test_ret = 0;
! 44929:
! 44930:
! 44931: /* missing type support */
! 44932: return(test_ret);
! 44933: }
! 44934:
! 44935:
! 44936: static int
! 44937: test_xmlTextWriterWriteFormatDTDAttlist(void) {
! 44938: int test_ret = 0;
! 44939:
! 44940:
! 44941: /* missing type support */
! 44942: return(test_ret);
! 44943: }
! 44944:
! 44945:
! 44946: static int
! 44947: test_xmlTextWriterWriteFormatDTDElement(void) {
! 44948: int test_ret = 0;
! 44949:
! 44950:
! 44951: /* missing type support */
! 44952: return(test_ret);
! 44953: }
! 44954:
! 44955:
! 44956: static int
! 44957: test_xmlTextWriterWriteFormatDTDInternalEntity(void) {
! 44958: int test_ret = 0;
! 44959:
! 44960:
! 44961: /* missing type support */
! 44962: return(test_ret);
! 44963: }
! 44964:
! 44965:
! 44966: static int
! 44967: test_xmlTextWriterWriteFormatElement(void) {
! 44968: int test_ret = 0;
! 44969:
! 44970:
! 44971: /* missing type support */
! 44972: return(test_ret);
! 44973: }
! 44974:
! 44975:
! 44976: static int
! 44977: test_xmlTextWriterWriteFormatElementNS(void) {
! 44978: int test_ret = 0;
! 44979:
! 44980:
! 44981: /* missing type support */
! 44982: return(test_ret);
! 44983: }
! 44984:
! 44985:
! 44986: static int
! 44987: test_xmlTextWriterWriteFormatPI(void) {
! 44988: int test_ret = 0;
! 44989:
! 44990:
! 44991: /* missing type support */
! 44992: return(test_ret);
! 44993: }
! 44994:
! 44995:
! 44996: static int
! 44997: test_xmlTextWriterWriteFormatRaw(void) {
! 44998: int test_ret = 0;
! 44999:
! 45000:
! 45001: /* missing type support */
! 45002: return(test_ret);
! 45003: }
! 45004:
! 45005:
! 45006: static int
! 45007: test_xmlTextWriterWriteFormatString(void) {
! 45008: int test_ret = 0;
! 45009:
! 45010:
! 45011: /* missing type support */
! 45012: return(test_ret);
! 45013: }
! 45014:
! 45015:
! 45016: static int
! 45017: test_xmlTextWriterWritePI(void) {
! 45018: int test_ret = 0;
! 45019:
! 45020: #if defined(LIBXML_WRITER_ENABLED)
! 45021: int mem_base;
! 45022: int ret_val;
! 45023: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 45024: int n_writer;
! 45025: xmlChar * target; /* PI target */
! 45026: int n_target;
! 45027: xmlChar * content; /* PI content */
! 45028: int n_content;
! 45029:
! 45030: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 45031: for (n_target = 0;n_target < gen_nb_const_xmlChar_ptr;n_target++) {
! 45032: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 45033: mem_base = xmlMemBlocks();
! 45034: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 45035: target = gen_const_xmlChar_ptr(n_target, 1);
! 45036: content = gen_const_xmlChar_ptr(n_content, 2);
! 45037:
! 45038: ret_val = xmlTextWriterWritePI(writer, (const xmlChar *)target, (const xmlChar *)content);
! 45039: desret_int(ret_val);
! 45040: call_tests++;
! 45041: des_xmlTextWriterPtr(n_writer, writer, 0);
! 45042: des_const_xmlChar_ptr(n_target, (const xmlChar *)target, 1);
! 45043: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
! 45044: xmlResetLastError();
! 45045: if (mem_base != xmlMemBlocks()) {
! 45046: printf("Leak of %d blocks found in xmlTextWriterWritePI",
! 45047: xmlMemBlocks() - mem_base);
! 45048: test_ret++;
! 45049: printf(" %d", n_writer);
! 45050: printf(" %d", n_target);
! 45051: printf(" %d", n_content);
! 45052: printf("\n");
! 45053: }
! 45054: }
! 45055: }
! 45056: }
! 45057: function_tests++;
! 45058: #endif
! 45059:
! 45060: return(test_ret);
! 45061: }
! 45062:
! 45063:
! 45064: static int
! 45065: test_xmlTextWriterWriteRaw(void) {
! 45066: int test_ret = 0;
! 45067:
! 45068: #if defined(LIBXML_WRITER_ENABLED)
! 45069: int mem_base;
! 45070: int ret_val;
! 45071: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 45072: int n_writer;
! 45073: xmlChar * content; /* text string */
! 45074: int n_content;
! 45075:
! 45076: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 45077: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 45078: mem_base = xmlMemBlocks();
! 45079: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 45080: content = gen_const_xmlChar_ptr(n_content, 1);
! 45081:
! 45082: ret_val = xmlTextWriterWriteRaw(writer, (const xmlChar *)content);
! 45083: desret_int(ret_val);
! 45084: call_tests++;
! 45085: des_xmlTextWriterPtr(n_writer, writer, 0);
! 45086: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
! 45087: xmlResetLastError();
! 45088: if (mem_base != xmlMemBlocks()) {
! 45089: printf("Leak of %d blocks found in xmlTextWriterWriteRaw",
! 45090: xmlMemBlocks() - mem_base);
! 45091: test_ret++;
! 45092: printf(" %d", n_writer);
! 45093: printf(" %d", n_content);
! 45094: printf("\n");
! 45095: }
! 45096: }
! 45097: }
! 45098: function_tests++;
! 45099: #endif
! 45100:
! 45101: return(test_ret);
! 45102: }
! 45103:
! 45104:
! 45105: static int
! 45106: test_xmlTextWriterWriteRawLen(void) {
! 45107: int test_ret = 0;
! 45108:
! 45109: #if defined(LIBXML_WRITER_ENABLED)
! 45110: int mem_base;
! 45111: int ret_val;
! 45112: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 45113: int n_writer;
! 45114: xmlChar * content; /* text string */
! 45115: int n_content;
! 45116: int len; /* length of the text string */
! 45117: int n_len;
! 45118:
! 45119: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 45120: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 45121: for (n_len = 0;n_len < gen_nb_int;n_len++) {
! 45122: mem_base = xmlMemBlocks();
! 45123: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 45124: content = gen_const_xmlChar_ptr(n_content, 1);
! 45125: len = gen_int(n_len, 2);
! 45126:
! 45127: ret_val = xmlTextWriterWriteRawLen(writer, (const xmlChar *)content, len);
! 45128: desret_int(ret_val);
! 45129: call_tests++;
! 45130: des_xmlTextWriterPtr(n_writer, writer, 0);
! 45131: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
! 45132: des_int(n_len, len, 2);
! 45133: xmlResetLastError();
! 45134: if (mem_base != xmlMemBlocks()) {
! 45135: printf("Leak of %d blocks found in xmlTextWriterWriteRawLen",
! 45136: xmlMemBlocks() - mem_base);
! 45137: test_ret++;
! 45138: printf(" %d", n_writer);
! 45139: printf(" %d", n_content);
! 45140: printf(" %d", n_len);
! 45141: printf("\n");
! 45142: }
! 45143: }
! 45144: }
! 45145: }
! 45146: function_tests++;
! 45147: #endif
! 45148:
! 45149: return(test_ret);
! 45150: }
! 45151:
! 45152:
! 45153: static int
! 45154: test_xmlTextWriterWriteString(void) {
! 45155: int test_ret = 0;
! 45156:
! 45157: #if defined(LIBXML_WRITER_ENABLED)
! 45158: int mem_base;
! 45159: int ret_val;
! 45160: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 45161: int n_writer;
! 45162: xmlChar * content; /* text string */
! 45163: int n_content;
! 45164:
! 45165: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 45166: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
! 45167: mem_base = xmlMemBlocks();
! 45168: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 45169: content = gen_const_xmlChar_ptr(n_content, 1);
! 45170:
! 45171: ret_val = xmlTextWriterWriteString(writer, (const xmlChar *)content);
! 45172: desret_int(ret_val);
! 45173: call_tests++;
! 45174: des_xmlTextWriterPtr(n_writer, writer, 0);
! 45175: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
! 45176: xmlResetLastError();
! 45177: if (mem_base != xmlMemBlocks()) {
! 45178: printf("Leak of %d blocks found in xmlTextWriterWriteString",
! 45179: xmlMemBlocks() - mem_base);
! 45180: test_ret++;
! 45181: printf(" %d", n_writer);
! 45182: printf(" %d", n_content);
! 45183: printf("\n");
! 45184: }
! 45185: }
! 45186: }
! 45187: function_tests++;
! 45188: #endif
! 45189:
! 45190: return(test_ret);
! 45191: }
! 45192:
! 45193:
! 45194: static int
! 45195: test_xmlTextWriterWriteVFormatAttribute(void) {
! 45196: int test_ret = 0;
! 45197:
! 45198:
! 45199: /* missing type support */
! 45200: return(test_ret);
! 45201: }
! 45202:
! 45203:
! 45204: static int
! 45205: test_xmlTextWriterWriteVFormatAttributeNS(void) {
! 45206: int test_ret = 0;
! 45207:
! 45208:
! 45209: /* missing type support */
! 45210: return(test_ret);
! 45211: }
! 45212:
! 45213:
! 45214: static int
! 45215: test_xmlTextWriterWriteVFormatCDATA(void) {
! 45216: int test_ret = 0;
! 45217:
! 45218:
! 45219: /* missing type support */
! 45220: return(test_ret);
! 45221: }
! 45222:
! 45223:
! 45224: static int
! 45225: test_xmlTextWriterWriteVFormatComment(void) {
! 45226: int test_ret = 0;
! 45227:
! 45228:
! 45229: /* missing type support */
! 45230: return(test_ret);
! 45231: }
! 45232:
! 45233:
! 45234: static int
! 45235: test_xmlTextWriterWriteVFormatDTD(void) {
! 45236: int test_ret = 0;
! 45237:
! 45238:
! 45239: /* missing type support */
! 45240: return(test_ret);
! 45241: }
! 45242:
! 45243:
! 45244: static int
! 45245: test_xmlTextWriterWriteVFormatDTDAttlist(void) {
! 45246: int test_ret = 0;
! 45247:
! 45248:
! 45249: /* missing type support */
! 45250: return(test_ret);
! 45251: }
! 45252:
! 45253:
! 45254: static int
! 45255: test_xmlTextWriterWriteVFormatDTDElement(void) {
! 45256: int test_ret = 0;
! 45257:
! 45258:
! 45259: /* missing type support */
! 45260: return(test_ret);
! 45261: }
! 45262:
! 45263:
! 45264: static int
! 45265: test_xmlTextWriterWriteVFormatDTDInternalEntity(void) {
! 45266: int test_ret = 0;
! 45267:
! 45268:
! 45269: /* missing type support */
! 45270: return(test_ret);
! 45271: }
! 45272:
! 45273:
! 45274: static int
! 45275: test_xmlTextWriterWriteVFormatElement(void) {
! 45276: int test_ret = 0;
! 45277:
! 45278:
! 45279: /* missing type support */
! 45280: return(test_ret);
! 45281: }
! 45282:
! 45283:
! 45284: static int
! 45285: test_xmlTextWriterWriteVFormatElementNS(void) {
! 45286: int test_ret = 0;
! 45287:
! 45288:
! 45289: /* missing type support */
! 45290: return(test_ret);
! 45291: }
! 45292:
! 45293:
! 45294: static int
! 45295: test_xmlTextWriterWriteVFormatPI(void) {
! 45296: int test_ret = 0;
! 45297:
! 45298:
! 45299: /* missing type support */
! 45300: return(test_ret);
! 45301: }
! 45302:
! 45303:
! 45304: static int
! 45305: test_xmlTextWriterWriteVFormatRaw(void) {
! 45306: int test_ret = 0;
! 45307:
! 45308:
! 45309: /* missing type support */
! 45310: return(test_ret);
! 45311: }
! 45312:
! 45313:
! 45314: static int
! 45315: test_xmlTextWriterWriteVFormatString(void) {
! 45316: int test_ret = 0;
! 45317:
! 45318:
! 45319: /* missing type support */
! 45320: return(test_ret);
! 45321: }
! 45322:
! 45323: static int
! 45324: test_xmlwriter(void) {
! 45325: int test_ret = 0;
! 45326:
! 45327: if (quiet == 0) printf("Testing xmlwriter : 51 of 79 functions ...\n");
! 45328: test_ret += test_xmlNewTextWriter();
! 45329: test_ret += test_xmlNewTextWriterFilename();
! 45330: test_ret += test_xmlNewTextWriterMemory();
! 45331: test_ret += test_xmlNewTextWriterPushParser();
! 45332: test_ret += test_xmlNewTextWriterTree();
! 45333: test_ret += test_xmlTextWriterEndAttribute();
! 45334: test_ret += test_xmlTextWriterEndCDATA();
! 45335: test_ret += test_xmlTextWriterEndComment();
! 45336: test_ret += test_xmlTextWriterEndDTD();
! 45337: test_ret += test_xmlTextWriterEndDTDAttlist();
! 45338: test_ret += test_xmlTextWriterEndDTDElement();
! 45339: test_ret += test_xmlTextWriterEndDTDEntity();
! 45340: test_ret += test_xmlTextWriterEndDocument();
! 45341: test_ret += test_xmlTextWriterEndElement();
! 45342: test_ret += test_xmlTextWriterEndPI();
! 45343: test_ret += test_xmlTextWriterFlush();
! 45344: test_ret += test_xmlTextWriterFullEndElement();
! 45345: test_ret += test_xmlTextWriterSetIndent();
! 45346: test_ret += test_xmlTextWriterSetIndentString();
! 45347: test_ret += test_xmlTextWriterStartAttribute();
! 45348: test_ret += test_xmlTextWriterStartAttributeNS();
! 45349: test_ret += test_xmlTextWriterStartCDATA();
! 45350: test_ret += test_xmlTextWriterStartComment();
! 45351: test_ret += test_xmlTextWriterStartDTD();
! 45352: test_ret += test_xmlTextWriterStartDTDAttlist();
! 45353: test_ret += test_xmlTextWriterStartDTDElement();
! 45354: test_ret += test_xmlTextWriterStartDTDEntity();
! 45355: test_ret += test_xmlTextWriterStartDocument();
! 45356: test_ret += test_xmlTextWriterStartElement();
! 45357: test_ret += test_xmlTextWriterStartElementNS();
! 45358: test_ret += test_xmlTextWriterStartPI();
! 45359: test_ret += test_xmlTextWriterWriteAttribute();
! 45360: test_ret += test_xmlTextWriterWriteAttributeNS();
! 45361: test_ret += test_xmlTextWriterWriteBase64();
! 45362: test_ret += test_xmlTextWriterWriteBinHex();
! 45363: test_ret += test_xmlTextWriterWriteCDATA();
! 45364: test_ret += test_xmlTextWriterWriteComment();
! 45365: test_ret += test_xmlTextWriterWriteDTD();
! 45366: test_ret += test_xmlTextWriterWriteDTDAttlist();
! 45367: test_ret += test_xmlTextWriterWriteDTDElement();
! 45368: test_ret += test_xmlTextWriterWriteDTDEntity();
! 45369: test_ret += test_xmlTextWriterWriteDTDExternalEntity();
! 45370: test_ret += test_xmlTextWriterWriteDTDExternalEntityContents();
! 45371: test_ret += test_xmlTextWriterWriteDTDInternalEntity();
! 45372: test_ret += test_xmlTextWriterWriteDTDNotation();
! 45373: test_ret += test_xmlTextWriterWriteElement();
! 45374: test_ret += test_xmlTextWriterWriteElementNS();
! 45375: test_ret += test_xmlTextWriterWriteFormatAttribute();
! 45376: test_ret += test_xmlTextWriterWriteFormatAttributeNS();
! 45377: test_ret += test_xmlTextWriterWriteFormatCDATA();
! 45378: test_ret += test_xmlTextWriterWriteFormatComment();
! 45379: test_ret += test_xmlTextWriterWriteFormatDTD();
! 45380: test_ret += test_xmlTextWriterWriteFormatDTDAttlist();
! 45381: test_ret += test_xmlTextWriterWriteFormatDTDElement();
! 45382: test_ret += test_xmlTextWriterWriteFormatDTDInternalEntity();
! 45383: test_ret += test_xmlTextWriterWriteFormatElement();
! 45384: test_ret += test_xmlTextWriterWriteFormatElementNS();
! 45385: test_ret += test_xmlTextWriterWriteFormatPI();
! 45386: test_ret += test_xmlTextWriterWriteFormatRaw();
! 45387: test_ret += test_xmlTextWriterWriteFormatString();
! 45388: test_ret += test_xmlTextWriterWritePI();
! 45389: test_ret += test_xmlTextWriterWriteRaw();
! 45390: test_ret += test_xmlTextWriterWriteRawLen();
! 45391: test_ret += test_xmlTextWriterWriteString();
! 45392: test_ret += test_xmlTextWriterWriteVFormatAttribute();
! 45393: test_ret += test_xmlTextWriterWriteVFormatAttributeNS();
! 45394: test_ret += test_xmlTextWriterWriteVFormatCDATA();
! 45395: test_ret += test_xmlTextWriterWriteVFormatComment();
! 45396: test_ret += test_xmlTextWriterWriteVFormatDTD();
! 45397: test_ret += test_xmlTextWriterWriteVFormatDTDAttlist();
! 45398: test_ret += test_xmlTextWriterWriteVFormatDTDElement();
! 45399: test_ret += test_xmlTextWriterWriteVFormatDTDInternalEntity();
! 45400: test_ret += test_xmlTextWriterWriteVFormatElement();
! 45401: test_ret += test_xmlTextWriterWriteVFormatElementNS();
! 45402: test_ret += test_xmlTextWriterWriteVFormatPI();
! 45403: test_ret += test_xmlTextWriterWriteVFormatRaw();
! 45404: test_ret += test_xmlTextWriterWriteVFormatString();
! 45405:
! 45406: if (test_ret != 0)
! 45407: printf("Module xmlwriter: %d errors\n", test_ret);
! 45408: return(test_ret);
! 45409: }
! 45410:
! 45411: static int
! 45412: test_xmlXPathCastBooleanToNumber(void) {
! 45413: int test_ret = 0;
! 45414:
! 45415: #if defined(LIBXML_XPATH_ENABLED)
! 45416: int mem_base;
! 45417: double ret_val;
! 45418: int val; /* a boolean */
! 45419: int n_val;
! 45420:
! 45421: for (n_val = 0;n_val < gen_nb_int;n_val++) {
! 45422: mem_base = xmlMemBlocks();
! 45423: val = gen_int(n_val, 0);
! 45424:
! 45425: ret_val = xmlXPathCastBooleanToNumber(val);
! 45426: desret_double(ret_val);
! 45427: call_tests++;
! 45428: des_int(n_val, val, 0);
! 45429: xmlResetLastError();
! 45430: if (mem_base != xmlMemBlocks()) {
! 45431: printf("Leak of %d blocks found in xmlXPathCastBooleanToNumber",
! 45432: xmlMemBlocks() - mem_base);
! 45433: test_ret++;
! 45434: printf(" %d", n_val);
! 45435: printf("\n");
! 45436: }
! 45437: }
! 45438: function_tests++;
! 45439: #endif
! 45440:
! 45441: return(test_ret);
! 45442: }
! 45443:
! 45444:
! 45445: static int
! 45446: test_xmlXPathCastBooleanToString(void) {
! 45447: int test_ret = 0;
! 45448:
! 45449: #if defined(LIBXML_XPATH_ENABLED)
! 45450: int mem_base;
! 45451: xmlChar * ret_val;
! 45452: int val; /* a boolean */
! 45453: int n_val;
! 45454:
! 45455: for (n_val = 0;n_val < gen_nb_int;n_val++) {
! 45456: mem_base = xmlMemBlocks();
! 45457: val = gen_int(n_val, 0);
! 45458:
! 45459: ret_val = xmlXPathCastBooleanToString(val);
! 45460: desret_xmlChar_ptr(ret_val);
! 45461: call_tests++;
! 45462: des_int(n_val, val, 0);
! 45463: xmlResetLastError();
! 45464: if (mem_base != xmlMemBlocks()) {
! 45465: printf("Leak of %d blocks found in xmlXPathCastBooleanToString",
! 45466: xmlMemBlocks() - mem_base);
! 45467: test_ret++;
! 45468: printf(" %d", n_val);
! 45469: printf("\n");
! 45470: }
! 45471: }
! 45472: function_tests++;
! 45473: #endif
! 45474:
! 45475: return(test_ret);
! 45476: }
! 45477:
! 45478:
! 45479: static int
! 45480: test_xmlXPathCastNodeSetToBoolean(void) {
! 45481: int test_ret = 0;
! 45482:
! 45483: #if defined(LIBXML_XPATH_ENABLED)
! 45484: int mem_base;
! 45485: int ret_val;
! 45486: xmlNodeSetPtr ns; /* a node-set */
! 45487: int n_ns;
! 45488:
! 45489: for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) {
! 45490: mem_base = xmlMemBlocks();
! 45491: ns = gen_xmlNodeSetPtr(n_ns, 0);
! 45492:
! 45493: ret_val = xmlXPathCastNodeSetToBoolean(ns);
! 45494: desret_int(ret_val);
! 45495: call_tests++;
! 45496: des_xmlNodeSetPtr(n_ns, ns, 0);
! 45497: xmlResetLastError();
! 45498: if (mem_base != xmlMemBlocks()) {
! 45499: printf("Leak of %d blocks found in xmlXPathCastNodeSetToBoolean",
! 45500: xmlMemBlocks() - mem_base);
! 45501: test_ret++;
! 45502: printf(" %d", n_ns);
! 45503: printf("\n");
! 45504: }
! 45505: }
! 45506: function_tests++;
! 45507: #endif
! 45508:
! 45509: return(test_ret);
! 45510: }
! 45511:
! 45512:
! 45513: static int
! 45514: test_xmlXPathCastNodeSetToNumber(void) {
! 45515: int test_ret = 0;
! 45516:
! 45517: #if defined(LIBXML_XPATH_ENABLED)
! 45518: int mem_base;
! 45519: double ret_val;
! 45520: xmlNodeSetPtr ns; /* a node-set */
! 45521: int n_ns;
! 45522:
! 45523: for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) {
! 45524: mem_base = xmlMemBlocks();
! 45525: ns = gen_xmlNodeSetPtr(n_ns, 0);
! 45526:
! 45527: ret_val = xmlXPathCastNodeSetToNumber(ns);
! 45528: desret_double(ret_val);
! 45529: call_tests++;
! 45530: des_xmlNodeSetPtr(n_ns, ns, 0);
! 45531: xmlResetLastError();
! 45532: if (mem_base != xmlMemBlocks()) {
! 45533: printf("Leak of %d blocks found in xmlXPathCastNodeSetToNumber",
! 45534: xmlMemBlocks() - mem_base);
! 45535: test_ret++;
! 45536: printf(" %d", n_ns);
! 45537: printf("\n");
! 45538: }
! 45539: }
! 45540: function_tests++;
! 45541: #endif
! 45542:
! 45543: return(test_ret);
! 45544: }
! 45545:
! 45546:
! 45547: static int
! 45548: test_xmlXPathCastNodeSetToString(void) {
! 45549: int test_ret = 0;
! 45550:
! 45551: #if defined(LIBXML_XPATH_ENABLED)
! 45552: int mem_base;
! 45553: xmlChar * ret_val;
! 45554: xmlNodeSetPtr ns; /* a node-set */
! 45555: int n_ns;
! 45556:
! 45557: for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) {
! 45558: mem_base = xmlMemBlocks();
! 45559: ns = gen_xmlNodeSetPtr(n_ns, 0);
! 45560:
! 45561: ret_val = xmlXPathCastNodeSetToString(ns);
! 45562: desret_xmlChar_ptr(ret_val);
! 45563: call_tests++;
! 45564: des_xmlNodeSetPtr(n_ns, ns, 0);
! 45565: xmlResetLastError();
! 45566: if (mem_base != xmlMemBlocks()) {
! 45567: printf("Leak of %d blocks found in xmlXPathCastNodeSetToString",
! 45568: xmlMemBlocks() - mem_base);
! 45569: test_ret++;
! 45570: printf(" %d", n_ns);
! 45571: printf("\n");
! 45572: }
! 45573: }
! 45574: function_tests++;
! 45575: #endif
! 45576:
! 45577: return(test_ret);
! 45578: }
! 45579:
! 45580:
! 45581: static int
! 45582: test_xmlXPathCastNodeToNumber(void) {
! 45583: int test_ret = 0;
! 45584:
! 45585: #if defined(LIBXML_XPATH_ENABLED)
! 45586: int mem_base;
! 45587: double ret_val;
! 45588: xmlNodePtr node; /* a node */
! 45589: int n_node;
! 45590:
! 45591: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 45592: mem_base = xmlMemBlocks();
! 45593: node = gen_xmlNodePtr(n_node, 0);
! 45594:
! 45595: ret_val = xmlXPathCastNodeToNumber(node);
! 45596: desret_double(ret_val);
! 45597: call_tests++;
! 45598: des_xmlNodePtr(n_node, node, 0);
! 45599: xmlResetLastError();
! 45600: if (mem_base != xmlMemBlocks()) {
! 45601: printf("Leak of %d blocks found in xmlXPathCastNodeToNumber",
! 45602: xmlMemBlocks() - mem_base);
! 45603: test_ret++;
! 45604: printf(" %d", n_node);
! 45605: printf("\n");
! 45606: }
! 45607: }
! 45608: function_tests++;
! 45609: #endif
! 45610:
! 45611: return(test_ret);
! 45612: }
! 45613:
! 45614:
! 45615: static int
! 45616: test_xmlXPathCastNodeToString(void) {
! 45617: int test_ret = 0;
! 45618:
! 45619: #if defined(LIBXML_XPATH_ENABLED)
! 45620: int mem_base;
! 45621: xmlChar * ret_val;
! 45622: xmlNodePtr node; /* a node */
! 45623: int n_node;
! 45624:
! 45625: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 45626: mem_base = xmlMemBlocks();
! 45627: node = gen_xmlNodePtr(n_node, 0);
! 45628:
! 45629: ret_val = xmlXPathCastNodeToString(node);
! 45630: desret_xmlChar_ptr(ret_val);
! 45631: call_tests++;
! 45632: des_xmlNodePtr(n_node, node, 0);
! 45633: xmlResetLastError();
! 45634: if (mem_base != xmlMemBlocks()) {
! 45635: printf("Leak of %d blocks found in xmlXPathCastNodeToString",
! 45636: xmlMemBlocks() - mem_base);
! 45637: test_ret++;
! 45638: printf(" %d", n_node);
! 45639: printf("\n");
! 45640: }
! 45641: }
! 45642: function_tests++;
! 45643: #endif
! 45644:
! 45645: return(test_ret);
! 45646: }
! 45647:
! 45648:
! 45649: static int
! 45650: test_xmlXPathCastNumberToBoolean(void) {
! 45651: int test_ret = 0;
! 45652:
! 45653: #if defined(LIBXML_XPATH_ENABLED)
! 45654: int mem_base;
! 45655: int ret_val;
! 45656: double val; /* a number */
! 45657: int n_val;
! 45658:
! 45659: for (n_val = 0;n_val < gen_nb_double;n_val++) {
! 45660: mem_base = xmlMemBlocks();
! 45661: val = gen_double(n_val, 0);
! 45662:
! 45663: ret_val = xmlXPathCastNumberToBoolean(val);
! 45664: desret_int(ret_val);
! 45665: call_tests++;
! 45666: des_double(n_val, val, 0);
! 45667: xmlResetLastError();
! 45668: if (mem_base != xmlMemBlocks()) {
! 45669: printf("Leak of %d blocks found in xmlXPathCastNumberToBoolean",
! 45670: xmlMemBlocks() - mem_base);
! 45671: test_ret++;
! 45672: printf(" %d", n_val);
! 45673: printf("\n");
! 45674: }
! 45675: }
! 45676: function_tests++;
! 45677: #endif
! 45678:
! 45679: return(test_ret);
! 45680: }
! 45681:
! 45682:
! 45683: static int
! 45684: test_xmlXPathCastNumberToString(void) {
! 45685: int test_ret = 0;
! 45686:
! 45687: #if defined(LIBXML_XPATH_ENABLED)
! 45688: int mem_base;
! 45689: xmlChar * ret_val;
! 45690: double val; /* a number */
! 45691: int n_val;
! 45692:
! 45693: for (n_val = 0;n_val < gen_nb_double;n_val++) {
! 45694: mem_base = xmlMemBlocks();
! 45695: val = gen_double(n_val, 0);
! 45696:
! 45697: ret_val = xmlXPathCastNumberToString(val);
! 45698: desret_xmlChar_ptr(ret_val);
! 45699: call_tests++;
! 45700: des_double(n_val, val, 0);
! 45701: xmlResetLastError();
! 45702: if (mem_base != xmlMemBlocks()) {
! 45703: printf("Leak of %d blocks found in xmlXPathCastNumberToString",
! 45704: xmlMemBlocks() - mem_base);
! 45705: test_ret++;
! 45706: printf(" %d", n_val);
! 45707: printf("\n");
! 45708: }
! 45709: }
! 45710: function_tests++;
! 45711: #endif
! 45712:
! 45713: return(test_ret);
! 45714: }
! 45715:
! 45716:
! 45717: static int
! 45718: test_xmlXPathCastStringToBoolean(void) {
! 45719: int test_ret = 0;
! 45720:
! 45721: #if defined(LIBXML_XPATH_ENABLED)
! 45722: int mem_base;
! 45723: int ret_val;
! 45724: xmlChar * val; /* a string */
! 45725: int n_val;
! 45726:
! 45727: for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
! 45728: mem_base = xmlMemBlocks();
! 45729: val = gen_const_xmlChar_ptr(n_val, 0);
! 45730:
! 45731: ret_val = xmlXPathCastStringToBoolean((const xmlChar *)val);
! 45732: desret_int(ret_val);
! 45733: call_tests++;
! 45734: des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 0);
! 45735: xmlResetLastError();
! 45736: if (mem_base != xmlMemBlocks()) {
! 45737: printf("Leak of %d blocks found in xmlXPathCastStringToBoolean",
! 45738: xmlMemBlocks() - mem_base);
! 45739: test_ret++;
! 45740: printf(" %d", n_val);
! 45741: printf("\n");
! 45742: }
! 45743: }
! 45744: function_tests++;
! 45745: #endif
! 45746:
! 45747: return(test_ret);
! 45748: }
! 45749:
! 45750:
! 45751: static int
! 45752: test_xmlXPathCastStringToNumber(void) {
! 45753: int test_ret = 0;
! 45754:
! 45755: #if defined(LIBXML_XPATH_ENABLED)
! 45756: int mem_base;
! 45757: double ret_val;
! 45758: xmlChar * val; /* a string */
! 45759: int n_val;
! 45760:
! 45761: for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
! 45762: mem_base = xmlMemBlocks();
! 45763: val = gen_const_xmlChar_ptr(n_val, 0);
! 45764:
! 45765: ret_val = xmlXPathCastStringToNumber((const xmlChar *)val);
! 45766: desret_double(ret_val);
! 45767: call_tests++;
! 45768: des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 0);
! 45769: xmlResetLastError();
! 45770: if (mem_base != xmlMemBlocks()) {
! 45771: printf("Leak of %d blocks found in xmlXPathCastStringToNumber",
! 45772: xmlMemBlocks() - mem_base);
! 45773: test_ret++;
! 45774: printf(" %d", n_val);
! 45775: printf("\n");
! 45776: }
! 45777: }
! 45778: function_tests++;
! 45779: #endif
! 45780:
! 45781: return(test_ret);
! 45782: }
! 45783:
! 45784:
! 45785: static int
! 45786: test_xmlXPathCastToBoolean(void) {
! 45787: int test_ret = 0;
! 45788:
! 45789: #if defined(LIBXML_XPATH_ENABLED)
! 45790: int mem_base;
! 45791: int ret_val;
! 45792: xmlXPathObjectPtr val; /* an XPath object */
! 45793: int n_val;
! 45794:
! 45795: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
! 45796: mem_base = xmlMemBlocks();
! 45797: val = gen_xmlXPathObjectPtr(n_val, 0);
! 45798:
! 45799: ret_val = xmlXPathCastToBoolean(val);
! 45800: desret_int(ret_val);
! 45801: call_tests++;
! 45802: des_xmlXPathObjectPtr(n_val, val, 0);
! 45803: xmlResetLastError();
! 45804: if (mem_base != xmlMemBlocks()) {
! 45805: printf("Leak of %d blocks found in xmlXPathCastToBoolean",
! 45806: xmlMemBlocks() - mem_base);
! 45807: test_ret++;
! 45808: printf(" %d", n_val);
! 45809: printf("\n");
! 45810: }
! 45811: }
! 45812: function_tests++;
! 45813: #endif
! 45814:
! 45815: return(test_ret);
! 45816: }
! 45817:
! 45818:
! 45819: static int
! 45820: test_xmlXPathCastToNumber(void) {
! 45821: int test_ret = 0;
! 45822:
! 45823: #if defined(LIBXML_XPATH_ENABLED)
! 45824: int mem_base;
! 45825: double ret_val;
! 45826: xmlXPathObjectPtr val; /* an XPath object */
! 45827: int n_val;
! 45828:
! 45829: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
! 45830: mem_base = xmlMemBlocks();
! 45831: val = gen_xmlXPathObjectPtr(n_val, 0);
! 45832:
! 45833: ret_val = xmlXPathCastToNumber(val);
! 45834: desret_double(ret_val);
! 45835: call_tests++;
! 45836: des_xmlXPathObjectPtr(n_val, val, 0);
! 45837: xmlResetLastError();
! 45838: if (mem_base != xmlMemBlocks()) {
! 45839: printf("Leak of %d blocks found in xmlXPathCastToNumber",
! 45840: xmlMemBlocks() - mem_base);
! 45841: test_ret++;
! 45842: printf(" %d", n_val);
! 45843: printf("\n");
! 45844: }
! 45845: }
! 45846: function_tests++;
! 45847: #endif
! 45848:
! 45849: return(test_ret);
! 45850: }
! 45851:
! 45852:
! 45853: static int
! 45854: test_xmlXPathCastToString(void) {
! 45855: int test_ret = 0;
! 45856:
! 45857: #if defined(LIBXML_XPATH_ENABLED)
! 45858: int mem_base;
! 45859: xmlChar * ret_val;
! 45860: xmlXPathObjectPtr val; /* an XPath object */
! 45861: int n_val;
! 45862:
! 45863: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
! 45864: mem_base = xmlMemBlocks();
! 45865: val = gen_xmlXPathObjectPtr(n_val, 0);
! 45866:
! 45867: ret_val = xmlXPathCastToString(val);
! 45868: desret_xmlChar_ptr(ret_val);
! 45869: call_tests++;
! 45870: des_xmlXPathObjectPtr(n_val, val, 0);
! 45871: xmlResetLastError();
! 45872: if (mem_base != xmlMemBlocks()) {
! 45873: printf("Leak of %d blocks found in xmlXPathCastToString",
! 45874: xmlMemBlocks() - mem_base);
! 45875: test_ret++;
! 45876: printf(" %d", n_val);
! 45877: printf("\n");
! 45878: }
! 45879: }
! 45880: function_tests++;
! 45881: #endif
! 45882:
! 45883: return(test_ret);
! 45884: }
! 45885:
! 45886:
! 45887: static int
! 45888: test_xmlXPathCmpNodes(void) {
! 45889: int test_ret = 0;
! 45890:
! 45891: #if defined(LIBXML_XPATH_ENABLED)
! 45892: int mem_base;
! 45893: int ret_val;
! 45894: xmlNodePtr node1; /* the first node */
! 45895: int n_node1;
! 45896: xmlNodePtr node2; /* the second node */
! 45897: int n_node2;
! 45898:
! 45899: for (n_node1 = 0;n_node1 < gen_nb_xmlNodePtr;n_node1++) {
! 45900: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
! 45901: mem_base = xmlMemBlocks();
! 45902: node1 = gen_xmlNodePtr(n_node1, 0);
! 45903: node2 = gen_xmlNodePtr(n_node2, 1);
! 45904:
! 45905: ret_val = xmlXPathCmpNodes(node1, node2);
! 45906: desret_int(ret_val);
! 45907: call_tests++;
! 45908: des_xmlNodePtr(n_node1, node1, 0);
! 45909: des_xmlNodePtr(n_node2, node2, 1);
! 45910: xmlResetLastError();
! 45911: if (mem_base != xmlMemBlocks()) {
! 45912: printf("Leak of %d blocks found in xmlXPathCmpNodes",
! 45913: xmlMemBlocks() - mem_base);
! 45914: test_ret++;
! 45915: printf(" %d", n_node1);
! 45916: printf(" %d", n_node2);
! 45917: printf("\n");
! 45918: }
! 45919: }
! 45920: }
! 45921: function_tests++;
! 45922: #endif
! 45923:
! 45924: return(test_ret);
! 45925: }
! 45926:
! 45927:
! 45928: static int
! 45929: test_xmlXPathCompile(void) {
! 45930: int test_ret = 0;
! 45931:
! 45932:
! 45933: /* missing type support */
! 45934: return(test_ret);
! 45935: }
! 45936:
! 45937: #ifdef LIBXML_XPATH_ENABLED
! 45938:
! 45939: #define gen_nb_xmlXPathCompExprPtr 1
! 45940: static xmlXPathCompExprPtr gen_xmlXPathCompExprPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 45941: return(NULL);
! 45942: }
! 45943: static void des_xmlXPathCompExprPtr(int no ATTRIBUTE_UNUSED, xmlXPathCompExprPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 45944: }
! 45945: #endif
! 45946:
! 45947: #ifdef LIBXML_XPATH_ENABLED
! 45948:
! 45949: #define gen_nb_xmlXPathContextPtr 1
! 45950: static xmlXPathContextPtr gen_xmlXPathContextPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 45951: return(NULL);
! 45952: }
! 45953: static void des_xmlXPathContextPtr(int no ATTRIBUTE_UNUSED, xmlXPathContextPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 45954: }
! 45955: #endif
! 45956:
! 45957:
! 45958: static int
! 45959: test_xmlXPathCompiledEval(void) {
! 45960: int test_ret = 0;
! 45961:
! 45962: #if defined(LIBXML_XPATH_ENABLED)
! 45963: int mem_base;
! 45964: xmlXPathObjectPtr ret_val;
! 45965: xmlXPathCompExprPtr comp; /* the compiled XPath expression */
! 45966: int n_comp;
! 45967: xmlXPathContextPtr ctx; /* the XPath context */
! 45968: int n_ctx;
! 45969:
! 45970: for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) {
! 45971: for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
! 45972: mem_base = xmlMemBlocks();
! 45973: comp = gen_xmlXPathCompExprPtr(n_comp, 0);
! 45974: ctx = gen_xmlXPathContextPtr(n_ctx, 1);
! 45975:
! 45976: ret_val = xmlXPathCompiledEval(comp, ctx);
! 45977: desret_xmlXPathObjectPtr(ret_val);
! 45978: call_tests++;
! 45979: des_xmlXPathCompExprPtr(n_comp, comp, 0);
! 45980: des_xmlXPathContextPtr(n_ctx, ctx, 1);
! 45981: xmlResetLastError();
! 45982: if (mem_base != xmlMemBlocks()) {
! 45983: printf("Leak of %d blocks found in xmlXPathCompiledEval",
! 45984: xmlMemBlocks() - mem_base);
! 45985: test_ret++;
! 45986: printf(" %d", n_comp);
! 45987: printf(" %d", n_ctx);
! 45988: printf("\n");
! 45989: }
! 45990: }
! 45991: }
! 45992: function_tests++;
! 45993: #endif
! 45994:
! 45995: return(test_ret);
! 45996: }
! 45997:
! 45998:
! 45999: static int
! 46000: test_xmlXPathCompiledEvalToBoolean(void) {
! 46001: int test_ret = 0;
! 46002:
! 46003: #if defined(LIBXML_XPATH_ENABLED)
! 46004: int mem_base;
! 46005: int ret_val;
! 46006: xmlXPathCompExprPtr comp; /* the compiled XPath expression */
! 46007: int n_comp;
! 46008: xmlXPathContextPtr ctxt; /* the XPath context */
! 46009: int n_ctxt;
! 46010:
! 46011: for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) {
! 46012: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
! 46013: mem_base = xmlMemBlocks();
! 46014: comp = gen_xmlXPathCompExprPtr(n_comp, 0);
! 46015: ctxt = gen_xmlXPathContextPtr(n_ctxt, 1);
! 46016:
! 46017: ret_val = xmlXPathCompiledEvalToBoolean(comp, ctxt);
! 46018: desret_int(ret_val);
! 46019: call_tests++;
! 46020: des_xmlXPathCompExprPtr(n_comp, comp, 0);
! 46021: des_xmlXPathContextPtr(n_ctxt, ctxt, 1);
! 46022: xmlResetLastError();
! 46023: if (mem_base != xmlMemBlocks()) {
! 46024: printf("Leak of %d blocks found in xmlXPathCompiledEvalToBoolean",
! 46025: xmlMemBlocks() - mem_base);
! 46026: test_ret++;
! 46027: printf(" %d", n_comp);
! 46028: printf(" %d", n_ctxt);
! 46029: printf("\n");
! 46030: }
! 46031: }
! 46032: }
! 46033: function_tests++;
! 46034: #endif
! 46035:
! 46036: return(test_ret);
! 46037: }
! 46038:
! 46039:
! 46040: static int
! 46041: test_xmlXPathContextSetCache(void) {
! 46042: int test_ret = 0;
! 46043:
! 46044: #if defined(LIBXML_XPATH_ENABLED)
! 46045: int mem_base;
! 46046: int ret_val;
! 46047: xmlXPathContextPtr ctxt; /* the XPath context */
! 46048: int n_ctxt;
! 46049: int active; /* enables/disables (creates/frees) the cache */
! 46050: int n_active;
! 46051: int value; /* a value with semantics dependant on @options */
! 46052: int n_value;
! 46053: int options; /* options (currently only the value 0 is used) */
! 46054: int n_options;
! 46055:
! 46056: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
! 46057: for (n_active = 0;n_active < gen_nb_int;n_active++) {
! 46058: for (n_value = 0;n_value < gen_nb_int;n_value++) {
! 46059: for (n_options = 0;n_options < gen_nb_int;n_options++) {
! 46060: mem_base = xmlMemBlocks();
! 46061: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
! 46062: active = gen_int(n_active, 1);
! 46063: value = gen_int(n_value, 2);
! 46064: options = gen_int(n_options, 3);
! 46065:
! 46066: ret_val = xmlXPathContextSetCache(ctxt, active, value, options);
! 46067: desret_int(ret_val);
! 46068: call_tests++;
! 46069: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
! 46070: des_int(n_active, active, 1);
! 46071: des_int(n_value, value, 2);
! 46072: des_int(n_options, options, 3);
! 46073: xmlResetLastError();
! 46074: if (mem_base != xmlMemBlocks()) {
! 46075: printf("Leak of %d blocks found in xmlXPathContextSetCache",
! 46076: xmlMemBlocks() - mem_base);
! 46077: test_ret++;
! 46078: printf(" %d", n_ctxt);
! 46079: printf(" %d", n_active);
! 46080: printf(" %d", n_value);
! 46081: printf(" %d", n_options);
! 46082: printf("\n");
! 46083: }
! 46084: }
! 46085: }
! 46086: }
! 46087: }
! 46088: function_tests++;
! 46089: #endif
! 46090:
! 46091: return(test_ret);
! 46092: }
! 46093:
! 46094:
! 46095: static int
! 46096: test_xmlXPathConvertBoolean(void) {
! 46097: int test_ret = 0;
! 46098:
! 46099: #if defined(LIBXML_XPATH_ENABLED)
! 46100: int mem_base;
! 46101: xmlXPathObjectPtr ret_val;
! 46102: xmlXPathObjectPtr val; /* an XPath object */
! 46103: int n_val;
! 46104:
! 46105: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
! 46106: mem_base = xmlMemBlocks();
! 46107: val = gen_xmlXPathObjectPtr(n_val, 0);
! 46108:
! 46109: ret_val = xmlXPathConvertBoolean(val);
! 46110: val = NULL;
! 46111: desret_xmlXPathObjectPtr(ret_val);
! 46112: call_tests++;
! 46113: des_xmlXPathObjectPtr(n_val, val, 0);
! 46114: xmlResetLastError();
! 46115: if (mem_base != xmlMemBlocks()) {
! 46116: printf("Leak of %d blocks found in xmlXPathConvertBoolean",
! 46117: xmlMemBlocks() - mem_base);
! 46118: test_ret++;
! 46119: printf(" %d", n_val);
! 46120: printf("\n");
! 46121: }
! 46122: }
! 46123: function_tests++;
! 46124: #endif
! 46125:
! 46126: return(test_ret);
! 46127: }
! 46128:
! 46129:
! 46130: static int
! 46131: test_xmlXPathConvertNumber(void) {
! 46132: int test_ret = 0;
! 46133:
! 46134: #if defined(LIBXML_XPATH_ENABLED)
! 46135: int mem_base;
! 46136: xmlXPathObjectPtr ret_val;
! 46137: xmlXPathObjectPtr val; /* an XPath object */
! 46138: int n_val;
! 46139:
! 46140: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
! 46141: mem_base = xmlMemBlocks();
! 46142: val = gen_xmlXPathObjectPtr(n_val, 0);
! 46143:
! 46144: ret_val = xmlXPathConvertNumber(val);
! 46145: val = NULL;
! 46146: desret_xmlXPathObjectPtr(ret_val);
! 46147: call_tests++;
! 46148: des_xmlXPathObjectPtr(n_val, val, 0);
! 46149: xmlResetLastError();
! 46150: if (mem_base != xmlMemBlocks()) {
! 46151: printf("Leak of %d blocks found in xmlXPathConvertNumber",
! 46152: xmlMemBlocks() - mem_base);
! 46153: test_ret++;
! 46154: printf(" %d", n_val);
! 46155: printf("\n");
! 46156: }
! 46157: }
! 46158: function_tests++;
! 46159: #endif
! 46160:
! 46161: return(test_ret);
! 46162: }
! 46163:
! 46164:
! 46165: static int
! 46166: test_xmlXPathConvertString(void) {
! 46167: int test_ret = 0;
! 46168:
! 46169: #if defined(LIBXML_XPATH_ENABLED)
! 46170: int mem_base;
! 46171: xmlXPathObjectPtr ret_val;
! 46172: xmlXPathObjectPtr val; /* an XPath object */
! 46173: int n_val;
! 46174:
! 46175: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
! 46176: mem_base = xmlMemBlocks();
! 46177: val = gen_xmlXPathObjectPtr(n_val, 0);
! 46178:
! 46179: ret_val = xmlXPathConvertString(val);
! 46180: val = NULL;
! 46181: desret_xmlXPathObjectPtr(ret_val);
! 46182: call_tests++;
! 46183: des_xmlXPathObjectPtr(n_val, val, 0);
! 46184: xmlResetLastError();
! 46185: if (mem_base != xmlMemBlocks()) {
! 46186: printf("Leak of %d blocks found in xmlXPathConvertString",
! 46187: xmlMemBlocks() - mem_base);
! 46188: test_ret++;
! 46189: printf(" %d", n_val);
! 46190: printf("\n");
! 46191: }
! 46192: }
! 46193: function_tests++;
! 46194: #endif
! 46195:
! 46196: return(test_ret);
! 46197: }
! 46198:
! 46199:
! 46200: static int
! 46201: test_xmlXPathCtxtCompile(void) {
! 46202: int test_ret = 0;
! 46203:
! 46204:
! 46205: /* missing type support */
! 46206: return(test_ret);
! 46207: }
! 46208:
! 46209:
! 46210: static int
! 46211: test_xmlXPathEval(void) {
! 46212: int test_ret = 0;
! 46213:
! 46214: #if defined(LIBXML_XPATH_ENABLED)
! 46215: int mem_base;
! 46216: xmlXPathObjectPtr ret_val;
! 46217: xmlChar * str; /* the XPath expression */
! 46218: int n_str;
! 46219: xmlXPathContextPtr ctx; /* the XPath context */
! 46220: int n_ctx;
! 46221:
! 46222: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 46223: for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
! 46224: mem_base = xmlMemBlocks();
! 46225: str = gen_const_xmlChar_ptr(n_str, 0);
! 46226: ctx = gen_xmlXPathContextPtr(n_ctx, 1);
! 46227:
! 46228: ret_val = xmlXPathEval((const xmlChar *)str, ctx);
! 46229: desret_xmlXPathObjectPtr(ret_val);
! 46230: call_tests++;
! 46231: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
! 46232: des_xmlXPathContextPtr(n_ctx, ctx, 1);
! 46233: xmlResetLastError();
! 46234: if (mem_base != xmlMemBlocks()) {
! 46235: printf("Leak of %d blocks found in xmlXPathEval",
! 46236: xmlMemBlocks() - mem_base);
! 46237: test_ret++;
! 46238: printf(" %d", n_str);
! 46239: printf(" %d", n_ctx);
! 46240: printf("\n");
! 46241: }
! 46242: }
! 46243: }
! 46244: function_tests++;
! 46245: #endif
! 46246:
! 46247: return(test_ret);
! 46248: }
! 46249:
! 46250:
! 46251: static int
! 46252: test_xmlXPathEvalExpression(void) {
! 46253: int test_ret = 0;
! 46254:
! 46255: #if defined(LIBXML_XPATH_ENABLED)
! 46256: int mem_base;
! 46257: xmlXPathObjectPtr ret_val;
! 46258: xmlChar * str; /* the XPath expression */
! 46259: int n_str;
! 46260: xmlXPathContextPtr ctxt; /* the XPath context */
! 46261: int n_ctxt;
! 46262:
! 46263: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 46264: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
! 46265: mem_base = xmlMemBlocks();
! 46266: str = gen_const_xmlChar_ptr(n_str, 0);
! 46267: ctxt = gen_xmlXPathContextPtr(n_ctxt, 1);
! 46268:
! 46269: ret_val = xmlXPathEvalExpression((const xmlChar *)str, ctxt);
! 46270: desret_xmlXPathObjectPtr(ret_val);
! 46271: call_tests++;
! 46272: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
! 46273: des_xmlXPathContextPtr(n_ctxt, ctxt, 1);
! 46274: xmlResetLastError();
! 46275: if (mem_base != xmlMemBlocks()) {
! 46276: printf("Leak of %d blocks found in xmlXPathEvalExpression",
! 46277: xmlMemBlocks() - mem_base);
! 46278: test_ret++;
! 46279: printf(" %d", n_str);
! 46280: printf(" %d", n_ctxt);
! 46281: printf("\n");
! 46282: }
! 46283: }
! 46284: }
! 46285: function_tests++;
! 46286: #endif
! 46287:
! 46288: return(test_ret);
! 46289: }
! 46290:
! 46291:
! 46292: static int
! 46293: test_xmlXPathEvalPredicate(void) {
! 46294: int test_ret = 0;
! 46295:
! 46296: #if defined(LIBXML_XPATH_ENABLED)
! 46297: int mem_base;
! 46298: int ret_val;
! 46299: xmlXPathContextPtr ctxt; /* the XPath context */
! 46300: int n_ctxt;
! 46301: xmlXPathObjectPtr res; /* the Predicate Expression evaluation result */
! 46302: int n_res;
! 46303:
! 46304: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
! 46305: for (n_res = 0;n_res < gen_nb_xmlXPathObjectPtr;n_res++) {
! 46306: mem_base = xmlMemBlocks();
! 46307: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
! 46308: res = gen_xmlXPathObjectPtr(n_res, 1);
! 46309:
! 46310: ret_val = xmlXPathEvalPredicate(ctxt, res);
! 46311: desret_int(ret_val);
! 46312: call_tests++;
! 46313: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
! 46314: des_xmlXPathObjectPtr(n_res, res, 1);
! 46315: xmlResetLastError();
! 46316: if (mem_base != xmlMemBlocks()) {
! 46317: printf("Leak of %d blocks found in xmlXPathEvalPredicate",
! 46318: xmlMemBlocks() - mem_base);
! 46319: test_ret++;
! 46320: printf(" %d", n_ctxt);
! 46321: printf(" %d", n_res);
! 46322: printf("\n");
! 46323: }
! 46324: }
! 46325: }
! 46326: function_tests++;
! 46327: #endif
! 46328:
! 46329: return(test_ret);
! 46330: }
! 46331:
! 46332:
! 46333: static int
! 46334: test_xmlXPathInit(void) {
! 46335: int test_ret = 0;
! 46336:
! 46337: #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 46338: int mem_base;
! 46339:
! 46340: mem_base = xmlMemBlocks();
! 46341:
! 46342: xmlXPathInit();
! 46343: call_tests++;
! 46344: xmlResetLastError();
! 46345: if (mem_base != xmlMemBlocks()) {
! 46346: printf("Leak of %d blocks found in xmlXPathInit",
! 46347: xmlMemBlocks() - mem_base);
! 46348: test_ret++;
! 46349: printf("\n");
! 46350: }
! 46351: function_tests++;
! 46352: #endif
! 46353:
! 46354: return(test_ret);
! 46355: }
! 46356:
! 46357:
! 46358: static int
! 46359: test_xmlXPathIsInf(void) {
! 46360: int test_ret = 0;
! 46361:
! 46362: #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 46363: int mem_base;
! 46364: int ret_val;
! 46365: double val; /* a double value */
! 46366: int n_val;
! 46367:
! 46368: for (n_val = 0;n_val < gen_nb_double;n_val++) {
! 46369: mem_base = xmlMemBlocks();
! 46370: val = gen_double(n_val, 0);
! 46371:
! 46372: ret_val = xmlXPathIsInf(val);
! 46373: desret_int(ret_val);
! 46374: call_tests++;
! 46375: des_double(n_val, val, 0);
! 46376: xmlResetLastError();
! 46377: if (mem_base != xmlMemBlocks()) {
! 46378: printf("Leak of %d blocks found in xmlXPathIsInf",
! 46379: xmlMemBlocks() - mem_base);
! 46380: test_ret++;
! 46381: printf(" %d", n_val);
! 46382: printf("\n");
! 46383: }
! 46384: }
! 46385: function_tests++;
! 46386: #endif
! 46387:
! 46388: return(test_ret);
! 46389: }
! 46390:
! 46391:
! 46392: static int
! 46393: test_xmlXPathIsNaN(void) {
! 46394: int test_ret = 0;
! 46395:
! 46396: #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 46397: int mem_base;
! 46398: int ret_val;
! 46399: double val; /* a double value */
! 46400: int n_val;
! 46401:
! 46402: for (n_val = 0;n_val < gen_nb_double;n_val++) {
! 46403: mem_base = xmlMemBlocks();
! 46404: val = gen_double(n_val, 0);
! 46405:
! 46406: ret_val = xmlXPathIsNaN(val);
! 46407: desret_int(ret_val);
! 46408: call_tests++;
! 46409: des_double(n_val, val, 0);
! 46410: xmlResetLastError();
! 46411: if (mem_base != xmlMemBlocks()) {
! 46412: printf("Leak of %d blocks found in xmlXPathIsNaN",
! 46413: xmlMemBlocks() - mem_base);
! 46414: test_ret++;
! 46415: printf(" %d", n_val);
! 46416: printf("\n");
! 46417: }
! 46418: }
! 46419: function_tests++;
! 46420: #endif
! 46421:
! 46422: return(test_ret);
! 46423: }
! 46424:
! 46425:
! 46426: static int
! 46427: test_xmlXPathNewContext(void) {
! 46428: int test_ret = 0;
! 46429:
! 46430:
! 46431: /* missing type support */
! 46432: return(test_ret);
! 46433: }
! 46434:
! 46435:
! 46436: static int
! 46437: test_xmlXPathNodeSetCreate(void) {
! 46438: int test_ret = 0;
! 46439:
! 46440: #if defined(LIBXML_XPATH_ENABLED)
! 46441: int mem_base;
! 46442: xmlNodeSetPtr ret_val;
! 46443: xmlNodePtr val; /* an initial xmlNodePtr, or NULL */
! 46444: int n_val;
! 46445:
! 46446: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
! 46447: mem_base = xmlMemBlocks();
! 46448: val = gen_xmlNodePtr(n_val, 0);
! 46449:
! 46450: ret_val = xmlXPathNodeSetCreate(val);
! 46451: desret_xmlNodeSetPtr(ret_val);
! 46452: call_tests++;
! 46453: des_xmlNodePtr(n_val, val, 0);
! 46454: xmlResetLastError();
! 46455: if (mem_base != xmlMemBlocks()) {
! 46456: printf("Leak of %d blocks found in xmlXPathNodeSetCreate",
! 46457: xmlMemBlocks() - mem_base);
! 46458: test_ret++;
! 46459: printf(" %d", n_val);
! 46460: printf("\n");
! 46461: }
! 46462: }
! 46463: function_tests++;
! 46464: #endif
! 46465:
! 46466: return(test_ret);
! 46467: }
! 46468:
! 46469:
! 46470: static int
! 46471: test_xmlXPathObjectCopy(void) {
! 46472: int test_ret = 0;
! 46473:
! 46474: #if defined(LIBXML_XPATH_ENABLED)
! 46475: int mem_base;
! 46476: xmlXPathObjectPtr ret_val;
! 46477: xmlXPathObjectPtr val; /* the original object */
! 46478: int n_val;
! 46479:
! 46480: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
! 46481: mem_base = xmlMemBlocks();
! 46482: val = gen_xmlXPathObjectPtr(n_val, 0);
! 46483:
! 46484: ret_val = xmlXPathObjectCopy(val);
! 46485: desret_xmlXPathObjectPtr(ret_val);
! 46486: call_tests++;
! 46487: des_xmlXPathObjectPtr(n_val, val, 0);
! 46488: xmlResetLastError();
! 46489: if (mem_base != xmlMemBlocks()) {
! 46490: printf("Leak of %d blocks found in xmlXPathObjectCopy",
! 46491: xmlMemBlocks() - mem_base);
! 46492: test_ret++;
! 46493: printf(" %d", n_val);
! 46494: printf("\n");
! 46495: }
! 46496: }
! 46497: function_tests++;
! 46498: #endif
! 46499:
! 46500: return(test_ret);
! 46501: }
! 46502:
! 46503:
! 46504: static int
! 46505: test_xmlXPathOrderDocElems(void) {
! 46506: int test_ret = 0;
! 46507:
! 46508: #if defined(LIBXML_XPATH_ENABLED)
! 46509: int mem_base;
! 46510: long ret_val;
! 46511: xmlDocPtr doc; /* an input document */
! 46512: int n_doc;
! 46513:
! 46514: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
! 46515: mem_base = xmlMemBlocks();
! 46516: doc = gen_xmlDocPtr(n_doc, 0);
! 46517:
! 46518: ret_val = xmlXPathOrderDocElems(doc);
! 46519: desret_long(ret_val);
! 46520: call_tests++;
! 46521: des_xmlDocPtr(n_doc, doc, 0);
! 46522: xmlResetLastError();
! 46523: if (mem_base != xmlMemBlocks()) {
! 46524: printf("Leak of %d blocks found in xmlXPathOrderDocElems",
! 46525: xmlMemBlocks() - mem_base);
! 46526: test_ret++;
! 46527: printf(" %d", n_doc);
! 46528: printf("\n");
! 46529: }
! 46530: }
! 46531: function_tests++;
! 46532: #endif
! 46533:
! 46534: return(test_ret);
! 46535: }
! 46536:
! 46537: static int
! 46538: test_xpath(void) {
! 46539: int test_ret = 0;
! 46540:
! 46541: if (quiet == 0) printf("Testing xpath : 30 of 38 functions ...\n");
! 46542: test_ret += test_xmlXPathCastBooleanToNumber();
! 46543: test_ret += test_xmlXPathCastBooleanToString();
! 46544: test_ret += test_xmlXPathCastNodeSetToBoolean();
! 46545: test_ret += test_xmlXPathCastNodeSetToNumber();
! 46546: test_ret += test_xmlXPathCastNodeSetToString();
! 46547: test_ret += test_xmlXPathCastNodeToNumber();
! 46548: test_ret += test_xmlXPathCastNodeToString();
! 46549: test_ret += test_xmlXPathCastNumberToBoolean();
! 46550: test_ret += test_xmlXPathCastNumberToString();
! 46551: test_ret += test_xmlXPathCastStringToBoolean();
! 46552: test_ret += test_xmlXPathCastStringToNumber();
! 46553: test_ret += test_xmlXPathCastToBoolean();
! 46554: test_ret += test_xmlXPathCastToNumber();
! 46555: test_ret += test_xmlXPathCastToString();
! 46556: test_ret += test_xmlXPathCmpNodes();
! 46557: test_ret += test_xmlXPathCompile();
! 46558: test_ret += test_xmlXPathCompiledEval();
! 46559: test_ret += test_xmlXPathCompiledEvalToBoolean();
! 46560: test_ret += test_xmlXPathContextSetCache();
! 46561: test_ret += test_xmlXPathConvertBoolean();
! 46562: test_ret += test_xmlXPathConvertNumber();
! 46563: test_ret += test_xmlXPathConvertString();
! 46564: test_ret += test_xmlXPathCtxtCompile();
! 46565: test_ret += test_xmlXPathEval();
! 46566: test_ret += test_xmlXPathEvalExpression();
! 46567: test_ret += test_xmlXPathEvalPredicate();
! 46568: test_ret += test_xmlXPathInit();
! 46569: test_ret += test_xmlXPathIsInf();
! 46570: test_ret += test_xmlXPathIsNaN();
! 46571: test_ret += test_xmlXPathNewContext();
! 46572: test_ret += test_xmlXPathNodeSetCreate();
! 46573: test_ret += test_xmlXPathObjectCopy();
! 46574: test_ret += test_xmlXPathOrderDocElems();
! 46575:
! 46576: if (test_ret != 0)
! 46577: printf("Module xpath: %d errors\n", test_ret);
! 46578: return(test_ret);
! 46579: }
! 46580: #ifdef LIBXML_XPATH_ENABLED
! 46581:
! 46582: #define gen_nb_xmlXPathParserContextPtr 1
! 46583: static xmlXPathParserContextPtr gen_xmlXPathParserContextPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 46584: return(NULL);
! 46585: }
! 46586: static void des_xmlXPathParserContextPtr(int no ATTRIBUTE_UNUSED, xmlXPathParserContextPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 46587: }
! 46588: #endif
! 46589:
! 46590:
! 46591: static int
! 46592: test_valuePop(void) {
! 46593: int test_ret = 0;
! 46594:
! 46595: #if defined(LIBXML_XPATH_ENABLED)
! 46596: int mem_base;
! 46597: xmlXPathObjectPtr ret_val;
! 46598: xmlXPathParserContextPtr ctxt; /* an XPath evaluation context */
! 46599: int n_ctxt;
! 46600:
! 46601: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 46602: mem_base = xmlMemBlocks();
! 46603: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 46604:
! 46605: ret_val = valuePop(ctxt);
! 46606: desret_xmlXPathObjectPtr(ret_val);
! 46607: call_tests++;
! 46608: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 46609: xmlResetLastError();
! 46610: if (mem_base != xmlMemBlocks()) {
! 46611: printf("Leak of %d blocks found in valuePop",
! 46612: xmlMemBlocks() - mem_base);
! 46613: test_ret++;
! 46614: printf(" %d", n_ctxt);
! 46615: printf("\n");
! 46616: }
! 46617: }
! 46618: function_tests++;
! 46619: #endif
! 46620:
! 46621: return(test_ret);
! 46622: }
! 46623:
! 46624:
! 46625: static int
! 46626: test_valuePush(void) {
! 46627: int test_ret = 0;
! 46628:
! 46629: #if defined(LIBXML_XPATH_ENABLED)
! 46630: int mem_base;
! 46631: int ret_val;
! 46632: xmlXPathParserContextPtr ctxt; /* an XPath evaluation context */
! 46633: int n_ctxt;
! 46634: xmlXPathObjectPtr value; /* the XPath object */
! 46635: int n_value;
! 46636:
! 46637: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 46638: for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) {
! 46639: mem_base = xmlMemBlocks();
! 46640: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 46641: value = gen_xmlXPathObjectPtr(n_value, 1);
! 46642:
! 46643: ret_val = valuePush(ctxt, value);
! 46644: desret_int(ret_val);
! 46645: call_tests++;
! 46646: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 46647: des_xmlXPathObjectPtr(n_value, value, 1);
! 46648: xmlResetLastError();
! 46649: if (mem_base != xmlMemBlocks()) {
! 46650: printf("Leak of %d blocks found in valuePush",
! 46651: xmlMemBlocks() - mem_base);
! 46652: test_ret++;
! 46653: printf(" %d", n_ctxt);
! 46654: printf(" %d", n_value);
! 46655: printf("\n");
! 46656: }
! 46657: }
! 46658: }
! 46659: function_tests++;
! 46660: #endif
! 46661:
! 46662: return(test_ret);
! 46663: }
! 46664:
! 46665:
! 46666: static int
! 46667: test_xmlXPathAddValues(void) {
! 46668: int test_ret = 0;
! 46669:
! 46670: #if defined(LIBXML_XPATH_ENABLED)
! 46671: int mem_base;
! 46672: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 46673: int n_ctxt;
! 46674:
! 46675: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 46676: mem_base = xmlMemBlocks();
! 46677: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 46678:
! 46679: xmlXPathAddValues(ctxt);
! 46680: call_tests++;
! 46681: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 46682: xmlResetLastError();
! 46683: if (mem_base != xmlMemBlocks()) {
! 46684: printf("Leak of %d blocks found in xmlXPathAddValues",
! 46685: xmlMemBlocks() - mem_base);
! 46686: test_ret++;
! 46687: printf(" %d", n_ctxt);
! 46688: printf("\n");
! 46689: }
! 46690: }
! 46691: function_tests++;
! 46692: #endif
! 46693:
! 46694: return(test_ret);
! 46695: }
! 46696:
! 46697:
! 46698: static int
! 46699: test_xmlXPathBooleanFunction(void) {
! 46700: int test_ret = 0;
! 46701:
! 46702: #if defined(LIBXML_XPATH_ENABLED)
! 46703: int mem_base;
! 46704: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 46705: int n_ctxt;
! 46706: int nargs; /* the number of arguments */
! 46707: int n_nargs;
! 46708:
! 46709: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 46710: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 46711: mem_base = xmlMemBlocks();
! 46712: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 46713: nargs = gen_int(n_nargs, 1);
! 46714:
! 46715: xmlXPathBooleanFunction(ctxt, nargs);
! 46716: call_tests++;
! 46717: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 46718: des_int(n_nargs, nargs, 1);
! 46719: xmlResetLastError();
! 46720: if (mem_base != xmlMemBlocks()) {
! 46721: printf("Leak of %d blocks found in xmlXPathBooleanFunction",
! 46722: xmlMemBlocks() - mem_base);
! 46723: test_ret++;
! 46724: printf(" %d", n_ctxt);
! 46725: printf(" %d", n_nargs);
! 46726: printf("\n");
! 46727: }
! 46728: }
! 46729: }
! 46730: function_tests++;
! 46731: #endif
! 46732:
! 46733: return(test_ret);
! 46734: }
! 46735:
! 46736:
! 46737: static int
! 46738: test_xmlXPathCeilingFunction(void) {
! 46739: int test_ret = 0;
! 46740:
! 46741: #if defined(LIBXML_XPATH_ENABLED)
! 46742: int mem_base;
! 46743: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 46744: int n_ctxt;
! 46745: int nargs; /* the number of arguments */
! 46746: int n_nargs;
! 46747:
! 46748: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 46749: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 46750: mem_base = xmlMemBlocks();
! 46751: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 46752: nargs = gen_int(n_nargs, 1);
! 46753:
! 46754: xmlXPathCeilingFunction(ctxt, nargs);
! 46755: call_tests++;
! 46756: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 46757: des_int(n_nargs, nargs, 1);
! 46758: xmlResetLastError();
! 46759: if (mem_base != xmlMemBlocks()) {
! 46760: printf("Leak of %d blocks found in xmlXPathCeilingFunction",
! 46761: xmlMemBlocks() - mem_base);
! 46762: test_ret++;
! 46763: printf(" %d", n_ctxt);
! 46764: printf(" %d", n_nargs);
! 46765: printf("\n");
! 46766: }
! 46767: }
! 46768: }
! 46769: function_tests++;
! 46770: #endif
! 46771:
! 46772: return(test_ret);
! 46773: }
! 46774:
! 46775:
! 46776: static int
! 46777: test_xmlXPathCompareValues(void) {
! 46778: int test_ret = 0;
! 46779:
! 46780: #if defined(LIBXML_XPATH_ENABLED)
! 46781: int mem_base;
! 46782: int ret_val;
! 46783: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 46784: int n_ctxt;
! 46785: int inf; /* less than (1) or greater than (0) */
! 46786: int n_inf;
! 46787: int strict; /* is the comparison strict */
! 46788: int n_strict;
! 46789:
! 46790: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 46791: for (n_inf = 0;n_inf < gen_nb_int;n_inf++) {
! 46792: for (n_strict = 0;n_strict < gen_nb_int;n_strict++) {
! 46793: mem_base = xmlMemBlocks();
! 46794: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 46795: inf = gen_int(n_inf, 1);
! 46796: strict = gen_int(n_strict, 2);
! 46797:
! 46798: ret_val = xmlXPathCompareValues(ctxt, inf, strict);
! 46799: desret_int(ret_val);
! 46800: call_tests++;
! 46801: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 46802: des_int(n_inf, inf, 1);
! 46803: des_int(n_strict, strict, 2);
! 46804: xmlResetLastError();
! 46805: if (mem_base != xmlMemBlocks()) {
! 46806: printf("Leak of %d blocks found in xmlXPathCompareValues",
! 46807: xmlMemBlocks() - mem_base);
! 46808: test_ret++;
! 46809: printf(" %d", n_ctxt);
! 46810: printf(" %d", n_inf);
! 46811: printf(" %d", n_strict);
! 46812: printf("\n");
! 46813: }
! 46814: }
! 46815: }
! 46816: }
! 46817: function_tests++;
! 46818: #endif
! 46819:
! 46820: return(test_ret);
! 46821: }
! 46822:
! 46823:
! 46824: static int
! 46825: test_xmlXPathConcatFunction(void) {
! 46826: int test_ret = 0;
! 46827:
! 46828: #if defined(LIBXML_XPATH_ENABLED)
! 46829: int mem_base;
! 46830: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 46831: int n_ctxt;
! 46832: int nargs; /* the number of arguments */
! 46833: int n_nargs;
! 46834:
! 46835: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 46836: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 46837: mem_base = xmlMemBlocks();
! 46838: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 46839: nargs = gen_int(n_nargs, 1);
! 46840:
! 46841: xmlXPathConcatFunction(ctxt, nargs);
! 46842: call_tests++;
! 46843: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 46844: des_int(n_nargs, nargs, 1);
! 46845: xmlResetLastError();
! 46846: if (mem_base != xmlMemBlocks()) {
! 46847: printf("Leak of %d blocks found in xmlXPathConcatFunction",
! 46848: xmlMemBlocks() - mem_base);
! 46849: test_ret++;
! 46850: printf(" %d", n_ctxt);
! 46851: printf(" %d", n_nargs);
! 46852: printf("\n");
! 46853: }
! 46854: }
! 46855: }
! 46856: function_tests++;
! 46857: #endif
! 46858:
! 46859: return(test_ret);
! 46860: }
! 46861:
! 46862:
! 46863: static int
! 46864: test_xmlXPathContainsFunction(void) {
! 46865: int test_ret = 0;
! 46866:
! 46867: #if defined(LIBXML_XPATH_ENABLED)
! 46868: int mem_base;
! 46869: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 46870: int n_ctxt;
! 46871: int nargs; /* the number of arguments */
! 46872: int n_nargs;
! 46873:
! 46874: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 46875: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 46876: mem_base = xmlMemBlocks();
! 46877: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 46878: nargs = gen_int(n_nargs, 1);
! 46879:
! 46880: xmlXPathContainsFunction(ctxt, nargs);
! 46881: call_tests++;
! 46882: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 46883: des_int(n_nargs, nargs, 1);
! 46884: xmlResetLastError();
! 46885: if (mem_base != xmlMemBlocks()) {
! 46886: printf("Leak of %d blocks found in xmlXPathContainsFunction",
! 46887: xmlMemBlocks() - mem_base);
! 46888: test_ret++;
! 46889: printf(" %d", n_ctxt);
! 46890: printf(" %d", n_nargs);
! 46891: printf("\n");
! 46892: }
! 46893: }
! 46894: }
! 46895: function_tests++;
! 46896: #endif
! 46897:
! 46898: return(test_ret);
! 46899: }
! 46900:
! 46901:
! 46902: static int
! 46903: test_xmlXPathCountFunction(void) {
! 46904: int test_ret = 0;
! 46905:
! 46906: #if defined(LIBXML_XPATH_ENABLED)
! 46907: int mem_base;
! 46908: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 46909: int n_ctxt;
! 46910: int nargs; /* the number of arguments */
! 46911: int n_nargs;
! 46912:
! 46913: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 46914: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 46915: mem_base = xmlMemBlocks();
! 46916: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 46917: nargs = gen_int(n_nargs, 1);
! 46918:
! 46919: xmlXPathCountFunction(ctxt, nargs);
! 46920: call_tests++;
! 46921: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 46922: des_int(n_nargs, nargs, 1);
! 46923: xmlResetLastError();
! 46924: if (mem_base != xmlMemBlocks()) {
! 46925: printf("Leak of %d blocks found in xmlXPathCountFunction",
! 46926: xmlMemBlocks() - mem_base);
! 46927: test_ret++;
! 46928: printf(" %d", n_ctxt);
! 46929: printf(" %d", n_nargs);
! 46930: printf("\n");
! 46931: }
! 46932: }
! 46933: }
! 46934: function_tests++;
! 46935: #endif
! 46936:
! 46937: return(test_ret);
! 46938: }
! 46939:
! 46940:
! 46941: static int
! 46942: test_xmlXPathDebugDumpCompExpr(void) {
! 46943: int test_ret = 0;
! 46944:
! 46945: #if defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_DEBUG_ENABLED)
! 46946: int mem_base;
! 46947: FILE * output; /* the FILE * for the output */
! 46948: int n_output;
! 46949: xmlXPathCompExprPtr comp; /* the precompiled XPath expression */
! 46950: int n_comp;
! 46951: int depth; /* the indentation level. */
! 46952: int n_depth;
! 46953:
! 46954: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
! 46955: for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) {
! 46956: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
! 46957: mem_base = xmlMemBlocks();
! 46958: output = gen_FILE_ptr(n_output, 0);
! 46959: comp = gen_xmlXPathCompExprPtr(n_comp, 1);
! 46960: depth = gen_int(n_depth, 2);
! 46961:
! 46962: xmlXPathDebugDumpCompExpr(output, comp, depth);
! 46963: call_tests++;
! 46964: des_FILE_ptr(n_output, output, 0);
! 46965: des_xmlXPathCompExprPtr(n_comp, comp, 1);
! 46966: des_int(n_depth, depth, 2);
! 46967: xmlResetLastError();
! 46968: if (mem_base != xmlMemBlocks()) {
! 46969: printf("Leak of %d blocks found in xmlXPathDebugDumpCompExpr",
! 46970: xmlMemBlocks() - mem_base);
! 46971: test_ret++;
! 46972: printf(" %d", n_output);
! 46973: printf(" %d", n_comp);
! 46974: printf(" %d", n_depth);
! 46975: printf("\n");
! 46976: }
! 46977: }
! 46978: }
! 46979: }
! 46980: function_tests++;
! 46981: #endif
! 46982:
! 46983: return(test_ret);
! 46984: }
! 46985:
! 46986:
! 46987: static int
! 46988: test_xmlXPathDebugDumpObject(void) {
! 46989: int test_ret = 0;
! 46990:
! 46991: #if defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_DEBUG_ENABLED)
! 46992: int mem_base;
! 46993: FILE * output; /* the FILE * to dump the output */
! 46994: int n_output;
! 46995: xmlXPathObjectPtr cur; /* the object to inspect */
! 46996: int n_cur;
! 46997: int depth; /* indentation level */
! 46998: int n_depth;
! 46999:
! 47000: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
! 47001: for (n_cur = 0;n_cur < gen_nb_xmlXPathObjectPtr;n_cur++) {
! 47002: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
! 47003: mem_base = xmlMemBlocks();
! 47004: output = gen_FILE_ptr(n_output, 0);
! 47005: cur = gen_xmlXPathObjectPtr(n_cur, 1);
! 47006: depth = gen_int(n_depth, 2);
! 47007:
! 47008: xmlXPathDebugDumpObject(output, cur, depth);
! 47009: call_tests++;
! 47010: des_FILE_ptr(n_output, output, 0);
! 47011: des_xmlXPathObjectPtr(n_cur, cur, 1);
! 47012: des_int(n_depth, depth, 2);
! 47013: xmlResetLastError();
! 47014: if (mem_base != xmlMemBlocks()) {
! 47015: printf("Leak of %d blocks found in xmlXPathDebugDumpObject",
! 47016: xmlMemBlocks() - mem_base);
! 47017: test_ret++;
! 47018: printf(" %d", n_output);
! 47019: printf(" %d", n_cur);
! 47020: printf(" %d", n_depth);
! 47021: printf("\n");
! 47022: }
! 47023: }
! 47024: }
! 47025: }
! 47026: function_tests++;
! 47027: #endif
! 47028:
! 47029: return(test_ret);
! 47030: }
! 47031:
! 47032:
! 47033: static int
! 47034: test_xmlXPathDifference(void) {
! 47035: int test_ret = 0;
! 47036:
! 47037: #if defined(LIBXML_XPATH_ENABLED)
! 47038: int mem_base;
! 47039: xmlNodeSetPtr ret_val;
! 47040: xmlNodeSetPtr nodes1; /* a node-set */
! 47041: int n_nodes1;
! 47042: xmlNodeSetPtr nodes2; /* a node-set */
! 47043: int n_nodes2;
! 47044:
! 47045: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
! 47046: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
! 47047: mem_base = xmlMemBlocks();
! 47048: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
! 47049: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
! 47050:
! 47051: ret_val = xmlXPathDifference(nodes1, nodes2);
! 47052: desret_xmlNodeSetPtr(ret_val);
! 47053: call_tests++;
! 47054: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
! 47055: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
! 47056: xmlResetLastError();
! 47057: if (mem_base != xmlMemBlocks()) {
! 47058: printf("Leak of %d blocks found in xmlXPathDifference",
! 47059: xmlMemBlocks() - mem_base);
! 47060: test_ret++;
! 47061: printf(" %d", n_nodes1);
! 47062: printf(" %d", n_nodes2);
! 47063: printf("\n");
! 47064: }
! 47065: }
! 47066: }
! 47067: function_tests++;
! 47068: #endif
! 47069:
! 47070: return(test_ret);
! 47071: }
! 47072:
! 47073:
! 47074: static int
! 47075: test_xmlXPathDistinct(void) {
! 47076: int test_ret = 0;
! 47077:
! 47078: #if defined(LIBXML_XPATH_ENABLED)
! 47079: int mem_base;
! 47080: xmlNodeSetPtr ret_val;
! 47081: xmlNodeSetPtr nodes; /* a node-set */
! 47082: int n_nodes;
! 47083:
! 47084: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
! 47085: mem_base = xmlMemBlocks();
! 47086: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
! 47087:
! 47088: ret_val = xmlXPathDistinct(nodes);
! 47089: desret_xmlNodeSetPtr(ret_val);
! 47090: call_tests++;
! 47091: des_xmlNodeSetPtr(n_nodes, nodes, 0);
! 47092: xmlResetLastError();
! 47093: if (mem_base != xmlMemBlocks()) {
! 47094: printf("Leak of %d blocks found in xmlXPathDistinct",
! 47095: xmlMemBlocks() - mem_base);
! 47096: test_ret++;
! 47097: printf(" %d", n_nodes);
! 47098: printf("\n");
! 47099: }
! 47100: }
! 47101: function_tests++;
! 47102: #endif
! 47103:
! 47104: return(test_ret);
! 47105: }
! 47106:
! 47107:
! 47108: static int
! 47109: test_xmlXPathDistinctSorted(void) {
! 47110: int test_ret = 0;
! 47111:
! 47112: #if defined(LIBXML_XPATH_ENABLED)
! 47113: int mem_base;
! 47114: xmlNodeSetPtr ret_val;
! 47115: xmlNodeSetPtr nodes; /* a node-set, sorted by document order */
! 47116: int n_nodes;
! 47117:
! 47118: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
! 47119: mem_base = xmlMemBlocks();
! 47120: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
! 47121:
! 47122: ret_val = xmlXPathDistinctSorted(nodes);
! 47123: desret_xmlNodeSetPtr(ret_val);
! 47124: call_tests++;
! 47125: des_xmlNodeSetPtr(n_nodes, nodes, 0);
! 47126: xmlResetLastError();
! 47127: if (mem_base != xmlMemBlocks()) {
! 47128: printf("Leak of %d blocks found in xmlXPathDistinctSorted",
! 47129: xmlMemBlocks() - mem_base);
! 47130: test_ret++;
! 47131: printf(" %d", n_nodes);
! 47132: printf("\n");
! 47133: }
! 47134: }
! 47135: function_tests++;
! 47136: #endif
! 47137:
! 47138: return(test_ret);
! 47139: }
! 47140:
! 47141:
! 47142: static int
! 47143: test_xmlXPathDivValues(void) {
! 47144: int test_ret = 0;
! 47145:
! 47146: #if defined(LIBXML_XPATH_ENABLED)
! 47147: int mem_base;
! 47148: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 47149: int n_ctxt;
! 47150:
! 47151: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 47152: mem_base = xmlMemBlocks();
! 47153: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 47154:
! 47155: xmlXPathDivValues(ctxt);
! 47156: call_tests++;
! 47157: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 47158: xmlResetLastError();
! 47159: if (mem_base != xmlMemBlocks()) {
! 47160: printf("Leak of %d blocks found in xmlXPathDivValues",
! 47161: xmlMemBlocks() - mem_base);
! 47162: test_ret++;
! 47163: printf(" %d", n_ctxt);
! 47164: printf("\n");
! 47165: }
! 47166: }
! 47167: function_tests++;
! 47168: #endif
! 47169:
! 47170: return(test_ret);
! 47171: }
! 47172:
! 47173:
! 47174: static int
! 47175: test_xmlXPathEqualValues(void) {
! 47176: int test_ret = 0;
! 47177:
! 47178: #if defined(LIBXML_XPATH_ENABLED)
! 47179: int mem_base;
! 47180: int ret_val;
! 47181: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 47182: int n_ctxt;
! 47183:
! 47184: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 47185: mem_base = xmlMemBlocks();
! 47186: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 47187:
! 47188: ret_val = xmlXPathEqualValues(ctxt);
! 47189: desret_int(ret_val);
! 47190: call_tests++;
! 47191: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 47192: xmlResetLastError();
! 47193: if (mem_base != xmlMemBlocks()) {
! 47194: printf("Leak of %d blocks found in xmlXPathEqualValues",
! 47195: xmlMemBlocks() - mem_base);
! 47196: test_ret++;
! 47197: printf(" %d", n_ctxt);
! 47198: printf("\n");
! 47199: }
! 47200: }
! 47201: function_tests++;
! 47202: #endif
! 47203:
! 47204: return(test_ret);
! 47205: }
! 47206:
! 47207:
! 47208: static int
! 47209: test_xmlXPathErr(void) {
! 47210: int test_ret = 0;
! 47211:
! 47212: #if defined(LIBXML_XPATH_ENABLED)
! 47213: int mem_base;
! 47214: xmlXPathParserContextPtr ctxt; /* a XPath parser context */
! 47215: int n_ctxt;
! 47216: int error; /* the error code */
! 47217: int n_error;
! 47218:
! 47219: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 47220: for (n_error = 0;n_error < gen_nb_int;n_error++) {
! 47221: mem_base = xmlMemBlocks();
! 47222: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 47223: error = gen_int(n_error, 1);
! 47224:
! 47225: xmlXPathErr(ctxt, error);
! 47226: call_tests++;
! 47227: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 47228: des_int(n_error, error, 1);
! 47229: xmlResetLastError();
! 47230: if (mem_base != xmlMemBlocks()) {
! 47231: printf("Leak of %d blocks found in xmlXPathErr",
! 47232: xmlMemBlocks() - mem_base);
! 47233: test_ret++;
! 47234: printf(" %d", n_ctxt);
! 47235: printf(" %d", n_error);
! 47236: printf("\n");
! 47237: }
! 47238: }
! 47239: }
! 47240: function_tests++;
! 47241: #endif
! 47242:
! 47243: return(test_ret);
! 47244: }
! 47245:
! 47246:
! 47247: static int
! 47248: test_xmlXPathEvalExpr(void) {
! 47249: int test_ret = 0;
! 47250:
! 47251: #if defined(LIBXML_XPATH_ENABLED)
! 47252: int mem_base;
! 47253: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 47254: int n_ctxt;
! 47255:
! 47256: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 47257: mem_base = xmlMemBlocks();
! 47258: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 47259:
! 47260: xmlXPathEvalExpr(ctxt);
! 47261: call_tests++;
! 47262: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 47263: xmlResetLastError();
! 47264: if (mem_base != xmlMemBlocks()) {
! 47265: printf("Leak of %d blocks found in xmlXPathEvalExpr",
! 47266: xmlMemBlocks() - mem_base);
! 47267: test_ret++;
! 47268: printf(" %d", n_ctxt);
! 47269: printf("\n");
! 47270: }
! 47271: }
! 47272: function_tests++;
! 47273: #endif
! 47274:
! 47275: return(test_ret);
! 47276: }
! 47277:
! 47278:
! 47279: static int
! 47280: test_xmlXPathEvaluatePredicateResult(void) {
! 47281: int test_ret = 0;
! 47282:
! 47283: #if defined(LIBXML_XPATH_ENABLED)
! 47284: int mem_base;
! 47285: int ret_val;
! 47286: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 47287: int n_ctxt;
! 47288: xmlXPathObjectPtr res; /* the Predicate Expression evaluation result */
! 47289: int n_res;
! 47290:
! 47291: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 47292: for (n_res = 0;n_res < gen_nb_xmlXPathObjectPtr;n_res++) {
! 47293: mem_base = xmlMemBlocks();
! 47294: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 47295: res = gen_xmlXPathObjectPtr(n_res, 1);
! 47296:
! 47297: ret_val = xmlXPathEvaluatePredicateResult(ctxt, res);
! 47298: desret_int(ret_val);
! 47299: call_tests++;
! 47300: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 47301: des_xmlXPathObjectPtr(n_res, res, 1);
! 47302: xmlResetLastError();
! 47303: if (mem_base != xmlMemBlocks()) {
! 47304: printf("Leak of %d blocks found in xmlXPathEvaluatePredicateResult",
! 47305: xmlMemBlocks() - mem_base);
! 47306: test_ret++;
! 47307: printf(" %d", n_ctxt);
! 47308: printf(" %d", n_res);
! 47309: printf("\n");
! 47310: }
! 47311: }
! 47312: }
! 47313: function_tests++;
! 47314: #endif
! 47315:
! 47316: return(test_ret);
! 47317: }
! 47318:
! 47319:
! 47320: static int
! 47321: test_xmlXPathFalseFunction(void) {
! 47322: int test_ret = 0;
! 47323:
! 47324: #if defined(LIBXML_XPATH_ENABLED)
! 47325: int mem_base;
! 47326: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 47327: int n_ctxt;
! 47328: int nargs; /* the number of arguments */
! 47329: int n_nargs;
! 47330:
! 47331: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 47332: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 47333: mem_base = xmlMemBlocks();
! 47334: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 47335: nargs = gen_int(n_nargs, 1);
! 47336:
! 47337: xmlXPathFalseFunction(ctxt, nargs);
! 47338: call_tests++;
! 47339: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 47340: des_int(n_nargs, nargs, 1);
! 47341: xmlResetLastError();
! 47342: if (mem_base != xmlMemBlocks()) {
! 47343: printf("Leak of %d blocks found in xmlXPathFalseFunction",
! 47344: xmlMemBlocks() - mem_base);
! 47345: test_ret++;
! 47346: printf(" %d", n_ctxt);
! 47347: printf(" %d", n_nargs);
! 47348: printf("\n");
! 47349: }
! 47350: }
! 47351: }
! 47352: function_tests++;
! 47353: #endif
! 47354:
! 47355: return(test_ret);
! 47356: }
! 47357:
! 47358:
! 47359: static int
! 47360: test_xmlXPathFloorFunction(void) {
! 47361: int test_ret = 0;
! 47362:
! 47363: #if defined(LIBXML_XPATH_ENABLED)
! 47364: int mem_base;
! 47365: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 47366: int n_ctxt;
! 47367: int nargs; /* the number of arguments */
! 47368: int n_nargs;
! 47369:
! 47370: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 47371: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 47372: mem_base = xmlMemBlocks();
! 47373: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 47374: nargs = gen_int(n_nargs, 1);
! 47375:
! 47376: xmlXPathFloorFunction(ctxt, nargs);
! 47377: call_tests++;
! 47378: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 47379: des_int(n_nargs, nargs, 1);
! 47380: xmlResetLastError();
! 47381: if (mem_base != xmlMemBlocks()) {
! 47382: printf("Leak of %d blocks found in xmlXPathFloorFunction",
! 47383: xmlMemBlocks() - mem_base);
! 47384: test_ret++;
! 47385: printf(" %d", n_ctxt);
! 47386: printf(" %d", n_nargs);
! 47387: printf("\n");
! 47388: }
! 47389: }
! 47390: }
! 47391: function_tests++;
! 47392: #endif
! 47393:
! 47394: return(test_ret);
! 47395: }
! 47396:
! 47397:
! 47398: static int
! 47399: test_xmlXPathFunctionLookup(void) {
! 47400: int test_ret = 0;
! 47401:
! 47402:
! 47403: /* missing type support */
! 47404: return(test_ret);
! 47405: }
! 47406:
! 47407:
! 47408: static int
! 47409: test_xmlXPathFunctionLookupNS(void) {
! 47410: int test_ret = 0;
! 47411:
! 47412:
! 47413: /* missing type support */
! 47414: return(test_ret);
! 47415: }
! 47416:
! 47417:
! 47418: static int
! 47419: test_xmlXPathHasSameNodes(void) {
! 47420: int test_ret = 0;
! 47421:
! 47422: #if defined(LIBXML_XPATH_ENABLED)
! 47423: int mem_base;
! 47424: int ret_val;
! 47425: xmlNodeSetPtr nodes1; /* a node-set */
! 47426: int n_nodes1;
! 47427: xmlNodeSetPtr nodes2; /* a node-set */
! 47428: int n_nodes2;
! 47429:
! 47430: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
! 47431: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
! 47432: mem_base = xmlMemBlocks();
! 47433: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
! 47434: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
! 47435:
! 47436: ret_val = xmlXPathHasSameNodes(nodes1, nodes2);
! 47437: desret_int(ret_val);
! 47438: call_tests++;
! 47439: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
! 47440: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
! 47441: xmlResetLastError();
! 47442: if (mem_base != xmlMemBlocks()) {
! 47443: printf("Leak of %d blocks found in xmlXPathHasSameNodes",
! 47444: xmlMemBlocks() - mem_base);
! 47445: test_ret++;
! 47446: printf(" %d", n_nodes1);
! 47447: printf(" %d", n_nodes2);
! 47448: printf("\n");
! 47449: }
! 47450: }
! 47451: }
! 47452: function_tests++;
! 47453: #endif
! 47454:
! 47455: return(test_ret);
! 47456: }
! 47457:
! 47458:
! 47459: static int
! 47460: test_xmlXPathIdFunction(void) {
! 47461: int test_ret = 0;
! 47462:
! 47463: #if defined(LIBXML_XPATH_ENABLED)
! 47464: int mem_base;
! 47465: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 47466: int n_ctxt;
! 47467: int nargs; /* the number of arguments */
! 47468: int n_nargs;
! 47469:
! 47470: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 47471: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 47472: mem_base = xmlMemBlocks();
! 47473: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 47474: nargs = gen_int(n_nargs, 1);
! 47475:
! 47476: xmlXPathIdFunction(ctxt, nargs);
! 47477: call_tests++;
! 47478: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 47479: des_int(n_nargs, nargs, 1);
! 47480: xmlResetLastError();
! 47481: if (mem_base != xmlMemBlocks()) {
! 47482: printf("Leak of %d blocks found in xmlXPathIdFunction",
! 47483: xmlMemBlocks() - mem_base);
! 47484: test_ret++;
! 47485: printf(" %d", n_ctxt);
! 47486: printf(" %d", n_nargs);
! 47487: printf("\n");
! 47488: }
! 47489: }
! 47490: }
! 47491: function_tests++;
! 47492: #endif
! 47493:
! 47494: return(test_ret);
! 47495: }
! 47496:
! 47497:
! 47498: static int
! 47499: test_xmlXPathIntersection(void) {
! 47500: int test_ret = 0;
! 47501:
! 47502: #if defined(LIBXML_XPATH_ENABLED)
! 47503: int mem_base;
! 47504: xmlNodeSetPtr ret_val;
! 47505: xmlNodeSetPtr nodes1; /* a node-set */
! 47506: int n_nodes1;
! 47507: xmlNodeSetPtr nodes2; /* a node-set */
! 47508: int n_nodes2;
! 47509:
! 47510: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
! 47511: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
! 47512: mem_base = xmlMemBlocks();
! 47513: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
! 47514: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
! 47515:
! 47516: ret_val = xmlXPathIntersection(nodes1, nodes2);
! 47517: desret_xmlNodeSetPtr(ret_val);
! 47518: call_tests++;
! 47519: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
! 47520: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
! 47521: xmlResetLastError();
! 47522: if (mem_base != xmlMemBlocks()) {
! 47523: printf("Leak of %d blocks found in xmlXPathIntersection",
! 47524: xmlMemBlocks() - mem_base);
! 47525: test_ret++;
! 47526: printf(" %d", n_nodes1);
! 47527: printf(" %d", n_nodes2);
! 47528: printf("\n");
! 47529: }
! 47530: }
! 47531: }
! 47532: function_tests++;
! 47533: #endif
! 47534:
! 47535: return(test_ret);
! 47536: }
! 47537:
! 47538:
! 47539: static int
! 47540: test_xmlXPathIsNodeType(void) {
! 47541: int test_ret = 0;
! 47542:
! 47543: #if defined(LIBXML_XPATH_ENABLED)
! 47544: int mem_base;
! 47545: int ret_val;
! 47546: xmlChar * name; /* a name string */
! 47547: int n_name;
! 47548:
! 47549: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 47550: mem_base = xmlMemBlocks();
! 47551: name = gen_const_xmlChar_ptr(n_name, 0);
! 47552:
! 47553: ret_val = xmlXPathIsNodeType((const xmlChar *)name);
! 47554: desret_int(ret_val);
! 47555: call_tests++;
! 47556: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
! 47557: xmlResetLastError();
! 47558: if (mem_base != xmlMemBlocks()) {
! 47559: printf("Leak of %d blocks found in xmlXPathIsNodeType",
! 47560: xmlMemBlocks() - mem_base);
! 47561: test_ret++;
! 47562: printf(" %d", n_name);
! 47563: printf("\n");
! 47564: }
! 47565: }
! 47566: function_tests++;
! 47567: #endif
! 47568:
! 47569: return(test_ret);
! 47570: }
! 47571:
! 47572:
! 47573: static int
! 47574: test_xmlXPathLangFunction(void) {
! 47575: int test_ret = 0;
! 47576:
! 47577: #if defined(LIBXML_XPATH_ENABLED)
! 47578: int mem_base;
! 47579: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 47580: int n_ctxt;
! 47581: int nargs; /* the number of arguments */
! 47582: int n_nargs;
! 47583:
! 47584: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 47585: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 47586: mem_base = xmlMemBlocks();
! 47587: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 47588: nargs = gen_int(n_nargs, 1);
! 47589:
! 47590: xmlXPathLangFunction(ctxt, nargs);
! 47591: call_tests++;
! 47592: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 47593: des_int(n_nargs, nargs, 1);
! 47594: xmlResetLastError();
! 47595: if (mem_base != xmlMemBlocks()) {
! 47596: printf("Leak of %d blocks found in xmlXPathLangFunction",
! 47597: xmlMemBlocks() - mem_base);
! 47598: test_ret++;
! 47599: printf(" %d", n_ctxt);
! 47600: printf(" %d", n_nargs);
! 47601: printf("\n");
! 47602: }
! 47603: }
! 47604: }
! 47605: function_tests++;
! 47606: #endif
! 47607:
! 47608: return(test_ret);
! 47609: }
! 47610:
! 47611:
! 47612: static int
! 47613: test_xmlXPathLastFunction(void) {
! 47614: int test_ret = 0;
! 47615:
! 47616: #if defined(LIBXML_XPATH_ENABLED)
! 47617: int mem_base;
! 47618: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 47619: int n_ctxt;
! 47620: int nargs; /* the number of arguments */
! 47621: int n_nargs;
! 47622:
! 47623: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 47624: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 47625: mem_base = xmlMemBlocks();
! 47626: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 47627: nargs = gen_int(n_nargs, 1);
! 47628:
! 47629: xmlXPathLastFunction(ctxt, nargs);
! 47630: call_tests++;
! 47631: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 47632: des_int(n_nargs, nargs, 1);
! 47633: xmlResetLastError();
! 47634: if (mem_base != xmlMemBlocks()) {
! 47635: printf("Leak of %d blocks found in xmlXPathLastFunction",
! 47636: xmlMemBlocks() - mem_base);
! 47637: test_ret++;
! 47638: printf(" %d", n_ctxt);
! 47639: printf(" %d", n_nargs);
! 47640: printf("\n");
! 47641: }
! 47642: }
! 47643: }
! 47644: function_tests++;
! 47645: #endif
! 47646:
! 47647: return(test_ret);
! 47648: }
! 47649:
! 47650:
! 47651: static int
! 47652: test_xmlXPathLeading(void) {
! 47653: int test_ret = 0;
! 47654:
! 47655: #if defined(LIBXML_XPATH_ENABLED)
! 47656: int mem_base;
! 47657: xmlNodeSetPtr ret_val;
! 47658: xmlNodeSetPtr nodes1; /* a node-set */
! 47659: int n_nodes1;
! 47660: xmlNodeSetPtr nodes2; /* a node-set */
! 47661: int n_nodes2;
! 47662:
! 47663: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
! 47664: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
! 47665: mem_base = xmlMemBlocks();
! 47666: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
! 47667: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
! 47668:
! 47669: ret_val = xmlXPathLeading(nodes1, nodes2);
! 47670: desret_xmlNodeSetPtr(ret_val);
! 47671: call_tests++;
! 47672: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
! 47673: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
! 47674: xmlResetLastError();
! 47675: if (mem_base != xmlMemBlocks()) {
! 47676: printf("Leak of %d blocks found in xmlXPathLeading",
! 47677: xmlMemBlocks() - mem_base);
! 47678: test_ret++;
! 47679: printf(" %d", n_nodes1);
! 47680: printf(" %d", n_nodes2);
! 47681: printf("\n");
! 47682: }
! 47683: }
! 47684: }
! 47685: function_tests++;
! 47686: #endif
! 47687:
! 47688: return(test_ret);
! 47689: }
! 47690:
! 47691:
! 47692: static int
! 47693: test_xmlXPathLeadingSorted(void) {
! 47694: int test_ret = 0;
! 47695:
! 47696: #if defined(LIBXML_XPATH_ENABLED)
! 47697: int mem_base;
! 47698: xmlNodeSetPtr ret_val;
! 47699: xmlNodeSetPtr nodes1; /* a node-set, sorted by document order */
! 47700: int n_nodes1;
! 47701: xmlNodeSetPtr nodes2; /* a node-set, sorted by document order */
! 47702: int n_nodes2;
! 47703:
! 47704: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
! 47705: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
! 47706: mem_base = xmlMemBlocks();
! 47707: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
! 47708: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
! 47709:
! 47710: ret_val = xmlXPathLeadingSorted(nodes1, nodes2);
! 47711: desret_xmlNodeSetPtr(ret_val);
! 47712: call_tests++;
! 47713: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
! 47714: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
! 47715: xmlResetLastError();
! 47716: if (mem_base != xmlMemBlocks()) {
! 47717: printf("Leak of %d blocks found in xmlXPathLeadingSorted",
! 47718: xmlMemBlocks() - mem_base);
! 47719: test_ret++;
! 47720: printf(" %d", n_nodes1);
! 47721: printf(" %d", n_nodes2);
! 47722: printf("\n");
! 47723: }
! 47724: }
! 47725: }
! 47726: function_tests++;
! 47727: #endif
! 47728:
! 47729: return(test_ret);
! 47730: }
! 47731:
! 47732:
! 47733: static int
! 47734: test_xmlXPathLocalNameFunction(void) {
! 47735: int test_ret = 0;
! 47736:
! 47737: #if defined(LIBXML_XPATH_ENABLED)
! 47738: int mem_base;
! 47739: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 47740: int n_ctxt;
! 47741: int nargs; /* the number of arguments */
! 47742: int n_nargs;
! 47743:
! 47744: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 47745: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 47746: mem_base = xmlMemBlocks();
! 47747: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 47748: nargs = gen_int(n_nargs, 1);
! 47749:
! 47750: xmlXPathLocalNameFunction(ctxt, nargs);
! 47751: call_tests++;
! 47752: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 47753: des_int(n_nargs, nargs, 1);
! 47754: xmlResetLastError();
! 47755: if (mem_base != xmlMemBlocks()) {
! 47756: printf("Leak of %d blocks found in xmlXPathLocalNameFunction",
! 47757: xmlMemBlocks() - mem_base);
! 47758: test_ret++;
! 47759: printf(" %d", n_ctxt);
! 47760: printf(" %d", n_nargs);
! 47761: printf("\n");
! 47762: }
! 47763: }
! 47764: }
! 47765: function_tests++;
! 47766: #endif
! 47767:
! 47768: return(test_ret);
! 47769: }
! 47770:
! 47771:
! 47772: static int
! 47773: test_xmlXPathModValues(void) {
! 47774: int test_ret = 0;
! 47775:
! 47776: #if defined(LIBXML_XPATH_ENABLED)
! 47777: int mem_base;
! 47778: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 47779: int n_ctxt;
! 47780:
! 47781: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 47782: mem_base = xmlMemBlocks();
! 47783: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 47784:
! 47785: xmlXPathModValues(ctxt);
! 47786: call_tests++;
! 47787: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 47788: xmlResetLastError();
! 47789: if (mem_base != xmlMemBlocks()) {
! 47790: printf("Leak of %d blocks found in xmlXPathModValues",
! 47791: xmlMemBlocks() - mem_base);
! 47792: test_ret++;
! 47793: printf(" %d", n_ctxt);
! 47794: printf("\n");
! 47795: }
! 47796: }
! 47797: function_tests++;
! 47798: #endif
! 47799:
! 47800: return(test_ret);
! 47801: }
! 47802:
! 47803:
! 47804: static int
! 47805: test_xmlXPathMultValues(void) {
! 47806: int test_ret = 0;
! 47807:
! 47808: #if defined(LIBXML_XPATH_ENABLED)
! 47809: int mem_base;
! 47810: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 47811: int n_ctxt;
! 47812:
! 47813: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 47814: mem_base = xmlMemBlocks();
! 47815: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 47816:
! 47817: xmlXPathMultValues(ctxt);
! 47818: call_tests++;
! 47819: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 47820: xmlResetLastError();
! 47821: if (mem_base != xmlMemBlocks()) {
! 47822: printf("Leak of %d blocks found in xmlXPathMultValues",
! 47823: xmlMemBlocks() - mem_base);
! 47824: test_ret++;
! 47825: printf(" %d", n_ctxt);
! 47826: printf("\n");
! 47827: }
! 47828: }
! 47829: function_tests++;
! 47830: #endif
! 47831:
! 47832: return(test_ret);
! 47833: }
! 47834:
! 47835:
! 47836: static int
! 47837: test_xmlXPathNamespaceURIFunction(void) {
! 47838: int test_ret = 0;
! 47839:
! 47840: #if defined(LIBXML_XPATH_ENABLED)
! 47841: int mem_base;
! 47842: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 47843: int n_ctxt;
! 47844: int nargs; /* the number of arguments */
! 47845: int n_nargs;
! 47846:
! 47847: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 47848: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 47849: mem_base = xmlMemBlocks();
! 47850: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 47851: nargs = gen_int(n_nargs, 1);
! 47852:
! 47853: xmlXPathNamespaceURIFunction(ctxt, nargs);
! 47854: call_tests++;
! 47855: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 47856: des_int(n_nargs, nargs, 1);
! 47857: xmlResetLastError();
! 47858: if (mem_base != xmlMemBlocks()) {
! 47859: printf("Leak of %d blocks found in xmlXPathNamespaceURIFunction",
! 47860: xmlMemBlocks() - mem_base);
! 47861: test_ret++;
! 47862: printf(" %d", n_ctxt);
! 47863: printf(" %d", n_nargs);
! 47864: printf("\n");
! 47865: }
! 47866: }
! 47867: }
! 47868: function_tests++;
! 47869: #endif
! 47870:
! 47871: return(test_ret);
! 47872: }
! 47873:
! 47874:
! 47875: static int
! 47876: test_xmlXPathNewBoolean(void) {
! 47877: int test_ret = 0;
! 47878:
! 47879: #if defined(LIBXML_XPATH_ENABLED)
! 47880: int mem_base;
! 47881: xmlXPathObjectPtr ret_val;
! 47882: int val; /* the boolean value */
! 47883: int n_val;
! 47884:
! 47885: for (n_val = 0;n_val < gen_nb_int;n_val++) {
! 47886: mem_base = xmlMemBlocks();
! 47887: val = gen_int(n_val, 0);
! 47888:
! 47889: ret_val = xmlXPathNewBoolean(val);
! 47890: desret_xmlXPathObjectPtr(ret_val);
! 47891: call_tests++;
! 47892: des_int(n_val, val, 0);
! 47893: xmlResetLastError();
! 47894: if (mem_base != xmlMemBlocks()) {
! 47895: printf("Leak of %d blocks found in xmlXPathNewBoolean",
! 47896: xmlMemBlocks() - mem_base);
! 47897: test_ret++;
! 47898: printf(" %d", n_val);
! 47899: printf("\n");
! 47900: }
! 47901: }
! 47902: function_tests++;
! 47903: #endif
! 47904:
! 47905: return(test_ret);
! 47906: }
! 47907:
! 47908:
! 47909: static int
! 47910: test_xmlXPathNewCString(void) {
! 47911: int test_ret = 0;
! 47912:
! 47913: #if defined(LIBXML_XPATH_ENABLED)
! 47914: int mem_base;
! 47915: xmlXPathObjectPtr ret_val;
! 47916: char * val; /* the char * value */
! 47917: int n_val;
! 47918:
! 47919: for (n_val = 0;n_val < gen_nb_const_char_ptr;n_val++) {
! 47920: mem_base = xmlMemBlocks();
! 47921: val = gen_const_char_ptr(n_val, 0);
! 47922:
! 47923: ret_val = xmlXPathNewCString((const char *)val);
! 47924: desret_xmlXPathObjectPtr(ret_val);
! 47925: call_tests++;
! 47926: des_const_char_ptr(n_val, (const char *)val, 0);
! 47927: xmlResetLastError();
! 47928: if (mem_base != xmlMemBlocks()) {
! 47929: printf("Leak of %d blocks found in xmlXPathNewCString",
! 47930: xmlMemBlocks() - mem_base);
! 47931: test_ret++;
! 47932: printf(" %d", n_val);
! 47933: printf("\n");
! 47934: }
! 47935: }
! 47936: function_tests++;
! 47937: #endif
! 47938:
! 47939: return(test_ret);
! 47940: }
! 47941:
! 47942:
! 47943: static int
! 47944: test_xmlXPathNewFloat(void) {
! 47945: int test_ret = 0;
! 47946:
! 47947: #if defined(LIBXML_XPATH_ENABLED)
! 47948: int mem_base;
! 47949: xmlXPathObjectPtr ret_val;
! 47950: double val; /* the double value */
! 47951: int n_val;
! 47952:
! 47953: for (n_val = 0;n_val < gen_nb_double;n_val++) {
! 47954: mem_base = xmlMemBlocks();
! 47955: val = gen_double(n_val, 0);
! 47956:
! 47957: ret_val = xmlXPathNewFloat(val);
! 47958: desret_xmlXPathObjectPtr(ret_val);
! 47959: call_tests++;
! 47960: des_double(n_val, val, 0);
! 47961: xmlResetLastError();
! 47962: if (mem_base != xmlMemBlocks()) {
! 47963: printf("Leak of %d blocks found in xmlXPathNewFloat",
! 47964: xmlMemBlocks() - mem_base);
! 47965: test_ret++;
! 47966: printf(" %d", n_val);
! 47967: printf("\n");
! 47968: }
! 47969: }
! 47970: function_tests++;
! 47971: #endif
! 47972:
! 47973: return(test_ret);
! 47974: }
! 47975:
! 47976:
! 47977: static int
! 47978: test_xmlXPathNewNodeSet(void) {
! 47979: int test_ret = 0;
! 47980:
! 47981: #if defined(LIBXML_XPATH_ENABLED)
! 47982: int mem_base;
! 47983: xmlXPathObjectPtr ret_val;
! 47984: xmlNodePtr val; /* the NodePtr value */
! 47985: int n_val;
! 47986:
! 47987: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
! 47988: mem_base = xmlMemBlocks();
! 47989: val = gen_xmlNodePtr(n_val, 0);
! 47990:
! 47991: ret_val = xmlXPathNewNodeSet(val);
! 47992: desret_xmlXPathObjectPtr(ret_val);
! 47993: call_tests++;
! 47994: des_xmlNodePtr(n_val, val, 0);
! 47995: xmlResetLastError();
! 47996: if (mem_base != xmlMemBlocks()) {
! 47997: printf("Leak of %d blocks found in xmlXPathNewNodeSet",
! 47998: xmlMemBlocks() - mem_base);
! 47999: test_ret++;
! 48000: printf(" %d", n_val);
! 48001: printf("\n");
! 48002: }
! 48003: }
! 48004: function_tests++;
! 48005: #endif
! 48006:
! 48007: return(test_ret);
! 48008: }
! 48009:
! 48010:
! 48011: static int
! 48012: test_xmlXPathNewNodeSetList(void) {
! 48013: int test_ret = 0;
! 48014:
! 48015: #if defined(LIBXML_XPATH_ENABLED)
! 48016: int mem_base;
! 48017: xmlXPathObjectPtr ret_val;
! 48018: xmlNodeSetPtr val; /* an existing NodeSet */
! 48019: int n_val;
! 48020:
! 48021: for (n_val = 0;n_val < gen_nb_xmlNodeSetPtr;n_val++) {
! 48022: mem_base = xmlMemBlocks();
! 48023: val = gen_xmlNodeSetPtr(n_val, 0);
! 48024:
! 48025: ret_val = xmlXPathNewNodeSetList(val);
! 48026: desret_xmlXPathObjectPtr(ret_val);
! 48027: call_tests++;
! 48028: des_xmlNodeSetPtr(n_val, val, 0);
! 48029: xmlResetLastError();
! 48030: if (mem_base != xmlMemBlocks()) {
! 48031: printf("Leak of %d blocks found in xmlXPathNewNodeSetList",
! 48032: xmlMemBlocks() - mem_base);
! 48033: test_ret++;
! 48034: printf(" %d", n_val);
! 48035: printf("\n");
! 48036: }
! 48037: }
! 48038: function_tests++;
! 48039: #endif
! 48040:
! 48041: return(test_ret);
! 48042: }
! 48043:
! 48044:
! 48045: static int
! 48046: test_xmlXPathNewParserContext(void) {
! 48047: int test_ret = 0;
! 48048:
! 48049:
! 48050: /* missing type support */
! 48051: return(test_ret);
! 48052: }
! 48053:
! 48054:
! 48055: static int
! 48056: test_xmlXPathNewString(void) {
! 48057: int test_ret = 0;
! 48058:
! 48059: #if defined(LIBXML_XPATH_ENABLED)
! 48060: int mem_base;
! 48061: xmlXPathObjectPtr ret_val;
! 48062: xmlChar * val; /* the xmlChar * value */
! 48063: int n_val;
! 48064:
! 48065: for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
! 48066: mem_base = xmlMemBlocks();
! 48067: val = gen_const_xmlChar_ptr(n_val, 0);
! 48068:
! 48069: ret_val = xmlXPathNewString((const xmlChar *)val);
! 48070: desret_xmlXPathObjectPtr(ret_val);
! 48071: call_tests++;
! 48072: des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 0);
! 48073: xmlResetLastError();
! 48074: if (mem_base != xmlMemBlocks()) {
! 48075: printf("Leak of %d blocks found in xmlXPathNewString",
! 48076: xmlMemBlocks() - mem_base);
! 48077: test_ret++;
! 48078: printf(" %d", n_val);
! 48079: printf("\n");
! 48080: }
! 48081: }
! 48082: function_tests++;
! 48083: #endif
! 48084:
! 48085: return(test_ret);
! 48086: }
! 48087:
! 48088:
! 48089: static int
! 48090: test_xmlXPathNextAncestor(void) {
! 48091: int test_ret = 0;
! 48092:
! 48093: #if defined(LIBXML_XPATH_ENABLED)
! 48094: int mem_base;
! 48095: xmlNodePtr ret_val;
! 48096: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 48097: int n_ctxt;
! 48098: xmlNodePtr cur; /* the current node in the traversal */
! 48099: int n_cur;
! 48100:
! 48101: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 48102: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 48103: mem_base = xmlMemBlocks();
! 48104: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 48105: cur = gen_xmlNodePtr(n_cur, 1);
! 48106:
! 48107: ret_val = xmlXPathNextAncestor(ctxt, cur);
! 48108: desret_xmlNodePtr(ret_val);
! 48109: call_tests++;
! 48110: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 48111: des_xmlNodePtr(n_cur, cur, 1);
! 48112: xmlResetLastError();
! 48113: if (mem_base != xmlMemBlocks()) {
! 48114: printf("Leak of %d blocks found in xmlXPathNextAncestor",
! 48115: xmlMemBlocks() - mem_base);
! 48116: test_ret++;
! 48117: printf(" %d", n_ctxt);
! 48118: printf(" %d", n_cur);
! 48119: printf("\n");
! 48120: }
! 48121: }
! 48122: }
! 48123: function_tests++;
! 48124: #endif
! 48125:
! 48126: return(test_ret);
! 48127: }
! 48128:
! 48129:
! 48130: static int
! 48131: test_xmlXPathNextAncestorOrSelf(void) {
! 48132: int test_ret = 0;
! 48133:
! 48134: #if defined(LIBXML_XPATH_ENABLED)
! 48135: int mem_base;
! 48136: xmlNodePtr ret_val;
! 48137: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 48138: int n_ctxt;
! 48139: xmlNodePtr cur; /* the current node in the traversal */
! 48140: int n_cur;
! 48141:
! 48142: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 48143: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 48144: mem_base = xmlMemBlocks();
! 48145: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 48146: cur = gen_xmlNodePtr(n_cur, 1);
! 48147:
! 48148: ret_val = xmlXPathNextAncestorOrSelf(ctxt, cur);
! 48149: desret_xmlNodePtr(ret_val);
! 48150: call_tests++;
! 48151: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 48152: des_xmlNodePtr(n_cur, cur, 1);
! 48153: xmlResetLastError();
! 48154: if (mem_base != xmlMemBlocks()) {
! 48155: printf("Leak of %d blocks found in xmlXPathNextAncestorOrSelf",
! 48156: xmlMemBlocks() - mem_base);
! 48157: test_ret++;
! 48158: printf(" %d", n_ctxt);
! 48159: printf(" %d", n_cur);
! 48160: printf("\n");
! 48161: }
! 48162: }
! 48163: }
! 48164: function_tests++;
! 48165: #endif
! 48166:
! 48167: return(test_ret);
! 48168: }
! 48169:
! 48170:
! 48171: static int
! 48172: test_xmlXPathNextAttribute(void) {
! 48173: int test_ret = 0;
! 48174:
! 48175: #if defined(LIBXML_XPATH_ENABLED)
! 48176: int mem_base;
! 48177: xmlNodePtr ret_val;
! 48178: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 48179: int n_ctxt;
! 48180: xmlNodePtr cur; /* the current attribute in the traversal */
! 48181: int n_cur;
! 48182:
! 48183: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 48184: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 48185: mem_base = xmlMemBlocks();
! 48186: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 48187: cur = gen_xmlNodePtr(n_cur, 1);
! 48188:
! 48189: ret_val = xmlXPathNextAttribute(ctxt, cur);
! 48190: desret_xmlNodePtr(ret_val);
! 48191: call_tests++;
! 48192: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 48193: des_xmlNodePtr(n_cur, cur, 1);
! 48194: xmlResetLastError();
! 48195: if (mem_base != xmlMemBlocks()) {
! 48196: printf("Leak of %d blocks found in xmlXPathNextAttribute",
! 48197: xmlMemBlocks() - mem_base);
! 48198: test_ret++;
! 48199: printf(" %d", n_ctxt);
! 48200: printf(" %d", n_cur);
! 48201: printf("\n");
! 48202: }
! 48203: }
! 48204: }
! 48205: function_tests++;
! 48206: #endif
! 48207:
! 48208: return(test_ret);
! 48209: }
! 48210:
! 48211:
! 48212: static int
! 48213: test_xmlXPathNextChild(void) {
! 48214: int test_ret = 0;
! 48215:
! 48216: #if defined(LIBXML_XPATH_ENABLED)
! 48217: int mem_base;
! 48218: xmlNodePtr ret_val;
! 48219: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 48220: int n_ctxt;
! 48221: xmlNodePtr cur; /* the current node in the traversal */
! 48222: int n_cur;
! 48223:
! 48224: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 48225: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 48226: mem_base = xmlMemBlocks();
! 48227: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 48228: cur = gen_xmlNodePtr(n_cur, 1);
! 48229:
! 48230: ret_val = xmlXPathNextChild(ctxt, cur);
! 48231: desret_xmlNodePtr(ret_val);
! 48232: call_tests++;
! 48233: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 48234: des_xmlNodePtr(n_cur, cur, 1);
! 48235: xmlResetLastError();
! 48236: if (mem_base != xmlMemBlocks()) {
! 48237: printf("Leak of %d blocks found in xmlXPathNextChild",
! 48238: xmlMemBlocks() - mem_base);
! 48239: test_ret++;
! 48240: printf(" %d", n_ctxt);
! 48241: printf(" %d", n_cur);
! 48242: printf("\n");
! 48243: }
! 48244: }
! 48245: }
! 48246: function_tests++;
! 48247: #endif
! 48248:
! 48249: return(test_ret);
! 48250: }
! 48251:
! 48252:
! 48253: static int
! 48254: test_xmlXPathNextDescendant(void) {
! 48255: int test_ret = 0;
! 48256:
! 48257: #if defined(LIBXML_XPATH_ENABLED)
! 48258: int mem_base;
! 48259: xmlNodePtr ret_val;
! 48260: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 48261: int n_ctxt;
! 48262: xmlNodePtr cur; /* the current node in the traversal */
! 48263: int n_cur;
! 48264:
! 48265: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 48266: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 48267: mem_base = xmlMemBlocks();
! 48268: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 48269: cur = gen_xmlNodePtr(n_cur, 1);
! 48270:
! 48271: ret_val = xmlXPathNextDescendant(ctxt, cur);
! 48272: desret_xmlNodePtr(ret_val);
! 48273: call_tests++;
! 48274: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 48275: des_xmlNodePtr(n_cur, cur, 1);
! 48276: xmlResetLastError();
! 48277: if (mem_base != xmlMemBlocks()) {
! 48278: printf("Leak of %d blocks found in xmlXPathNextDescendant",
! 48279: xmlMemBlocks() - mem_base);
! 48280: test_ret++;
! 48281: printf(" %d", n_ctxt);
! 48282: printf(" %d", n_cur);
! 48283: printf("\n");
! 48284: }
! 48285: }
! 48286: }
! 48287: function_tests++;
! 48288: #endif
! 48289:
! 48290: return(test_ret);
! 48291: }
! 48292:
! 48293:
! 48294: static int
! 48295: test_xmlXPathNextDescendantOrSelf(void) {
! 48296: int test_ret = 0;
! 48297:
! 48298: #if defined(LIBXML_XPATH_ENABLED)
! 48299: int mem_base;
! 48300: xmlNodePtr ret_val;
! 48301: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 48302: int n_ctxt;
! 48303: xmlNodePtr cur; /* the current node in the traversal */
! 48304: int n_cur;
! 48305:
! 48306: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 48307: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 48308: mem_base = xmlMemBlocks();
! 48309: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 48310: cur = gen_xmlNodePtr(n_cur, 1);
! 48311:
! 48312: ret_val = xmlXPathNextDescendantOrSelf(ctxt, cur);
! 48313: desret_xmlNodePtr(ret_val);
! 48314: call_tests++;
! 48315: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 48316: des_xmlNodePtr(n_cur, cur, 1);
! 48317: xmlResetLastError();
! 48318: if (mem_base != xmlMemBlocks()) {
! 48319: printf("Leak of %d blocks found in xmlXPathNextDescendantOrSelf",
! 48320: xmlMemBlocks() - mem_base);
! 48321: test_ret++;
! 48322: printf(" %d", n_ctxt);
! 48323: printf(" %d", n_cur);
! 48324: printf("\n");
! 48325: }
! 48326: }
! 48327: }
! 48328: function_tests++;
! 48329: #endif
! 48330:
! 48331: return(test_ret);
! 48332: }
! 48333:
! 48334:
! 48335: static int
! 48336: test_xmlXPathNextFollowing(void) {
! 48337: int test_ret = 0;
! 48338:
! 48339: #if defined(LIBXML_XPATH_ENABLED)
! 48340: int mem_base;
! 48341: xmlNodePtr ret_val;
! 48342: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 48343: int n_ctxt;
! 48344: xmlNodePtr cur; /* the current node in the traversal */
! 48345: int n_cur;
! 48346:
! 48347: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 48348: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 48349: mem_base = xmlMemBlocks();
! 48350: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 48351: cur = gen_xmlNodePtr(n_cur, 1);
! 48352:
! 48353: ret_val = xmlXPathNextFollowing(ctxt, cur);
! 48354: desret_xmlNodePtr(ret_val);
! 48355: call_tests++;
! 48356: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 48357: des_xmlNodePtr(n_cur, cur, 1);
! 48358: xmlResetLastError();
! 48359: if (mem_base != xmlMemBlocks()) {
! 48360: printf("Leak of %d blocks found in xmlXPathNextFollowing",
! 48361: xmlMemBlocks() - mem_base);
! 48362: test_ret++;
! 48363: printf(" %d", n_ctxt);
! 48364: printf(" %d", n_cur);
! 48365: printf("\n");
! 48366: }
! 48367: }
! 48368: }
! 48369: function_tests++;
! 48370: #endif
! 48371:
! 48372: return(test_ret);
! 48373: }
! 48374:
! 48375:
! 48376: static int
! 48377: test_xmlXPathNextFollowingSibling(void) {
! 48378: int test_ret = 0;
! 48379:
! 48380: #if defined(LIBXML_XPATH_ENABLED)
! 48381: int mem_base;
! 48382: xmlNodePtr ret_val;
! 48383: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 48384: int n_ctxt;
! 48385: xmlNodePtr cur; /* the current node in the traversal */
! 48386: int n_cur;
! 48387:
! 48388: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 48389: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 48390: mem_base = xmlMemBlocks();
! 48391: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 48392: cur = gen_xmlNodePtr(n_cur, 1);
! 48393:
! 48394: ret_val = xmlXPathNextFollowingSibling(ctxt, cur);
! 48395: desret_xmlNodePtr(ret_val);
! 48396: call_tests++;
! 48397: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 48398: des_xmlNodePtr(n_cur, cur, 1);
! 48399: xmlResetLastError();
! 48400: if (mem_base != xmlMemBlocks()) {
! 48401: printf("Leak of %d blocks found in xmlXPathNextFollowingSibling",
! 48402: xmlMemBlocks() - mem_base);
! 48403: test_ret++;
! 48404: printf(" %d", n_ctxt);
! 48405: printf(" %d", n_cur);
! 48406: printf("\n");
! 48407: }
! 48408: }
! 48409: }
! 48410: function_tests++;
! 48411: #endif
! 48412:
! 48413: return(test_ret);
! 48414: }
! 48415:
! 48416:
! 48417: static int
! 48418: test_xmlXPathNextNamespace(void) {
! 48419: int test_ret = 0;
! 48420:
! 48421: #if defined(LIBXML_XPATH_ENABLED)
! 48422: int mem_base;
! 48423: xmlNodePtr ret_val;
! 48424: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 48425: int n_ctxt;
! 48426: xmlNodePtr cur; /* the current attribute in the traversal */
! 48427: int n_cur;
! 48428:
! 48429: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 48430: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 48431: mem_base = xmlMemBlocks();
! 48432: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 48433: cur = gen_xmlNodePtr(n_cur, 1);
! 48434:
! 48435: ret_val = xmlXPathNextNamespace(ctxt, cur);
! 48436: desret_xmlNodePtr(ret_val);
! 48437: call_tests++;
! 48438: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 48439: des_xmlNodePtr(n_cur, cur, 1);
! 48440: xmlResetLastError();
! 48441: if (mem_base != xmlMemBlocks()) {
! 48442: printf("Leak of %d blocks found in xmlXPathNextNamespace",
! 48443: xmlMemBlocks() - mem_base);
! 48444: test_ret++;
! 48445: printf(" %d", n_ctxt);
! 48446: printf(" %d", n_cur);
! 48447: printf("\n");
! 48448: }
! 48449: }
! 48450: }
! 48451: function_tests++;
! 48452: #endif
! 48453:
! 48454: return(test_ret);
! 48455: }
! 48456:
! 48457:
! 48458: static int
! 48459: test_xmlXPathNextParent(void) {
! 48460: int test_ret = 0;
! 48461:
! 48462: #if defined(LIBXML_XPATH_ENABLED)
! 48463: int mem_base;
! 48464: xmlNodePtr ret_val;
! 48465: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 48466: int n_ctxt;
! 48467: xmlNodePtr cur; /* the current node in the traversal */
! 48468: int n_cur;
! 48469:
! 48470: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 48471: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 48472: mem_base = xmlMemBlocks();
! 48473: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 48474: cur = gen_xmlNodePtr(n_cur, 1);
! 48475:
! 48476: ret_val = xmlXPathNextParent(ctxt, cur);
! 48477: desret_xmlNodePtr(ret_val);
! 48478: call_tests++;
! 48479: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 48480: des_xmlNodePtr(n_cur, cur, 1);
! 48481: xmlResetLastError();
! 48482: if (mem_base != xmlMemBlocks()) {
! 48483: printf("Leak of %d blocks found in xmlXPathNextParent",
! 48484: xmlMemBlocks() - mem_base);
! 48485: test_ret++;
! 48486: printf(" %d", n_ctxt);
! 48487: printf(" %d", n_cur);
! 48488: printf("\n");
! 48489: }
! 48490: }
! 48491: }
! 48492: function_tests++;
! 48493: #endif
! 48494:
! 48495: return(test_ret);
! 48496: }
! 48497:
! 48498:
! 48499: static int
! 48500: test_xmlXPathNextPreceding(void) {
! 48501: int test_ret = 0;
! 48502:
! 48503: #if defined(LIBXML_XPATH_ENABLED)
! 48504: int mem_base;
! 48505: xmlNodePtr ret_val;
! 48506: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 48507: int n_ctxt;
! 48508: xmlNodePtr cur; /* the current node in the traversal */
! 48509: int n_cur;
! 48510:
! 48511: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 48512: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 48513: mem_base = xmlMemBlocks();
! 48514: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 48515: cur = gen_xmlNodePtr(n_cur, 1);
! 48516:
! 48517: ret_val = xmlXPathNextPreceding(ctxt, cur);
! 48518: desret_xmlNodePtr(ret_val);
! 48519: call_tests++;
! 48520: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 48521: des_xmlNodePtr(n_cur, cur, 1);
! 48522: xmlResetLastError();
! 48523: if (mem_base != xmlMemBlocks()) {
! 48524: printf("Leak of %d blocks found in xmlXPathNextPreceding",
! 48525: xmlMemBlocks() - mem_base);
! 48526: test_ret++;
! 48527: printf(" %d", n_ctxt);
! 48528: printf(" %d", n_cur);
! 48529: printf("\n");
! 48530: }
! 48531: }
! 48532: }
! 48533: function_tests++;
! 48534: #endif
! 48535:
! 48536: return(test_ret);
! 48537: }
! 48538:
! 48539:
! 48540: static int
! 48541: test_xmlXPathNextPrecedingSibling(void) {
! 48542: int test_ret = 0;
! 48543:
! 48544: #if defined(LIBXML_XPATH_ENABLED)
! 48545: int mem_base;
! 48546: xmlNodePtr ret_val;
! 48547: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 48548: int n_ctxt;
! 48549: xmlNodePtr cur; /* the current node in the traversal */
! 48550: int n_cur;
! 48551:
! 48552: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 48553: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 48554: mem_base = xmlMemBlocks();
! 48555: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 48556: cur = gen_xmlNodePtr(n_cur, 1);
! 48557:
! 48558: ret_val = xmlXPathNextPrecedingSibling(ctxt, cur);
! 48559: desret_xmlNodePtr(ret_val);
! 48560: call_tests++;
! 48561: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 48562: des_xmlNodePtr(n_cur, cur, 1);
! 48563: xmlResetLastError();
! 48564: if (mem_base != xmlMemBlocks()) {
! 48565: printf("Leak of %d blocks found in xmlXPathNextPrecedingSibling",
! 48566: xmlMemBlocks() - mem_base);
! 48567: test_ret++;
! 48568: printf(" %d", n_ctxt);
! 48569: printf(" %d", n_cur);
! 48570: printf("\n");
! 48571: }
! 48572: }
! 48573: }
! 48574: function_tests++;
! 48575: #endif
! 48576:
! 48577: return(test_ret);
! 48578: }
! 48579:
! 48580:
! 48581: static int
! 48582: test_xmlXPathNextSelf(void) {
! 48583: int test_ret = 0;
! 48584:
! 48585: #if defined(LIBXML_XPATH_ENABLED)
! 48586: int mem_base;
! 48587: xmlNodePtr ret_val;
! 48588: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 48589: int n_ctxt;
! 48590: xmlNodePtr cur; /* the current node in the traversal */
! 48591: int n_cur;
! 48592:
! 48593: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 48594: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 48595: mem_base = xmlMemBlocks();
! 48596: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 48597: cur = gen_xmlNodePtr(n_cur, 1);
! 48598:
! 48599: ret_val = xmlXPathNextSelf(ctxt, cur);
! 48600: desret_xmlNodePtr(ret_val);
! 48601: call_tests++;
! 48602: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 48603: des_xmlNodePtr(n_cur, cur, 1);
! 48604: xmlResetLastError();
! 48605: if (mem_base != xmlMemBlocks()) {
! 48606: printf("Leak of %d blocks found in xmlXPathNextSelf",
! 48607: xmlMemBlocks() - mem_base);
! 48608: test_ret++;
! 48609: printf(" %d", n_ctxt);
! 48610: printf(" %d", n_cur);
! 48611: printf("\n");
! 48612: }
! 48613: }
! 48614: }
! 48615: function_tests++;
! 48616: #endif
! 48617:
! 48618: return(test_ret);
! 48619: }
! 48620:
! 48621:
! 48622: static int
! 48623: test_xmlXPathNodeLeading(void) {
! 48624: int test_ret = 0;
! 48625:
! 48626: #if defined(LIBXML_XPATH_ENABLED)
! 48627: int mem_base;
! 48628: xmlNodeSetPtr ret_val;
! 48629: xmlNodeSetPtr nodes; /* a node-set */
! 48630: int n_nodes;
! 48631: xmlNodePtr node; /* a node */
! 48632: int n_node;
! 48633:
! 48634: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
! 48635: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 48636: mem_base = xmlMemBlocks();
! 48637: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
! 48638: node = gen_xmlNodePtr(n_node, 1);
! 48639:
! 48640: ret_val = xmlXPathNodeLeading(nodes, node);
! 48641: desret_xmlNodeSetPtr(ret_val);
! 48642: call_tests++;
! 48643: des_xmlNodeSetPtr(n_nodes, nodes, 0);
! 48644: des_xmlNodePtr(n_node, node, 1);
! 48645: xmlResetLastError();
! 48646: if (mem_base != xmlMemBlocks()) {
! 48647: printf("Leak of %d blocks found in xmlXPathNodeLeading",
! 48648: xmlMemBlocks() - mem_base);
! 48649: test_ret++;
! 48650: printf(" %d", n_nodes);
! 48651: printf(" %d", n_node);
! 48652: printf("\n");
! 48653: }
! 48654: }
! 48655: }
! 48656: function_tests++;
! 48657: #endif
! 48658:
! 48659: return(test_ret);
! 48660: }
! 48661:
! 48662:
! 48663: static int
! 48664: test_xmlXPathNodeLeadingSorted(void) {
! 48665: int test_ret = 0;
! 48666:
! 48667: #if defined(LIBXML_XPATH_ENABLED)
! 48668: int mem_base;
! 48669: xmlNodeSetPtr ret_val;
! 48670: xmlNodeSetPtr nodes; /* a node-set, sorted by document order */
! 48671: int n_nodes;
! 48672: xmlNodePtr node; /* a node */
! 48673: int n_node;
! 48674:
! 48675: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
! 48676: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 48677: mem_base = xmlMemBlocks();
! 48678: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
! 48679: node = gen_xmlNodePtr(n_node, 1);
! 48680:
! 48681: ret_val = xmlXPathNodeLeadingSorted(nodes, node);
! 48682: desret_xmlNodeSetPtr(ret_val);
! 48683: call_tests++;
! 48684: des_xmlNodeSetPtr(n_nodes, nodes, 0);
! 48685: des_xmlNodePtr(n_node, node, 1);
! 48686: xmlResetLastError();
! 48687: if (mem_base != xmlMemBlocks()) {
! 48688: printf("Leak of %d blocks found in xmlXPathNodeLeadingSorted",
! 48689: xmlMemBlocks() - mem_base);
! 48690: test_ret++;
! 48691: printf(" %d", n_nodes);
! 48692: printf(" %d", n_node);
! 48693: printf("\n");
! 48694: }
! 48695: }
! 48696: }
! 48697: function_tests++;
! 48698: #endif
! 48699:
! 48700: return(test_ret);
! 48701: }
! 48702:
! 48703:
! 48704: static int
! 48705: test_xmlXPathNodeSetAdd(void) {
! 48706: int test_ret = 0;
! 48707:
! 48708: #if defined(LIBXML_XPATH_ENABLED)
! 48709: int mem_base;
! 48710: xmlNodeSetPtr cur; /* the initial node set */
! 48711: int n_cur;
! 48712: xmlNodePtr val; /* a new xmlNodePtr */
! 48713: int n_val;
! 48714:
! 48715: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
! 48716: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
! 48717: mem_base = xmlMemBlocks();
! 48718: cur = gen_xmlNodeSetPtr(n_cur, 0);
! 48719: val = gen_xmlNodePtr(n_val, 1);
! 48720:
! 48721: xmlXPathNodeSetAdd(cur, val);
! 48722: call_tests++;
! 48723: des_xmlNodeSetPtr(n_cur, cur, 0);
! 48724: des_xmlNodePtr(n_val, val, 1);
! 48725: xmlResetLastError();
! 48726: if (mem_base != xmlMemBlocks()) {
! 48727: printf("Leak of %d blocks found in xmlXPathNodeSetAdd",
! 48728: xmlMemBlocks() - mem_base);
! 48729: test_ret++;
! 48730: printf(" %d", n_cur);
! 48731: printf(" %d", n_val);
! 48732: printf("\n");
! 48733: }
! 48734: }
! 48735: }
! 48736: function_tests++;
! 48737: #endif
! 48738:
! 48739: return(test_ret);
! 48740: }
! 48741:
! 48742:
! 48743: static int
! 48744: test_xmlXPathNodeSetAddNs(void) {
! 48745: int test_ret = 0;
! 48746:
! 48747: #if defined(LIBXML_XPATH_ENABLED)
! 48748: int mem_base;
! 48749: xmlNodeSetPtr cur; /* the initial node set */
! 48750: int n_cur;
! 48751: xmlNodePtr node; /* the hosting node */
! 48752: int n_node;
! 48753: xmlNsPtr ns; /* a the namespace node */
! 48754: int n_ns;
! 48755:
! 48756: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
! 48757: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 48758: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
! 48759: mem_base = xmlMemBlocks();
! 48760: cur = gen_xmlNodeSetPtr(n_cur, 0);
! 48761: node = gen_xmlNodePtr(n_node, 1);
! 48762: ns = gen_xmlNsPtr(n_ns, 2);
! 48763:
! 48764: xmlXPathNodeSetAddNs(cur, node, ns);
! 48765: call_tests++;
! 48766: des_xmlNodeSetPtr(n_cur, cur, 0);
! 48767: des_xmlNodePtr(n_node, node, 1);
! 48768: des_xmlNsPtr(n_ns, ns, 2);
! 48769: xmlResetLastError();
! 48770: if (mem_base != xmlMemBlocks()) {
! 48771: printf("Leak of %d blocks found in xmlXPathNodeSetAddNs",
! 48772: xmlMemBlocks() - mem_base);
! 48773: test_ret++;
! 48774: printf(" %d", n_cur);
! 48775: printf(" %d", n_node);
! 48776: printf(" %d", n_ns);
! 48777: printf("\n");
! 48778: }
! 48779: }
! 48780: }
! 48781: }
! 48782: function_tests++;
! 48783: #endif
! 48784:
! 48785: return(test_ret);
! 48786: }
! 48787:
! 48788:
! 48789: static int
! 48790: test_xmlXPathNodeSetAddUnique(void) {
! 48791: int test_ret = 0;
! 48792:
! 48793: #if defined(LIBXML_XPATH_ENABLED)
! 48794: int mem_base;
! 48795: xmlNodeSetPtr cur; /* the initial node set */
! 48796: int n_cur;
! 48797: xmlNodePtr val; /* a new xmlNodePtr */
! 48798: int n_val;
! 48799:
! 48800: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
! 48801: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
! 48802: mem_base = xmlMemBlocks();
! 48803: cur = gen_xmlNodeSetPtr(n_cur, 0);
! 48804: val = gen_xmlNodePtr(n_val, 1);
! 48805:
! 48806: xmlXPathNodeSetAddUnique(cur, val);
! 48807: call_tests++;
! 48808: des_xmlNodeSetPtr(n_cur, cur, 0);
! 48809: des_xmlNodePtr(n_val, val, 1);
! 48810: xmlResetLastError();
! 48811: if (mem_base != xmlMemBlocks()) {
! 48812: printf("Leak of %d blocks found in xmlXPathNodeSetAddUnique",
! 48813: xmlMemBlocks() - mem_base);
! 48814: test_ret++;
! 48815: printf(" %d", n_cur);
! 48816: printf(" %d", n_val);
! 48817: printf("\n");
! 48818: }
! 48819: }
! 48820: }
! 48821: function_tests++;
! 48822: #endif
! 48823:
! 48824: return(test_ret);
! 48825: }
! 48826:
! 48827:
! 48828: static int
! 48829: test_xmlXPathNodeSetContains(void) {
! 48830: int test_ret = 0;
! 48831:
! 48832: #if defined(LIBXML_XPATH_ENABLED)
! 48833: int mem_base;
! 48834: int ret_val;
! 48835: xmlNodeSetPtr cur; /* the node-set */
! 48836: int n_cur;
! 48837: xmlNodePtr val; /* the node */
! 48838: int n_val;
! 48839:
! 48840: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
! 48841: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
! 48842: mem_base = xmlMemBlocks();
! 48843: cur = gen_xmlNodeSetPtr(n_cur, 0);
! 48844: val = gen_xmlNodePtr(n_val, 1);
! 48845:
! 48846: ret_val = xmlXPathNodeSetContains(cur, val);
! 48847: desret_int(ret_val);
! 48848: call_tests++;
! 48849: des_xmlNodeSetPtr(n_cur, cur, 0);
! 48850: des_xmlNodePtr(n_val, val, 1);
! 48851: xmlResetLastError();
! 48852: if (mem_base != xmlMemBlocks()) {
! 48853: printf("Leak of %d blocks found in xmlXPathNodeSetContains",
! 48854: xmlMemBlocks() - mem_base);
! 48855: test_ret++;
! 48856: printf(" %d", n_cur);
! 48857: printf(" %d", n_val);
! 48858: printf("\n");
! 48859: }
! 48860: }
! 48861: }
! 48862: function_tests++;
! 48863: #endif
! 48864:
! 48865: return(test_ret);
! 48866: }
! 48867:
! 48868:
! 48869: static int
! 48870: test_xmlXPathNodeSetDel(void) {
! 48871: int test_ret = 0;
! 48872:
! 48873: #if defined(LIBXML_XPATH_ENABLED)
! 48874: int mem_base;
! 48875: xmlNodeSetPtr cur; /* the initial node set */
! 48876: int n_cur;
! 48877: xmlNodePtr val; /* an xmlNodePtr */
! 48878: int n_val;
! 48879:
! 48880: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
! 48881: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
! 48882: mem_base = xmlMemBlocks();
! 48883: cur = gen_xmlNodeSetPtr(n_cur, 0);
! 48884: val = gen_xmlNodePtr(n_val, 1);
! 48885:
! 48886: xmlXPathNodeSetDel(cur, val);
! 48887: call_tests++;
! 48888: des_xmlNodeSetPtr(n_cur, cur, 0);
! 48889: des_xmlNodePtr(n_val, val, 1);
! 48890: xmlResetLastError();
! 48891: if (mem_base != xmlMemBlocks()) {
! 48892: printf("Leak of %d blocks found in xmlXPathNodeSetDel",
! 48893: xmlMemBlocks() - mem_base);
! 48894: test_ret++;
! 48895: printf(" %d", n_cur);
! 48896: printf(" %d", n_val);
! 48897: printf("\n");
! 48898: }
! 48899: }
! 48900: }
! 48901: function_tests++;
! 48902: #endif
! 48903:
! 48904: return(test_ret);
! 48905: }
! 48906:
! 48907:
! 48908: static int
! 48909: test_xmlXPathNodeSetMerge(void) {
! 48910: int test_ret = 0;
! 48911:
! 48912: #if defined(LIBXML_XPATH_ENABLED)
! 48913: int mem_base;
! 48914: xmlNodeSetPtr ret_val;
! 48915: xmlNodeSetPtr val1; /* the first NodeSet or NULL */
! 48916: int n_val1;
! 48917: xmlNodeSetPtr val2; /* the second NodeSet */
! 48918: int n_val2;
! 48919:
! 48920: for (n_val1 = 0;n_val1 < gen_nb_xmlNodeSetPtr;n_val1++) {
! 48921: for (n_val2 = 0;n_val2 < gen_nb_xmlNodeSetPtr;n_val2++) {
! 48922: mem_base = xmlMemBlocks();
! 48923: val1 = gen_xmlNodeSetPtr(n_val1, 0);
! 48924: val2 = gen_xmlNodeSetPtr(n_val2, 1);
! 48925:
! 48926: ret_val = xmlXPathNodeSetMerge(val1, val2);
! 48927: desret_xmlNodeSetPtr(ret_val);
! 48928: call_tests++;
! 48929: des_xmlNodeSetPtr(n_val1, val1, 0);
! 48930: des_xmlNodeSetPtr(n_val2, val2, 1);
! 48931: xmlResetLastError();
! 48932: if (mem_base != xmlMemBlocks()) {
! 48933: printf("Leak of %d blocks found in xmlXPathNodeSetMerge",
! 48934: xmlMemBlocks() - mem_base);
! 48935: test_ret++;
! 48936: printf(" %d", n_val1);
! 48937: printf(" %d", n_val2);
! 48938: printf("\n");
! 48939: }
! 48940: }
! 48941: }
! 48942: function_tests++;
! 48943: #endif
! 48944:
! 48945: return(test_ret);
! 48946: }
! 48947:
! 48948:
! 48949: static int
! 48950: test_xmlXPathNodeSetRemove(void) {
! 48951: int test_ret = 0;
! 48952:
! 48953: #if defined(LIBXML_XPATH_ENABLED)
! 48954: int mem_base;
! 48955: xmlNodeSetPtr cur; /* the initial node set */
! 48956: int n_cur;
! 48957: int val; /* the index to remove */
! 48958: int n_val;
! 48959:
! 48960: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
! 48961: for (n_val = 0;n_val < gen_nb_int;n_val++) {
! 48962: mem_base = xmlMemBlocks();
! 48963: cur = gen_xmlNodeSetPtr(n_cur, 0);
! 48964: val = gen_int(n_val, 1);
! 48965:
! 48966: xmlXPathNodeSetRemove(cur, val);
! 48967: call_tests++;
! 48968: des_xmlNodeSetPtr(n_cur, cur, 0);
! 48969: des_int(n_val, val, 1);
! 48970: xmlResetLastError();
! 48971: if (mem_base != xmlMemBlocks()) {
! 48972: printf("Leak of %d blocks found in xmlXPathNodeSetRemove",
! 48973: xmlMemBlocks() - mem_base);
! 48974: test_ret++;
! 48975: printf(" %d", n_cur);
! 48976: printf(" %d", n_val);
! 48977: printf("\n");
! 48978: }
! 48979: }
! 48980: }
! 48981: function_tests++;
! 48982: #endif
! 48983:
! 48984: return(test_ret);
! 48985: }
! 48986:
! 48987:
! 48988: static int
! 48989: test_xmlXPathNodeSetSort(void) {
! 48990: int test_ret = 0;
! 48991:
! 48992: #if defined(LIBXML_XPATH_ENABLED)
! 48993: int mem_base;
! 48994: xmlNodeSetPtr set; /* the node set */
! 48995: int n_set;
! 48996:
! 48997: for (n_set = 0;n_set < gen_nb_xmlNodeSetPtr;n_set++) {
! 48998: mem_base = xmlMemBlocks();
! 48999: set = gen_xmlNodeSetPtr(n_set, 0);
! 49000:
! 49001: xmlXPathNodeSetSort(set);
! 49002: call_tests++;
! 49003: des_xmlNodeSetPtr(n_set, set, 0);
! 49004: xmlResetLastError();
! 49005: if (mem_base != xmlMemBlocks()) {
! 49006: printf("Leak of %d blocks found in xmlXPathNodeSetSort",
! 49007: xmlMemBlocks() - mem_base);
! 49008: test_ret++;
! 49009: printf(" %d", n_set);
! 49010: printf("\n");
! 49011: }
! 49012: }
! 49013: function_tests++;
! 49014: #endif
! 49015:
! 49016: return(test_ret);
! 49017: }
! 49018:
! 49019:
! 49020: static int
! 49021: test_xmlXPathNodeTrailing(void) {
! 49022: int test_ret = 0;
! 49023:
! 49024: #if defined(LIBXML_XPATH_ENABLED)
! 49025: int mem_base;
! 49026: xmlNodeSetPtr ret_val;
! 49027: xmlNodeSetPtr nodes; /* a node-set */
! 49028: int n_nodes;
! 49029: xmlNodePtr node; /* a node */
! 49030: int n_node;
! 49031:
! 49032: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
! 49033: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 49034: mem_base = xmlMemBlocks();
! 49035: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
! 49036: node = gen_xmlNodePtr(n_node, 1);
! 49037:
! 49038: ret_val = xmlXPathNodeTrailing(nodes, node);
! 49039: desret_xmlNodeSetPtr(ret_val);
! 49040: call_tests++;
! 49041: des_xmlNodeSetPtr(n_nodes, nodes, 0);
! 49042: des_xmlNodePtr(n_node, node, 1);
! 49043: xmlResetLastError();
! 49044: if (mem_base != xmlMemBlocks()) {
! 49045: printf("Leak of %d blocks found in xmlXPathNodeTrailing",
! 49046: xmlMemBlocks() - mem_base);
! 49047: test_ret++;
! 49048: printf(" %d", n_nodes);
! 49049: printf(" %d", n_node);
! 49050: printf("\n");
! 49051: }
! 49052: }
! 49053: }
! 49054: function_tests++;
! 49055: #endif
! 49056:
! 49057: return(test_ret);
! 49058: }
! 49059:
! 49060:
! 49061: static int
! 49062: test_xmlXPathNodeTrailingSorted(void) {
! 49063: int test_ret = 0;
! 49064:
! 49065: #if defined(LIBXML_XPATH_ENABLED)
! 49066: int mem_base;
! 49067: xmlNodeSetPtr ret_val;
! 49068: xmlNodeSetPtr nodes; /* a node-set, sorted by document order */
! 49069: int n_nodes;
! 49070: xmlNodePtr node; /* a node */
! 49071: int n_node;
! 49072:
! 49073: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
! 49074: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 49075: mem_base = xmlMemBlocks();
! 49076: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
! 49077: node = gen_xmlNodePtr(n_node, 1);
! 49078:
! 49079: ret_val = xmlXPathNodeTrailingSorted(nodes, node);
! 49080: desret_xmlNodeSetPtr(ret_val);
! 49081: call_tests++;
! 49082: des_xmlNodeSetPtr(n_nodes, nodes, 0);
! 49083: des_xmlNodePtr(n_node, node, 1);
! 49084: xmlResetLastError();
! 49085: if (mem_base != xmlMemBlocks()) {
! 49086: printf("Leak of %d blocks found in xmlXPathNodeTrailingSorted",
! 49087: xmlMemBlocks() - mem_base);
! 49088: test_ret++;
! 49089: printf(" %d", n_nodes);
! 49090: printf(" %d", n_node);
! 49091: printf("\n");
! 49092: }
! 49093: }
! 49094: }
! 49095: function_tests++;
! 49096: #endif
! 49097:
! 49098: return(test_ret);
! 49099: }
! 49100:
! 49101:
! 49102: static int
! 49103: test_xmlXPathNormalizeFunction(void) {
! 49104: int test_ret = 0;
! 49105:
! 49106: #if defined(LIBXML_XPATH_ENABLED)
! 49107: int mem_base;
! 49108: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 49109: int n_ctxt;
! 49110: int nargs; /* the number of arguments */
! 49111: int n_nargs;
! 49112:
! 49113: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 49114: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 49115: mem_base = xmlMemBlocks();
! 49116: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 49117: nargs = gen_int(n_nargs, 1);
! 49118:
! 49119: xmlXPathNormalizeFunction(ctxt, nargs);
! 49120: call_tests++;
! 49121: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 49122: des_int(n_nargs, nargs, 1);
! 49123: xmlResetLastError();
! 49124: if (mem_base != xmlMemBlocks()) {
! 49125: printf("Leak of %d blocks found in xmlXPathNormalizeFunction",
! 49126: xmlMemBlocks() - mem_base);
! 49127: test_ret++;
! 49128: printf(" %d", n_ctxt);
! 49129: printf(" %d", n_nargs);
! 49130: printf("\n");
! 49131: }
! 49132: }
! 49133: }
! 49134: function_tests++;
! 49135: #endif
! 49136:
! 49137: return(test_ret);
! 49138: }
! 49139:
! 49140:
! 49141: static int
! 49142: test_xmlXPathNotEqualValues(void) {
! 49143: int test_ret = 0;
! 49144:
! 49145: #if defined(LIBXML_XPATH_ENABLED)
! 49146: int mem_base;
! 49147: int ret_val;
! 49148: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 49149: int n_ctxt;
! 49150:
! 49151: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 49152: mem_base = xmlMemBlocks();
! 49153: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 49154:
! 49155: ret_val = xmlXPathNotEqualValues(ctxt);
! 49156: desret_int(ret_val);
! 49157: call_tests++;
! 49158: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 49159: xmlResetLastError();
! 49160: if (mem_base != xmlMemBlocks()) {
! 49161: printf("Leak of %d blocks found in xmlXPathNotEqualValues",
! 49162: xmlMemBlocks() - mem_base);
! 49163: test_ret++;
! 49164: printf(" %d", n_ctxt);
! 49165: printf("\n");
! 49166: }
! 49167: }
! 49168: function_tests++;
! 49169: #endif
! 49170:
! 49171: return(test_ret);
! 49172: }
! 49173:
! 49174:
! 49175: static int
! 49176: test_xmlXPathNotFunction(void) {
! 49177: int test_ret = 0;
! 49178:
! 49179: #if defined(LIBXML_XPATH_ENABLED)
! 49180: int mem_base;
! 49181: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 49182: int n_ctxt;
! 49183: int nargs; /* the number of arguments */
! 49184: int n_nargs;
! 49185:
! 49186: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 49187: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 49188: mem_base = xmlMemBlocks();
! 49189: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 49190: nargs = gen_int(n_nargs, 1);
! 49191:
! 49192: xmlXPathNotFunction(ctxt, nargs);
! 49193: call_tests++;
! 49194: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 49195: des_int(n_nargs, nargs, 1);
! 49196: xmlResetLastError();
! 49197: if (mem_base != xmlMemBlocks()) {
! 49198: printf("Leak of %d blocks found in xmlXPathNotFunction",
! 49199: xmlMemBlocks() - mem_base);
! 49200: test_ret++;
! 49201: printf(" %d", n_ctxt);
! 49202: printf(" %d", n_nargs);
! 49203: printf("\n");
! 49204: }
! 49205: }
! 49206: }
! 49207: function_tests++;
! 49208: #endif
! 49209:
! 49210: return(test_ret);
! 49211: }
! 49212:
! 49213:
! 49214: static int
! 49215: test_xmlXPathNsLookup(void) {
! 49216: int test_ret = 0;
! 49217:
! 49218: #if defined(LIBXML_XPATH_ENABLED)
! 49219: int mem_base;
! 49220: const xmlChar * ret_val;
! 49221: xmlXPathContextPtr ctxt; /* the XPath context */
! 49222: int n_ctxt;
! 49223: xmlChar * prefix; /* the namespace prefix value */
! 49224: int n_prefix;
! 49225:
! 49226: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
! 49227: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
! 49228: mem_base = xmlMemBlocks();
! 49229: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
! 49230: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
! 49231:
! 49232: ret_val = xmlXPathNsLookup(ctxt, (const xmlChar *)prefix);
! 49233: desret_const_xmlChar_ptr(ret_val);
! 49234: call_tests++;
! 49235: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
! 49236: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
! 49237: xmlResetLastError();
! 49238: if (mem_base != xmlMemBlocks()) {
! 49239: printf("Leak of %d blocks found in xmlXPathNsLookup",
! 49240: xmlMemBlocks() - mem_base);
! 49241: test_ret++;
! 49242: printf(" %d", n_ctxt);
! 49243: printf(" %d", n_prefix);
! 49244: printf("\n");
! 49245: }
! 49246: }
! 49247: }
! 49248: function_tests++;
! 49249: #endif
! 49250:
! 49251: return(test_ret);
! 49252: }
! 49253:
! 49254:
! 49255: static int
! 49256: test_xmlXPathNumberFunction(void) {
! 49257: int test_ret = 0;
! 49258:
! 49259: #if defined(LIBXML_XPATH_ENABLED)
! 49260: int mem_base;
! 49261: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 49262: int n_ctxt;
! 49263: int nargs; /* the number of arguments */
! 49264: int n_nargs;
! 49265:
! 49266: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 49267: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 49268: mem_base = xmlMemBlocks();
! 49269: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 49270: nargs = gen_int(n_nargs, 1);
! 49271:
! 49272: xmlXPathNumberFunction(ctxt, nargs);
! 49273: call_tests++;
! 49274: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 49275: des_int(n_nargs, nargs, 1);
! 49276: xmlResetLastError();
! 49277: if (mem_base != xmlMemBlocks()) {
! 49278: printf("Leak of %d blocks found in xmlXPathNumberFunction",
! 49279: xmlMemBlocks() - mem_base);
! 49280: test_ret++;
! 49281: printf(" %d", n_ctxt);
! 49282: printf(" %d", n_nargs);
! 49283: printf("\n");
! 49284: }
! 49285: }
! 49286: }
! 49287: function_tests++;
! 49288: #endif
! 49289:
! 49290: return(test_ret);
! 49291: }
! 49292:
! 49293:
! 49294: static int
! 49295: test_xmlXPathParseNCName(void) {
! 49296: int test_ret = 0;
! 49297:
! 49298: #if defined(LIBXML_XPATH_ENABLED)
! 49299: int mem_base;
! 49300: xmlChar * ret_val;
! 49301: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 49302: int n_ctxt;
! 49303:
! 49304: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 49305: mem_base = xmlMemBlocks();
! 49306: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 49307:
! 49308: ret_val = xmlXPathParseNCName(ctxt);
! 49309: desret_xmlChar_ptr(ret_val);
! 49310: call_tests++;
! 49311: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 49312: xmlResetLastError();
! 49313: if (mem_base != xmlMemBlocks()) {
! 49314: printf("Leak of %d blocks found in xmlXPathParseNCName",
! 49315: xmlMemBlocks() - mem_base);
! 49316: test_ret++;
! 49317: printf(" %d", n_ctxt);
! 49318: printf("\n");
! 49319: }
! 49320: }
! 49321: function_tests++;
! 49322: #endif
! 49323:
! 49324: return(test_ret);
! 49325: }
! 49326:
! 49327:
! 49328: static int
! 49329: test_xmlXPathParseName(void) {
! 49330: int test_ret = 0;
! 49331:
! 49332: #if defined(LIBXML_XPATH_ENABLED)
! 49333: int mem_base;
! 49334: xmlChar * ret_val;
! 49335: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 49336: int n_ctxt;
! 49337:
! 49338: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 49339: mem_base = xmlMemBlocks();
! 49340: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 49341:
! 49342: ret_val = xmlXPathParseName(ctxt);
! 49343: desret_xmlChar_ptr(ret_val);
! 49344: call_tests++;
! 49345: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 49346: xmlResetLastError();
! 49347: if (mem_base != xmlMemBlocks()) {
! 49348: printf("Leak of %d blocks found in xmlXPathParseName",
! 49349: xmlMemBlocks() - mem_base);
! 49350: test_ret++;
! 49351: printf(" %d", n_ctxt);
! 49352: printf("\n");
! 49353: }
! 49354: }
! 49355: function_tests++;
! 49356: #endif
! 49357:
! 49358: return(test_ret);
! 49359: }
! 49360:
! 49361:
! 49362: static int
! 49363: test_xmlXPathPopBoolean(void) {
! 49364: int test_ret = 0;
! 49365:
! 49366: #if defined(LIBXML_XPATH_ENABLED)
! 49367: int mem_base;
! 49368: int ret_val;
! 49369: xmlXPathParserContextPtr ctxt; /* an XPath parser context */
! 49370: int n_ctxt;
! 49371:
! 49372: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 49373: mem_base = xmlMemBlocks();
! 49374: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 49375:
! 49376: ret_val = xmlXPathPopBoolean(ctxt);
! 49377: desret_int(ret_val);
! 49378: call_tests++;
! 49379: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 49380: xmlResetLastError();
! 49381: if (mem_base != xmlMemBlocks()) {
! 49382: printf("Leak of %d blocks found in xmlXPathPopBoolean",
! 49383: xmlMemBlocks() - mem_base);
! 49384: test_ret++;
! 49385: printf(" %d", n_ctxt);
! 49386: printf("\n");
! 49387: }
! 49388: }
! 49389: function_tests++;
! 49390: #endif
! 49391:
! 49392: return(test_ret);
! 49393: }
! 49394:
! 49395:
! 49396: static int
! 49397: test_xmlXPathPopExternal(void) {
! 49398: int test_ret = 0;
! 49399:
! 49400: #if defined(LIBXML_XPATH_ENABLED)
! 49401: int mem_base;
! 49402: void * ret_val;
! 49403: xmlXPathParserContextPtr ctxt; /* an XPath parser context */
! 49404: int n_ctxt;
! 49405:
! 49406: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 49407: mem_base = xmlMemBlocks();
! 49408: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 49409:
! 49410: ret_val = xmlXPathPopExternal(ctxt);
! 49411: desret_void_ptr(ret_val);
! 49412: call_tests++;
! 49413: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 49414: xmlResetLastError();
! 49415: if (mem_base != xmlMemBlocks()) {
! 49416: printf("Leak of %d blocks found in xmlXPathPopExternal",
! 49417: xmlMemBlocks() - mem_base);
! 49418: test_ret++;
! 49419: printf(" %d", n_ctxt);
! 49420: printf("\n");
! 49421: }
! 49422: }
! 49423: function_tests++;
! 49424: #endif
! 49425:
! 49426: return(test_ret);
! 49427: }
! 49428:
! 49429:
! 49430: static int
! 49431: test_xmlXPathPopNodeSet(void) {
! 49432: int test_ret = 0;
! 49433:
! 49434: #if defined(LIBXML_XPATH_ENABLED)
! 49435: int mem_base;
! 49436: xmlNodeSetPtr ret_val;
! 49437: xmlXPathParserContextPtr ctxt; /* an XPath parser context */
! 49438: int n_ctxt;
! 49439:
! 49440: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 49441: mem_base = xmlMemBlocks();
! 49442: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 49443:
! 49444: ret_val = xmlXPathPopNodeSet(ctxt);
! 49445: desret_xmlNodeSetPtr(ret_val);
! 49446: call_tests++;
! 49447: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 49448: xmlResetLastError();
! 49449: if (mem_base != xmlMemBlocks()) {
! 49450: printf("Leak of %d blocks found in xmlXPathPopNodeSet",
! 49451: xmlMemBlocks() - mem_base);
! 49452: test_ret++;
! 49453: printf(" %d", n_ctxt);
! 49454: printf("\n");
! 49455: }
! 49456: }
! 49457: function_tests++;
! 49458: #endif
! 49459:
! 49460: return(test_ret);
! 49461: }
! 49462:
! 49463:
! 49464: static int
! 49465: test_xmlXPathPopNumber(void) {
! 49466: int test_ret = 0;
! 49467:
! 49468: #if defined(LIBXML_XPATH_ENABLED)
! 49469: int mem_base;
! 49470: double ret_val;
! 49471: xmlXPathParserContextPtr ctxt; /* an XPath parser context */
! 49472: int n_ctxt;
! 49473:
! 49474: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 49475: mem_base = xmlMemBlocks();
! 49476: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 49477:
! 49478: ret_val = xmlXPathPopNumber(ctxt);
! 49479: desret_double(ret_val);
! 49480: call_tests++;
! 49481: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 49482: xmlResetLastError();
! 49483: if (mem_base != xmlMemBlocks()) {
! 49484: printf("Leak of %d blocks found in xmlXPathPopNumber",
! 49485: xmlMemBlocks() - mem_base);
! 49486: test_ret++;
! 49487: printf(" %d", n_ctxt);
! 49488: printf("\n");
! 49489: }
! 49490: }
! 49491: function_tests++;
! 49492: #endif
! 49493:
! 49494: return(test_ret);
! 49495: }
! 49496:
! 49497:
! 49498: static int
! 49499: test_xmlXPathPopString(void) {
! 49500: int test_ret = 0;
! 49501:
! 49502: #if defined(LIBXML_XPATH_ENABLED)
! 49503: int mem_base;
! 49504: xmlChar * ret_val;
! 49505: xmlXPathParserContextPtr ctxt; /* an XPath parser context */
! 49506: int n_ctxt;
! 49507:
! 49508: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 49509: mem_base = xmlMemBlocks();
! 49510: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 49511:
! 49512: ret_val = xmlXPathPopString(ctxt);
! 49513: desret_xmlChar_ptr(ret_val);
! 49514: call_tests++;
! 49515: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 49516: xmlResetLastError();
! 49517: if (mem_base != xmlMemBlocks()) {
! 49518: printf("Leak of %d blocks found in xmlXPathPopString",
! 49519: xmlMemBlocks() - mem_base);
! 49520: test_ret++;
! 49521: printf(" %d", n_ctxt);
! 49522: printf("\n");
! 49523: }
! 49524: }
! 49525: function_tests++;
! 49526: #endif
! 49527:
! 49528: return(test_ret);
! 49529: }
! 49530:
! 49531:
! 49532: static int
! 49533: test_xmlXPathPositionFunction(void) {
! 49534: int test_ret = 0;
! 49535:
! 49536: #if defined(LIBXML_XPATH_ENABLED)
! 49537: int mem_base;
! 49538: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 49539: int n_ctxt;
! 49540: int nargs; /* the number of arguments */
! 49541: int n_nargs;
! 49542:
! 49543: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 49544: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 49545: mem_base = xmlMemBlocks();
! 49546: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 49547: nargs = gen_int(n_nargs, 1);
! 49548:
! 49549: xmlXPathPositionFunction(ctxt, nargs);
! 49550: call_tests++;
! 49551: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 49552: des_int(n_nargs, nargs, 1);
! 49553: xmlResetLastError();
! 49554: if (mem_base != xmlMemBlocks()) {
! 49555: printf("Leak of %d blocks found in xmlXPathPositionFunction",
! 49556: xmlMemBlocks() - mem_base);
! 49557: test_ret++;
! 49558: printf(" %d", n_ctxt);
! 49559: printf(" %d", n_nargs);
! 49560: printf("\n");
! 49561: }
! 49562: }
! 49563: }
! 49564: function_tests++;
! 49565: #endif
! 49566:
! 49567: return(test_ret);
! 49568: }
! 49569:
! 49570:
! 49571: static int
! 49572: test_xmlXPathRegisterAllFunctions(void) {
! 49573: int test_ret = 0;
! 49574:
! 49575: #if defined(LIBXML_XPATH_ENABLED)
! 49576: int mem_base;
! 49577: xmlXPathContextPtr ctxt; /* the XPath context */
! 49578: int n_ctxt;
! 49579:
! 49580: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
! 49581: mem_base = xmlMemBlocks();
! 49582: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
! 49583:
! 49584: xmlXPathRegisterAllFunctions(ctxt);
! 49585: call_tests++;
! 49586: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
! 49587: xmlResetLastError();
! 49588: if (mem_base != xmlMemBlocks()) {
! 49589: printf("Leak of %d blocks found in xmlXPathRegisterAllFunctions",
! 49590: xmlMemBlocks() - mem_base);
! 49591: test_ret++;
! 49592: printf(" %d", n_ctxt);
! 49593: printf("\n");
! 49594: }
! 49595: }
! 49596: function_tests++;
! 49597: #endif
! 49598:
! 49599: return(test_ret);
! 49600: }
! 49601:
! 49602:
! 49603: static int
! 49604: test_xmlXPathRegisterFunc(void) {
! 49605: int test_ret = 0;
! 49606:
! 49607:
! 49608: /* missing type support */
! 49609: return(test_ret);
! 49610: }
! 49611:
! 49612:
! 49613: static int
! 49614: test_xmlXPathRegisterFuncLookup(void) {
! 49615: int test_ret = 0;
! 49616:
! 49617:
! 49618: /* missing type support */
! 49619: return(test_ret);
! 49620: }
! 49621:
! 49622:
! 49623: static int
! 49624: test_xmlXPathRegisterFuncNS(void) {
! 49625: int test_ret = 0;
! 49626:
! 49627:
! 49628: /* missing type support */
! 49629: return(test_ret);
! 49630: }
! 49631:
! 49632:
! 49633: static int
! 49634: test_xmlXPathRegisterNs(void) {
! 49635: int test_ret = 0;
! 49636:
! 49637: #if defined(LIBXML_XPATH_ENABLED)
! 49638: int mem_base;
! 49639: int ret_val;
! 49640: xmlXPathContextPtr ctxt; /* the XPath context */
! 49641: int n_ctxt;
! 49642: xmlChar * prefix; /* the namespace prefix cannot be NULL or empty string */
! 49643: int n_prefix;
! 49644: xmlChar * ns_uri; /* the namespace name */
! 49645: int n_ns_uri;
! 49646:
! 49647: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
! 49648: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
! 49649: for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) {
! 49650: mem_base = xmlMemBlocks();
! 49651: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
! 49652: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
! 49653: ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2);
! 49654:
! 49655: ret_val = xmlXPathRegisterNs(ctxt, (const xmlChar *)prefix, (const xmlChar *)ns_uri);
! 49656: desret_int(ret_val);
! 49657: call_tests++;
! 49658: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
! 49659: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
! 49660: des_const_xmlChar_ptr(n_ns_uri, (const xmlChar *)ns_uri, 2);
! 49661: xmlResetLastError();
! 49662: if (mem_base != xmlMemBlocks()) {
! 49663: printf("Leak of %d blocks found in xmlXPathRegisterNs",
! 49664: xmlMemBlocks() - mem_base);
! 49665: test_ret++;
! 49666: printf(" %d", n_ctxt);
! 49667: printf(" %d", n_prefix);
! 49668: printf(" %d", n_ns_uri);
! 49669: printf("\n");
! 49670: }
! 49671: }
! 49672: }
! 49673: }
! 49674: function_tests++;
! 49675: #endif
! 49676:
! 49677: return(test_ret);
! 49678: }
! 49679:
! 49680:
! 49681: static int
! 49682: test_xmlXPathRegisterVariable(void) {
! 49683: int test_ret = 0;
! 49684:
! 49685: #if defined(LIBXML_XPATH_ENABLED)
! 49686: int mem_base;
! 49687: int ret_val;
! 49688: xmlXPathContextPtr ctxt; /* the XPath context */
! 49689: int n_ctxt;
! 49690: xmlChar * name; /* the variable name */
! 49691: int n_name;
! 49692: xmlXPathObjectPtr value; /* the variable value or NULL */
! 49693: int n_value;
! 49694:
! 49695: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
! 49696: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 49697: for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) {
! 49698: mem_base = xmlMemBlocks();
! 49699: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
! 49700: name = gen_const_xmlChar_ptr(n_name, 1);
! 49701: value = gen_xmlXPathObjectPtr(n_value, 2);
! 49702:
! 49703: ret_val = xmlXPathRegisterVariable(ctxt, (const xmlChar *)name, value);
! 49704: desret_int(ret_val);
! 49705: call_tests++;
! 49706: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
! 49707: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 49708: des_xmlXPathObjectPtr(n_value, value, 2);
! 49709: xmlResetLastError();
! 49710: if (mem_base != xmlMemBlocks()) {
! 49711: printf("Leak of %d blocks found in xmlXPathRegisterVariable",
! 49712: xmlMemBlocks() - mem_base);
! 49713: test_ret++;
! 49714: printf(" %d", n_ctxt);
! 49715: printf(" %d", n_name);
! 49716: printf(" %d", n_value);
! 49717: printf("\n");
! 49718: }
! 49719: }
! 49720: }
! 49721: }
! 49722: function_tests++;
! 49723: #endif
! 49724:
! 49725: return(test_ret);
! 49726: }
! 49727:
! 49728:
! 49729: static int
! 49730: test_xmlXPathRegisterVariableLookup(void) {
! 49731: int test_ret = 0;
! 49732:
! 49733:
! 49734: /* missing type support */
! 49735: return(test_ret);
! 49736: }
! 49737:
! 49738:
! 49739: static int
! 49740: test_xmlXPathRegisterVariableNS(void) {
! 49741: int test_ret = 0;
! 49742:
! 49743: #if defined(LIBXML_XPATH_ENABLED)
! 49744: int mem_base;
! 49745: int ret_val;
! 49746: xmlXPathContextPtr ctxt; /* the XPath context */
! 49747: int n_ctxt;
! 49748: xmlChar * name; /* the variable name */
! 49749: int n_name;
! 49750: xmlChar * ns_uri; /* the variable namespace URI */
! 49751: int n_ns_uri;
! 49752: xmlXPathObjectPtr value; /* the variable value or NULL */
! 49753: int n_value;
! 49754:
! 49755: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
! 49756: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 49757: for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) {
! 49758: for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) {
! 49759: mem_base = xmlMemBlocks();
! 49760: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
! 49761: name = gen_const_xmlChar_ptr(n_name, 1);
! 49762: ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2);
! 49763: value = gen_xmlXPathObjectPtr(n_value, 3);
! 49764:
! 49765: ret_val = xmlXPathRegisterVariableNS(ctxt, (const xmlChar *)name, (const xmlChar *)ns_uri, value);
! 49766: desret_int(ret_val);
! 49767: call_tests++;
! 49768: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
! 49769: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 49770: des_const_xmlChar_ptr(n_ns_uri, (const xmlChar *)ns_uri, 2);
! 49771: des_xmlXPathObjectPtr(n_value, value, 3);
! 49772: xmlResetLastError();
! 49773: if (mem_base != xmlMemBlocks()) {
! 49774: printf("Leak of %d blocks found in xmlXPathRegisterVariableNS",
! 49775: xmlMemBlocks() - mem_base);
! 49776: test_ret++;
! 49777: printf(" %d", n_ctxt);
! 49778: printf(" %d", n_name);
! 49779: printf(" %d", n_ns_uri);
! 49780: printf(" %d", n_value);
! 49781: printf("\n");
! 49782: }
! 49783: }
! 49784: }
! 49785: }
! 49786: }
! 49787: function_tests++;
! 49788: #endif
! 49789:
! 49790: return(test_ret);
! 49791: }
! 49792:
! 49793:
! 49794: static int
! 49795: test_xmlXPathRegisteredFuncsCleanup(void) {
! 49796: int test_ret = 0;
! 49797:
! 49798: #if defined(LIBXML_XPATH_ENABLED)
! 49799: int mem_base;
! 49800: xmlXPathContextPtr ctxt; /* the XPath context */
! 49801: int n_ctxt;
! 49802:
! 49803: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
! 49804: mem_base = xmlMemBlocks();
! 49805: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
! 49806:
! 49807: xmlXPathRegisteredFuncsCleanup(ctxt);
! 49808: call_tests++;
! 49809: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
! 49810: xmlResetLastError();
! 49811: if (mem_base != xmlMemBlocks()) {
! 49812: printf("Leak of %d blocks found in xmlXPathRegisteredFuncsCleanup",
! 49813: xmlMemBlocks() - mem_base);
! 49814: test_ret++;
! 49815: printf(" %d", n_ctxt);
! 49816: printf("\n");
! 49817: }
! 49818: }
! 49819: function_tests++;
! 49820: #endif
! 49821:
! 49822: return(test_ret);
! 49823: }
! 49824:
! 49825:
! 49826: static int
! 49827: test_xmlXPathRegisteredNsCleanup(void) {
! 49828: int test_ret = 0;
! 49829:
! 49830: #if defined(LIBXML_XPATH_ENABLED)
! 49831: int mem_base;
! 49832: xmlXPathContextPtr ctxt; /* the XPath context */
! 49833: int n_ctxt;
! 49834:
! 49835: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
! 49836: mem_base = xmlMemBlocks();
! 49837: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
! 49838:
! 49839: xmlXPathRegisteredNsCleanup(ctxt);
! 49840: call_tests++;
! 49841: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
! 49842: xmlResetLastError();
! 49843: if (mem_base != xmlMemBlocks()) {
! 49844: printf("Leak of %d blocks found in xmlXPathRegisteredNsCleanup",
! 49845: xmlMemBlocks() - mem_base);
! 49846: test_ret++;
! 49847: printf(" %d", n_ctxt);
! 49848: printf("\n");
! 49849: }
! 49850: }
! 49851: function_tests++;
! 49852: #endif
! 49853:
! 49854: return(test_ret);
! 49855: }
! 49856:
! 49857:
! 49858: static int
! 49859: test_xmlXPathRegisteredVariablesCleanup(void) {
! 49860: int test_ret = 0;
! 49861:
! 49862: #if defined(LIBXML_XPATH_ENABLED)
! 49863: int mem_base;
! 49864: xmlXPathContextPtr ctxt; /* the XPath context */
! 49865: int n_ctxt;
! 49866:
! 49867: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
! 49868: mem_base = xmlMemBlocks();
! 49869: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
! 49870:
! 49871: xmlXPathRegisteredVariablesCleanup(ctxt);
! 49872: call_tests++;
! 49873: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
! 49874: xmlResetLastError();
! 49875: if (mem_base != xmlMemBlocks()) {
! 49876: printf("Leak of %d blocks found in xmlXPathRegisteredVariablesCleanup",
! 49877: xmlMemBlocks() - mem_base);
! 49878: test_ret++;
! 49879: printf(" %d", n_ctxt);
! 49880: printf("\n");
! 49881: }
! 49882: }
! 49883: function_tests++;
! 49884: #endif
! 49885:
! 49886: return(test_ret);
! 49887: }
! 49888:
! 49889:
! 49890: static int
! 49891: test_xmlXPathRoot(void) {
! 49892: int test_ret = 0;
! 49893:
! 49894: #if defined(LIBXML_XPATH_ENABLED)
! 49895: int mem_base;
! 49896: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 49897: int n_ctxt;
! 49898:
! 49899: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 49900: mem_base = xmlMemBlocks();
! 49901: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 49902:
! 49903: xmlXPathRoot(ctxt);
! 49904: call_tests++;
! 49905: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 49906: xmlResetLastError();
! 49907: if (mem_base != xmlMemBlocks()) {
! 49908: printf("Leak of %d blocks found in xmlXPathRoot",
! 49909: xmlMemBlocks() - mem_base);
! 49910: test_ret++;
! 49911: printf(" %d", n_ctxt);
! 49912: printf("\n");
! 49913: }
! 49914: }
! 49915: function_tests++;
! 49916: #endif
! 49917:
! 49918: return(test_ret);
! 49919: }
! 49920:
! 49921:
! 49922: static int
! 49923: test_xmlXPathRoundFunction(void) {
! 49924: int test_ret = 0;
! 49925:
! 49926: #if defined(LIBXML_XPATH_ENABLED)
! 49927: int mem_base;
! 49928: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 49929: int n_ctxt;
! 49930: int nargs; /* the number of arguments */
! 49931: int n_nargs;
! 49932:
! 49933: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 49934: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 49935: mem_base = xmlMemBlocks();
! 49936: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 49937: nargs = gen_int(n_nargs, 1);
! 49938:
! 49939: xmlXPathRoundFunction(ctxt, nargs);
! 49940: call_tests++;
! 49941: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 49942: des_int(n_nargs, nargs, 1);
! 49943: xmlResetLastError();
! 49944: if (mem_base != xmlMemBlocks()) {
! 49945: printf("Leak of %d blocks found in xmlXPathRoundFunction",
! 49946: xmlMemBlocks() - mem_base);
! 49947: test_ret++;
! 49948: printf(" %d", n_ctxt);
! 49949: printf(" %d", n_nargs);
! 49950: printf("\n");
! 49951: }
! 49952: }
! 49953: }
! 49954: function_tests++;
! 49955: #endif
! 49956:
! 49957: return(test_ret);
! 49958: }
! 49959:
! 49960:
! 49961: static int
! 49962: test_xmlXPathStartsWithFunction(void) {
! 49963: int test_ret = 0;
! 49964:
! 49965: #if defined(LIBXML_XPATH_ENABLED)
! 49966: int mem_base;
! 49967: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 49968: int n_ctxt;
! 49969: int nargs; /* the number of arguments */
! 49970: int n_nargs;
! 49971:
! 49972: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 49973: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 49974: mem_base = xmlMemBlocks();
! 49975: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 49976: nargs = gen_int(n_nargs, 1);
! 49977:
! 49978: xmlXPathStartsWithFunction(ctxt, nargs);
! 49979: call_tests++;
! 49980: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 49981: des_int(n_nargs, nargs, 1);
! 49982: xmlResetLastError();
! 49983: if (mem_base != xmlMemBlocks()) {
! 49984: printf("Leak of %d blocks found in xmlXPathStartsWithFunction",
! 49985: xmlMemBlocks() - mem_base);
! 49986: test_ret++;
! 49987: printf(" %d", n_ctxt);
! 49988: printf(" %d", n_nargs);
! 49989: printf("\n");
! 49990: }
! 49991: }
! 49992: }
! 49993: function_tests++;
! 49994: #endif
! 49995:
! 49996: return(test_ret);
! 49997: }
! 49998:
! 49999:
! 50000: static int
! 50001: test_xmlXPathStringEvalNumber(void) {
! 50002: int test_ret = 0;
! 50003:
! 50004: #if defined(LIBXML_XPATH_ENABLED)
! 50005: int mem_base;
! 50006: double ret_val;
! 50007: xmlChar * str; /* A string to scan */
! 50008: int n_str;
! 50009:
! 50010: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 50011: mem_base = xmlMemBlocks();
! 50012: str = gen_const_xmlChar_ptr(n_str, 0);
! 50013:
! 50014: ret_val = xmlXPathStringEvalNumber((const xmlChar *)str);
! 50015: desret_double(ret_val);
! 50016: call_tests++;
! 50017: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
! 50018: xmlResetLastError();
! 50019: if (mem_base != xmlMemBlocks()) {
! 50020: printf("Leak of %d blocks found in xmlXPathStringEvalNumber",
! 50021: xmlMemBlocks() - mem_base);
! 50022: test_ret++;
! 50023: printf(" %d", n_str);
! 50024: printf("\n");
! 50025: }
! 50026: }
! 50027: function_tests++;
! 50028: #endif
! 50029:
! 50030: return(test_ret);
! 50031: }
! 50032:
! 50033:
! 50034: static int
! 50035: test_xmlXPathStringFunction(void) {
! 50036: int test_ret = 0;
! 50037:
! 50038: #if defined(LIBXML_XPATH_ENABLED)
! 50039: int mem_base;
! 50040: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 50041: int n_ctxt;
! 50042: int nargs; /* the number of arguments */
! 50043: int n_nargs;
! 50044:
! 50045: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 50046: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 50047: mem_base = xmlMemBlocks();
! 50048: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 50049: nargs = gen_int(n_nargs, 1);
! 50050:
! 50051: xmlXPathStringFunction(ctxt, nargs);
! 50052: call_tests++;
! 50053: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 50054: des_int(n_nargs, nargs, 1);
! 50055: xmlResetLastError();
! 50056: if (mem_base != xmlMemBlocks()) {
! 50057: printf("Leak of %d blocks found in xmlXPathStringFunction",
! 50058: xmlMemBlocks() - mem_base);
! 50059: test_ret++;
! 50060: printf(" %d", n_ctxt);
! 50061: printf(" %d", n_nargs);
! 50062: printf("\n");
! 50063: }
! 50064: }
! 50065: }
! 50066: function_tests++;
! 50067: #endif
! 50068:
! 50069: return(test_ret);
! 50070: }
! 50071:
! 50072:
! 50073: static int
! 50074: test_xmlXPathStringLengthFunction(void) {
! 50075: int test_ret = 0;
! 50076:
! 50077: #if defined(LIBXML_XPATH_ENABLED)
! 50078: int mem_base;
! 50079: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 50080: int n_ctxt;
! 50081: int nargs; /* the number of arguments */
! 50082: int n_nargs;
! 50083:
! 50084: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 50085: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 50086: mem_base = xmlMemBlocks();
! 50087: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 50088: nargs = gen_int(n_nargs, 1);
! 50089:
! 50090: xmlXPathStringLengthFunction(ctxt, nargs);
! 50091: call_tests++;
! 50092: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 50093: des_int(n_nargs, nargs, 1);
! 50094: xmlResetLastError();
! 50095: if (mem_base != xmlMemBlocks()) {
! 50096: printf("Leak of %d blocks found in xmlXPathStringLengthFunction",
! 50097: xmlMemBlocks() - mem_base);
! 50098: test_ret++;
! 50099: printf(" %d", n_ctxt);
! 50100: printf(" %d", n_nargs);
! 50101: printf("\n");
! 50102: }
! 50103: }
! 50104: }
! 50105: function_tests++;
! 50106: #endif
! 50107:
! 50108: return(test_ret);
! 50109: }
! 50110:
! 50111:
! 50112: static int
! 50113: test_xmlXPathSubValues(void) {
! 50114: int test_ret = 0;
! 50115:
! 50116: #if defined(LIBXML_XPATH_ENABLED)
! 50117: int mem_base;
! 50118: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 50119: int n_ctxt;
! 50120:
! 50121: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 50122: mem_base = xmlMemBlocks();
! 50123: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 50124:
! 50125: xmlXPathSubValues(ctxt);
! 50126: call_tests++;
! 50127: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 50128: xmlResetLastError();
! 50129: if (mem_base != xmlMemBlocks()) {
! 50130: printf("Leak of %d blocks found in xmlXPathSubValues",
! 50131: xmlMemBlocks() - mem_base);
! 50132: test_ret++;
! 50133: printf(" %d", n_ctxt);
! 50134: printf("\n");
! 50135: }
! 50136: }
! 50137: function_tests++;
! 50138: #endif
! 50139:
! 50140: return(test_ret);
! 50141: }
! 50142:
! 50143:
! 50144: static int
! 50145: test_xmlXPathSubstringAfterFunction(void) {
! 50146: int test_ret = 0;
! 50147:
! 50148: #if defined(LIBXML_XPATH_ENABLED)
! 50149: int mem_base;
! 50150: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 50151: int n_ctxt;
! 50152: int nargs; /* the number of arguments */
! 50153: int n_nargs;
! 50154:
! 50155: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 50156: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 50157: mem_base = xmlMemBlocks();
! 50158: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 50159: nargs = gen_int(n_nargs, 1);
! 50160:
! 50161: xmlXPathSubstringAfterFunction(ctxt, nargs);
! 50162: call_tests++;
! 50163: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 50164: des_int(n_nargs, nargs, 1);
! 50165: xmlResetLastError();
! 50166: if (mem_base != xmlMemBlocks()) {
! 50167: printf("Leak of %d blocks found in xmlXPathSubstringAfterFunction",
! 50168: xmlMemBlocks() - mem_base);
! 50169: test_ret++;
! 50170: printf(" %d", n_ctxt);
! 50171: printf(" %d", n_nargs);
! 50172: printf("\n");
! 50173: }
! 50174: }
! 50175: }
! 50176: function_tests++;
! 50177: #endif
! 50178:
! 50179: return(test_ret);
! 50180: }
! 50181:
! 50182:
! 50183: static int
! 50184: test_xmlXPathSubstringBeforeFunction(void) {
! 50185: int test_ret = 0;
! 50186:
! 50187: #if defined(LIBXML_XPATH_ENABLED)
! 50188: int mem_base;
! 50189: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 50190: int n_ctxt;
! 50191: int nargs; /* the number of arguments */
! 50192: int n_nargs;
! 50193:
! 50194: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 50195: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 50196: mem_base = xmlMemBlocks();
! 50197: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 50198: nargs = gen_int(n_nargs, 1);
! 50199:
! 50200: xmlXPathSubstringBeforeFunction(ctxt, nargs);
! 50201: call_tests++;
! 50202: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 50203: des_int(n_nargs, nargs, 1);
! 50204: xmlResetLastError();
! 50205: if (mem_base != xmlMemBlocks()) {
! 50206: printf("Leak of %d blocks found in xmlXPathSubstringBeforeFunction",
! 50207: xmlMemBlocks() - mem_base);
! 50208: test_ret++;
! 50209: printf(" %d", n_ctxt);
! 50210: printf(" %d", n_nargs);
! 50211: printf("\n");
! 50212: }
! 50213: }
! 50214: }
! 50215: function_tests++;
! 50216: #endif
! 50217:
! 50218: return(test_ret);
! 50219: }
! 50220:
! 50221:
! 50222: static int
! 50223: test_xmlXPathSubstringFunction(void) {
! 50224: int test_ret = 0;
! 50225:
! 50226: #if defined(LIBXML_XPATH_ENABLED)
! 50227: int mem_base;
! 50228: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 50229: int n_ctxt;
! 50230: int nargs; /* the number of arguments */
! 50231: int n_nargs;
! 50232:
! 50233: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 50234: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 50235: mem_base = xmlMemBlocks();
! 50236: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 50237: nargs = gen_int(n_nargs, 1);
! 50238:
! 50239: xmlXPathSubstringFunction(ctxt, nargs);
! 50240: call_tests++;
! 50241: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 50242: des_int(n_nargs, nargs, 1);
! 50243: xmlResetLastError();
! 50244: if (mem_base != xmlMemBlocks()) {
! 50245: printf("Leak of %d blocks found in xmlXPathSubstringFunction",
! 50246: xmlMemBlocks() - mem_base);
! 50247: test_ret++;
! 50248: printf(" %d", n_ctxt);
! 50249: printf(" %d", n_nargs);
! 50250: printf("\n");
! 50251: }
! 50252: }
! 50253: }
! 50254: function_tests++;
! 50255: #endif
! 50256:
! 50257: return(test_ret);
! 50258: }
! 50259:
! 50260:
! 50261: static int
! 50262: test_xmlXPathSumFunction(void) {
! 50263: int test_ret = 0;
! 50264:
! 50265: #if defined(LIBXML_XPATH_ENABLED)
! 50266: int mem_base;
! 50267: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 50268: int n_ctxt;
! 50269: int nargs; /* the number of arguments */
! 50270: int n_nargs;
! 50271:
! 50272: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 50273: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 50274: mem_base = xmlMemBlocks();
! 50275: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 50276: nargs = gen_int(n_nargs, 1);
! 50277:
! 50278: xmlXPathSumFunction(ctxt, nargs);
! 50279: call_tests++;
! 50280: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 50281: des_int(n_nargs, nargs, 1);
! 50282: xmlResetLastError();
! 50283: if (mem_base != xmlMemBlocks()) {
! 50284: printf("Leak of %d blocks found in xmlXPathSumFunction",
! 50285: xmlMemBlocks() - mem_base);
! 50286: test_ret++;
! 50287: printf(" %d", n_ctxt);
! 50288: printf(" %d", n_nargs);
! 50289: printf("\n");
! 50290: }
! 50291: }
! 50292: }
! 50293: function_tests++;
! 50294: #endif
! 50295:
! 50296: return(test_ret);
! 50297: }
! 50298:
! 50299:
! 50300: static int
! 50301: test_xmlXPathTrailing(void) {
! 50302: int test_ret = 0;
! 50303:
! 50304: #if defined(LIBXML_XPATH_ENABLED)
! 50305: int mem_base;
! 50306: xmlNodeSetPtr ret_val;
! 50307: xmlNodeSetPtr nodes1; /* a node-set */
! 50308: int n_nodes1;
! 50309: xmlNodeSetPtr nodes2; /* a node-set */
! 50310: int n_nodes2;
! 50311:
! 50312: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
! 50313: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
! 50314: mem_base = xmlMemBlocks();
! 50315: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
! 50316: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
! 50317:
! 50318: ret_val = xmlXPathTrailing(nodes1, nodes2);
! 50319: desret_xmlNodeSetPtr(ret_val);
! 50320: call_tests++;
! 50321: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
! 50322: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
! 50323: xmlResetLastError();
! 50324: if (mem_base != xmlMemBlocks()) {
! 50325: printf("Leak of %d blocks found in xmlXPathTrailing",
! 50326: xmlMemBlocks() - mem_base);
! 50327: test_ret++;
! 50328: printf(" %d", n_nodes1);
! 50329: printf(" %d", n_nodes2);
! 50330: printf("\n");
! 50331: }
! 50332: }
! 50333: }
! 50334: function_tests++;
! 50335: #endif
! 50336:
! 50337: return(test_ret);
! 50338: }
! 50339:
! 50340:
! 50341: static int
! 50342: test_xmlXPathTrailingSorted(void) {
! 50343: int test_ret = 0;
! 50344:
! 50345: #if defined(LIBXML_XPATH_ENABLED)
! 50346: int mem_base;
! 50347: xmlNodeSetPtr ret_val;
! 50348: xmlNodeSetPtr nodes1; /* a node-set, sorted by document order */
! 50349: int n_nodes1;
! 50350: xmlNodeSetPtr nodes2; /* a node-set, sorted by document order */
! 50351: int n_nodes2;
! 50352:
! 50353: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
! 50354: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
! 50355: mem_base = xmlMemBlocks();
! 50356: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
! 50357: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
! 50358:
! 50359: ret_val = xmlXPathTrailingSorted(nodes1, nodes2);
! 50360: desret_xmlNodeSetPtr(ret_val);
! 50361: call_tests++;
! 50362: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
! 50363: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
! 50364: xmlResetLastError();
! 50365: if (mem_base != xmlMemBlocks()) {
! 50366: printf("Leak of %d blocks found in xmlXPathTrailingSorted",
! 50367: xmlMemBlocks() - mem_base);
! 50368: test_ret++;
! 50369: printf(" %d", n_nodes1);
! 50370: printf(" %d", n_nodes2);
! 50371: printf("\n");
! 50372: }
! 50373: }
! 50374: }
! 50375: function_tests++;
! 50376: #endif
! 50377:
! 50378: return(test_ret);
! 50379: }
! 50380:
! 50381:
! 50382: static int
! 50383: test_xmlXPathTranslateFunction(void) {
! 50384: int test_ret = 0;
! 50385:
! 50386: #if defined(LIBXML_XPATH_ENABLED)
! 50387: int mem_base;
! 50388: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 50389: int n_ctxt;
! 50390: int nargs; /* the number of arguments */
! 50391: int n_nargs;
! 50392:
! 50393: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 50394: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 50395: mem_base = xmlMemBlocks();
! 50396: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 50397: nargs = gen_int(n_nargs, 1);
! 50398:
! 50399: xmlXPathTranslateFunction(ctxt, nargs);
! 50400: call_tests++;
! 50401: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 50402: des_int(n_nargs, nargs, 1);
! 50403: xmlResetLastError();
! 50404: if (mem_base != xmlMemBlocks()) {
! 50405: printf("Leak of %d blocks found in xmlXPathTranslateFunction",
! 50406: xmlMemBlocks() - mem_base);
! 50407: test_ret++;
! 50408: printf(" %d", n_ctxt);
! 50409: printf(" %d", n_nargs);
! 50410: printf("\n");
! 50411: }
! 50412: }
! 50413: }
! 50414: function_tests++;
! 50415: #endif
! 50416:
! 50417: return(test_ret);
! 50418: }
! 50419:
! 50420:
! 50421: static int
! 50422: test_xmlXPathTrueFunction(void) {
! 50423: int test_ret = 0;
! 50424:
! 50425: #if defined(LIBXML_XPATH_ENABLED)
! 50426: int mem_base;
! 50427: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 50428: int n_ctxt;
! 50429: int nargs; /* the number of arguments */
! 50430: int n_nargs;
! 50431:
! 50432: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 50433: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 50434: mem_base = xmlMemBlocks();
! 50435: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 50436: nargs = gen_int(n_nargs, 1);
! 50437:
! 50438: xmlXPathTrueFunction(ctxt, nargs);
! 50439: call_tests++;
! 50440: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 50441: des_int(n_nargs, nargs, 1);
! 50442: xmlResetLastError();
! 50443: if (mem_base != xmlMemBlocks()) {
! 50444: printf("Leak of %d blocks found in xmlXPathTrueFunction",
! 50445: xmlMemBlocks() - mem_base);
! 50446: test_ret++;
! 50447: printf(" %d", n_ctxt);
! 50448: printf(" %d", n_nargs);
! 50449: printf("\n");
! 50450: }
! 50451: }
! 50452: }
! 50453: function_tests++;
! 50454: #endif
! 50455:
! 50456: return(test_ret);
! 50457: }
! 50458:
! 50459:
! 50460: static int
! 50461: test_xmlXPathValueFlipSign(void) {
! 50462: int test_ret = 0;
! 50463:
! 50464: #if defined(LIBXML_XPATH_ENABLED)
! 50465: int mem_base;
! 50466: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 50467: int n_ctxt;
! 50468:
! 50469: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 50470: mem_base = xmlMemBlocks();
! 50471: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 50472:
! 50473: xmlXPathValueFlipSign(ctxt);
! 50474: call_tests++;
! 50475: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 50476: xmlResetLastError();
! 50477: if (mem_base != xmlMemBlocks()) {
! 50478: printf("Leak of %d blocks found in xmlXPathValueFlipSign",
! 50479: xmlMemBlocks() - mem_base);
! 50480: test_ret++;
! 50481: printf(" %d", n_ctxt);
! 50482: printf("\n");
! 50483: }
! 50484: }
! 50485: function_tests++;
! 50486: #endif
! 50487:
! 50488: return(test_ret);
! 50489: }
! 50490:
! 50491:
! 50492: static int
! 50493: test_xmlXPathVariableLookup(void) {
! 50494: int test_ret = 0;
! 50495:
! 50496: #if defined(LIBXML_XPATH_ENABLED)
! 50497: int mem_base;
! 50498: xmlXPathObjectPtr ret_val;
! 50499: xmlXPathContextPtr ctxt; /* the XPath context */
! 50500: int n_ctxt;
! 50501: xmlChar * name; /* the variable name */
! 50502: int n_name;
! 50503:
! 50504: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
! 50505: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 50506: mem_base = xmlMemBlocks();
! 50507: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
! 50508: name = gen_const_xmlChar_ptr(n_name, 1);
! 50509:
! 50510: ret_val = xmlXPathVariableLookup(ctxt, (const xmlChar *)name);
! 50511: desret_xmlXPathObjectPtr(ret_val);
! 50512: call_tests++;
! 50513: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
! 50514: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 50515: xmlResetLastError();
! 50516: if (mem_base != xmlMemBlocks()) {
! 50517: printf("Leak of %d blocks found in xmlXPathVariableLookup",
! 50518: xmlMemBlocks() - mem_base);
! 50519: test_ret++;
! 50520: printf(" %d", n_ctxt);
! 50521: printf(" %d", n_name);
! 50522: printf("\n");
! 50523: }
! 50524: }
! 50525: }
! 50526: function_tests++;
! 50527: #endif
! 50528:
! 50529: return(test_ret);
! 50530: }
! 50531:
! 50532:
! 50533: static int
! 50534: test_xmlXPathVariableLookupNS(void) {
! 50535: int test_ret = 0;
! 50536:
! 50537: #if defined(LIBXML_XPATH_ENABLED)
! 50538: int mem_base;
! 50539: xmlXPathObjectPtr ret_val;
! 50540: xmlXPathContextPtr ctxt; /* the XPath context */
! 50541: int n_ctxt;
! 50542: xmlChar * name; /* the variable name */
! 50543: int n_name;
! 50544: xmlChar * ns_uri; /* the variable namespace URI */
! 50545: int n_ns_uri;
! 50546:
! 50547: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
! 50548: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
! 50549: for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) {
! 50550: mem_base = xmlMemBlocks();
! 50551: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
! 50552: name = gen_const_xmlChar_ptr(n_name, 1);
! 50553: ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2);
! 50554:
! 50555: ret_val = xmlXPathVariableLookupNS(ctxt, (const xmlChar *)name, (const xmlChar *)ns_uri);
! 50556: desret_xmlXPathObjectPtr(ret_val);
! 50557: call_tests++;
! 50558: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
! 50559: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
! 50560: des_const_xmlChar_ptr(n_ns_uri, (const xmlChar *)ns_uri, 2);
! 50561: xmlResetLastError();
! 50562: if (mem_base != xmlMemBlocks()) {
! 50563: printf("Leak of %d blocks found in xmlXPathVariableLookupNS",
! 50564: xmlMemBlocks() - mem_base);
! 50565: test_ret++;
! 50566: printf(" %d", n_ctxt);
! 50567: printf(" %d", n_name);
! 50568: printf(" %d", n_ns_uri);
! 50569: printf("\n");
! 50570: }
! 50571: }
! 50572: }
! 50573: }
! 50574: function_tests++;
! 50575: #endif
! 50576:
! 50577: return(test_ret);
! 50578: }
! 50579:
! 50580:
! 50581: static int
! 50582: test_xmlXPathWrapCString(void) {
! 50583: int test_ret = 0;
! 50584:
! 50585: #if defined(LIBXML_XPATH_ENABLED)
! 50586: int mem_base;
! 50587: xmlXPathObjectPtr ret_val;
! 50588: char * val; /* the char * value */
! 50589: int n_val;
! 50590:
! 50591: for (n_val = 0;n_val < gen_nb_char_ptr;n_val++) {
! 50592: mem_base = xmlMemBlocks();
! 50593: val = gen_char_ptr(n_val, 0);
! 50594:
! 50595: ret_val = xmlXPathWrapCString(val);
! 50596: desret_xmlXPathObjectPtr(ret_val);
! 50597: call_tests++;
! 50598: des_char_ptr(n_val, val, 0);
! 50599: xmlResetLastError();
! 50600: if (mem_base != xmlMemBlocks()) {
! 50601: printf("Leak of %d blocks found in xmlXPathWrapCString",
! 50602: xmlMemBlocks() - mem_base);
! 50603: test_ret++;
! 50604: printf(" %d", n_val);
! 50605: printf("\n");
! 50606: }
! 50607: }
! 50608: function_tests++;
! 50609: #endif
! 50610:
! 50611: return(test_ret);
! 50612: }
! 50613:
! 50614:
! 50615: static int
! 50616: test_xmlXPathWrapExternal(void) {
! 50617: int test_ret = 0;
! 50618:
! 50619: #if defined(LIBXML_XPATH_ENABLED)
! 50620: int mem_base;
! 50621: xmlXPathObjectPtr ret_val;
! 50622: void * val; /* the user data */
! 50623: int n_val;
! 50624:
! 50625: for (n_val = 0;n_val < gen_nb_void_ptr;n_val++) {
! 50626: mem_base = xmlMemBlocks();
! 50627: val = gen_void_ptr(n_val, 0);
! 50628:
! 50629: ret_val = xmlXPathWrapExternal(val);
! 50630: desret_xmlXPathObjectPtr(ret_val);
! 50631: call_tests++;
! 50632: des_void_ptr(n_val, val, 0);
! 50633: xmlResetLastError();
! 50634: if (mem_base != xmlMemBlocks()) {
! 50635: printf("Leak of %d blocks found in xmlXPathWrapExternal",
! 50636: xmlMemBlocks() - mem_base);
! 50637: test_ret++;
! 50638: printf(" %d", n_val);
! 50639: printf("\n");
! 50640: }
! 50641: }
! 50642: function_tests++;
! 50643: #endif
! 50644:
! 50645: return(test_ret);
! 50646: }
! 50647:
! 50648:
! 50649: static int
! 50650: test_xmlXPathWrapNodeSet(void) {
! 50651: int test_ret = 0;
! 50652:
! 50653: #if defined(LIBXML_XPATH_ENABLED)
! 50654: int mem_base;
! 50655: xmlXPathObjectPtr ret_val;
! 50656: xmlNodeSetPtr val; /* the NodePtr value */
! 50657: int n_val;
! 50658:
! 50659: for (n_val = 0;n_val < gen_nb_xmlNodeSetPtr;n_val++) {
! 50660: mem_base = xmlMemBlocks();
! 50661: val = gen_xmlNodeSetPtr(n_val, 0);
! 50662:
! 50663: ret_val = xmlXPathWrapNodeSet(val);
! 50664: desret_xmlXPathObjectPtr(ret_val);
! 50665: call_tests++;
! 50666: des_xmlNodeSetPtr(n_val, val, 0);
! 50667: xmlResetLastError();
! 50668: if (mem_base != xmlMemBlocks()) {
! 50669: printf("Leak of %d blocks found in xmlXPathWrapNodeSet",
! 50670: xmlMemBlocks() - mem_base);
! 50671: test_ret++;
! 50672: printf(" %d", n_val);
! 50673: printf("\n");
! 50674: }
! 50675: }
! 50676: function_tests++;
! 50677: #endif
! 50678:
! 50679: return(test_ret);
! 50680: }
! 50681:
! 50682:
! 50683: static int
! 50684: test_xmlXPatherror(void) {
! 50685: int test_ret = 0;
! 50686:
! 50687: #if defined(LIBXML_XPATH_ENABLED)
! 50688: int mem_base;
! 50689: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
! 50690: int n_ctxt;
! 50691: const char * file; /* the file name */
! 50692: int n_file;
! 50693: int line; /* the line number */
! 50694: int n_line;
! 50695: int no; /* the error number */
! 50696: int n_no;
! 50697:
! 50698: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 50699: for (n_file = 0;n_file < gen_nb_filepath;n_file++) {
! 50700: for (n_line = 0;n_line < gen_nb_int;n_line++) {
! 50701: for (n_no = 0;n_no < gen_nb_int;n_no++) {
! 50702: mem_base = xmlMemBlocks();
! 50703: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 50704: file = gen_filepath(n_file, 1);
! 50705: line = gen_int(n_line, 2);
! 50706: no = gen_int(n_no, 3);
! 50707:
! 50708: xmlXPatherror(ctxt, file, line, no);
! 50709: call_tests++;
! 50710: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 50711: des_filepath(n_file, file, 1);
! 50712: des_int(n_line, line, 2);
! 50713: des_int(n_no, no, 3);
! 50714: xmlResetLastError();
! 50715: if (mem_base != xmlMemBlocks()) {
! 50716: printf("Leak of %d blocks found in xmlXPatherror",
! 50717: xmlMemBlocks() - mem_base);
! 50718: test_ret++;
! 50719: printf(" %d", n_ctxt);
! 50720: printf(" %d", n_file);
! 50721: printf(" %d", n_line);
! 50722: printf(" %d", n_no);
! 50723: printf("\n");
! 50724: }
! 50725: }
! 50726: }
! 50727: }
! 50728: }
! 50729: function_tests++;
! 50730: #endif
! 50731:
! 50732: return(test_ret);
! 50733: }
! 50734:
! 50735: static int
! 50736: test_xpathInternals(void) {
! 50737: int test_ret = 0;
! 50738:
! 50739: if (quiet == 0) printf("Testing xpathInternals : 106 of 117 functions ...\n");
! 50740: test_ret += test_valuePop();
! 50741: test_ret += test_valuePush();
! 50742: test_ret += test_xmlXPathAddValues();
! 50743: test_ret += test_xmlXPathBooleanFunction();
! 50744: test_ret += test_xmlXPathCeilingFunction();
! 50745: test_ret += test_xmlXPathCompareValues();
! 50746: test_ret += test_xmlXPathConcatFunction();
! 50747: test_ret += test_xmlXPathContainsFunction();
! 50748: test_ret += test_xmlXPathCountFunction();
! 50749: test_ret += test_xmlXPathDebugDumpCompExpr();
! 50750: test_ret += test_xmlXPathDebugDumpObject();
! 50751: test_ret += test_xmlXPathDifference();
! 50752: test_ret += test_xmlXPathDistinct();
! 50753: test_ret += test_xmlXPathDistinctSorted();
! 50754: test_ret += test_xmlXPathDivValues();
! 50755: test_ret += test_xmlXPathEqualValues();
! 50756: test_ret += test_xmlXPathErr();
! 50757: test_ret += test_xmlXPathEvalExpr();
! 50758: test_ret += test_xmlXPathEvaluatePredicateResult();
! 50759: test_ret += test_xmlXPathFalseFunction();
! 50760: test_ret += test_xmlXPathFloorFunction();
! 50761: test_ret += test_xmlXPathFunctionLookup();
! 50762: test_ret += test_xmlXPathFunctionLookupNS();
! 50763: test_ret += test_xmlXPathHasSameNodes();
! 50764: test_ret += test_xmlXPathIdFunction();
! 50765: test_ret += test_xmlXPathIntersection();
! 50766: test_ret += test_xmlXPathIsNodeType();
! 50767: test_ret += test_xmlXPathLangFunction();
! 50768: test_ret += test_xmlXPathLastFunction();
! 50769: test_ret += test_xmlXPathLeading();
! 50770: test_ret += test_xmlXPathLeadingSorted();
! 50771: test_ret += test_xmlXPathLocalNameFunction();
! 50772: test_ret += test_xmlXPathModValues();
! 50773: test_ret += test_xmlXPathMultValues();
! 50774: test_ret += test_xmlXPathNamespaceURIFunction();
! 50775: test_ret += test_xmlXPathNewBoolean();
! 50776: test_ret += test_xmlXPathNewCString();
! 50777: test_ret += test_xmlXPathNewFloat();
! 50778: test_ret += test_xmlXPathNewNodeSet();
! 50779: test_ret += test_xmlXPathNewNodeSetList();
! 50780: test_ret += test_xmlXPathNewParserContext();
! 50781: test_ret += test_xmlXPathNewString();
! 50782: test_ret += test_xmlXPathNextAncestor();
! 50783: test_ret += test_xmlXPathNextAncestorOrSelf();
! 50784: test_ret += test_xmlXPathNextAttribute();
! 50785: test_ret += test_xmlXPathNextChild();
! 50786: test_ret += test_xmlXPathNextDescendant();
! 50787: test_ret += test_xmlXPathNextDescendantOrSelf();
! 50788: test_ret += test_xmlXPathNextFollowing();
! 50789: test_ret += test_xmlXPathNextFollowingSibling();
! 50790: test_ret += test_xmlXPathNextNamespace();
! 50791: test_ret += test_xmlXPathNextParent();
! 50792: test_ret += test_xmlXPathNextPreceding();
! 50793: test_ret += test_xmlXPathNextPrecedingSibling();
! 50794: test_ret += test_xmlXPathNextSelf();
! 50795: test_ret += test_xmlXPathNodeLeading();
! 50796: test_ret += test_xmlXPathNodeLeadingSorted();
! 50797: test_ret += test_xmlXPathNodeSetAdd();
! 50798: test_ret += test_xmlXPathNodeSetAddNs();
! 50799: test_ret += test_xmlXPathNodeSetAddUnique();
! 50800: test_ret += test_xmlXPathNodeSetContains();
! 50801: test_ret += test_xmlXPathNodeSetDel();
! 50802: test_ret += test_xmlXPathNodeSetMerge();
! 50803: test_ret += test_xmlXPathNodeSetRemove();
! 50804: test_ret += test_xmlXPathNodeSetSort();
! 50805: test_ret += test_xmlXPathNodeTrailing();
! 50806: test_ret += test_xmlXPathNodeTrailingSorted();
! 50807: test_ret += test_xmlXPathNormalizeFunction();
! 50808: test_ret += test_xmlXPathNotEqualValues();
! 50809: test_ret += test_xmlXPathNotFunction();
! 50810: test_ret += test_xmlXPathNsLookup();
! 50811: test_ret += test_xmlXPathNumberFunction();
! 50812: test_ret += test_xmlXPathParseNCName();
! 50813: test_ret += test_xmlXPathParseName();
! 50814: test_ret += test_xmlXPathPopBoolean();
! 50815: test_ret += test_xmlXPathPopExternal();
! 50816: test_ret += test_xmlXPathPopNodeSet();
! 50817: test_ret += test_xmlXPathPopNumber();
! 50818: test_ret += test_xmlXPathPopString();
! 50819: test_ret += test_xmlXPathPositionFunction();
! 50820: test_ret += test_xmlXPathRegisterAllFunctions();
! 50821: test_ret += test_xmlXPathRegisterFunc();
! 50822: test_ret += test_xmlXPathRegisterFuncLookup();
! 50823: test_ret += test_xmlXPathRegisterFuncNS();
! 50824: test_ret += test_xmlXPathRegisterNs();
! 50825: test_ret += test_xmlXPathRegisterVariable();
! 50826: test_ret += test_xmlXPathRegisterVariableLookup();
! 50827: test_ret += test_xmlXPathRegisterVariableNS();
! 50828: test_ret += test_xmlXPathRegisteredFuncsCleanup();
! 50829: test_ret += test_xmlXPathRegisteredNsCleanup();
! 50830: test_ret += test_xmlXPathRegisteredVariablesCleanup();
! 50831: test_ret += test_xmlXPathRoot();
! 50832: test_ret += test_xmlXPathRoundFunction();
! 50833: test_ret += test_xmlXPathStartsWithFunction();
! 50834: test_ret += test_xmlXPathStringEvalNumber();
! 50835: test_ret += test_xmlXPathStringFunction();
! 50836: test_ret += test_xmlXPathStringLengthFunction();
! 50837: test_ret += test_xmlXPathSubValues();
! 50838: test_ret += test_xmlXPathSubstringAfterFunction();
! 50839: test_ret += test_xmlXPathSubstringBeforeFunction();
! 50840: test_ret += test_xmlXPathSubstringFunction();
! 50841: test_ret += test_xmlXPathSumFunction();
! 50842: test_ret += test_xmlXPathTrailing();
! 50843: test_ret += test_xmlXPathTrailingSorted();
! 50844: test_ret += test_xmlXPathTranslateFunction();
! 50845: test_ret += test_xmlXPathTrueFunction();
! 50846: test_ret += test_xmlXPathValueFlipSign();
! 50847: test_ret += test_xmlXPathVariableLookup();
! 50848: test_ret += test_xmlXPathVariableLookupNS();
! 50849: test_ret += test_xmlXPathWrapCString();
! 50850: test_ret += test_xmlXPathWrapExternal();
! 50851: test_ret += test_xmlXPathWrapNodeSet();
! 50852: test_ret += test_xmlXPatherror();
! 50853:
! 50854: if (test_ret != 0)
! 50855: printf("Module xpathInternals: %d errors\n", test_ret);
! 50856: return(test_ret);
! 50857: }
! 50858:
! 50859: static int
! 50860: test_xmlXPtrBuildNodeList(void) {
! 50861: int test_ret = 0;
! 50862:
! 50863: #if defined(LIBXML_XPTR_ENABLED)
! 50864: int mem_base;
! 50865: xmlNodePtr ret_val;
! 50866: xmlXPathObjectPtr obj; /* the XPointer result from the evaluation. */
! 50867: int n_obj;
! 50868:
! 50869: for (n_obj = 0;n_obj < gen_nb_xmlXPathObjectPtr;n_obj++) {
! 50870: mem_base = xmlMemBlocks();
! 50871: obj = gen_xmlXPathObjectPtr(n_obj, 0);
! 50872:
! 50873: ret_val = xmlXPtrBuildNodeList(obj);
! 50874: desret_xmlNodePtr(ret_val);
! 50875: call_tests++;
! 50876: des_xmlXPathObjectPtr(n_obj, obj, 0);
! 50877: xmlResetLastError();
! 50878: if (mem_base != xmlMemBlocks()) {
! 50879: printf("Leak of %d blocks found in xmlXPtrBuildNodeList",
! 50880: xmlMemBlocks() - mem_base);
! 50881: test_ret++;
! 50882: printf(" %d", n_obj);
! 50883: printf("\n");
! 50884: }
! 50885: }
! 50886: function_tests++;
! 50887: #endif
! 50888:
! 50889: return(test_ret);
! 50890: }
! 50891:
! 50892:
! 50893: static int
! 50894: test_xmlXPtrEval(void) {
! 50895: int test_ret = 0;
! 50896:
! 50897: #if defined(LIBXML_XPTR_ENABLED)
! 50898: int mem_base;
! 50899: xmlXPathObjectPtr ret_val;
! 50900: xmlChar * str; /* the XPointer expression */
! 50901: int n_str;
! 50902: xmlXPathContextPtr ctx; /* the XPointer context */
! 50903: int n_ctx;
! 50904:
! 50905: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 50906: for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
! 50907: mem_base = xmlMemBlocks();
! 50908: str = gen_const_xmlChar_ptr(n_str, 0);
! 50909: ctx = gen_xmlXPathContextPtr(n_ctx, 1);
! 50910:
! 50911: ret_val = xmlXPtrEval((const xmlChar *)str, ctx);
! 50912: desret_xmlXPathObjectPtr(ret_val);
! 50913: call_tests++;
! 50914: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
! 50915: des_xmlXPathContextPtr(n_ctx, ctx, 1);
! 50916: xmlResetLastError();
! 50917: if (mem_base != xmlMemBlocks()) {
! 50918: printf("Leak of %d blocks found in xmlXPtrEval",
! 50919: xmlMemBlocks() - mem_base);
! 50920: test_ret++;
! 50921: printf(" %d", n_str);
! 50922: printf(" %d", n_ctx);
! 50923: printf("\n");
! 50924: }
! 50925: }
! 50926: }
! 50927: function_tests++;
! 50928: #endif
! 50929:
! 50930: return(test_ret);
! 50931: }
! 50932:
! 50933:
! 50934: static int
! 50935: test_xmlXPtrEvalRangePredicate(void) {
! 50936: int test_ret = 0;
! 50937:
! 50938: #if defined(LIBXML_XPTR_ENABLED)
! 50939: int mem_base;
! 50940: xmlXPathParserContextPtr ctxt; /* the XPointer Parser context */
! 50941: int n_ctxt;
! 50942:
! 50943: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 50944: mem_base = xmlMemBlocks();
! 50945: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 50946:
! 50947: xmlXPtrEvalRangePredicate(ctxt);
! 50948: call_tests++;
! 50949: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 50950: xmlResetLastError();
! 50951: if (mem_base != xmlMemBlocks()) {
! 50952: printf("Leak of %d blocks found in xmlXPtrEvalRangePredicate",
! 50953: xmlMemBlocks() - mem_base);
! 50954: test_ret++;
! 50955: printf(" %d", n_ctxt);
! 50956: printf("\n");
! 50957: }
! 50958: }
! 50959: function_tests++;
! 50960: #endif
! 50961:
! 50962: return(test_ret);
! 50963: }
! 50964:
! 50965: #ifdef LIBXML_XPTR_ENABLED
! 50966:
! 50967: #define gen_nb_xmlLocationSetPtr 1
! 50968: static xmlLocationSetPtr gen_xmlLocationSetPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 50969: return(NULL);
! 50970: }
! 50971: static void des_xmlLocationSetPtr(int no ATTRIBUTE_UNUSED, xmlLocationSetPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 50972: }
! 50973: #endif
! 50974:
! 50975:
! 50976: static int
! 50977: test_xmlXPtrLocationSetAdd(void) {
! 50978: int test_ret = 0;
! 50979:
! 50980: #if defined(LIBXML_XPTR_ENABLED)
! 50981: int mem_base;
! 50982: xmlLocationSetPtr cur; /* the initial range set */
! 50983: int n_cur;
! 50984: xmlXPathObjectPtr val; /* a new xmlXPathObjectPtr */
! 50985: int n_val;
! 50986:
! 50987: for (n_cur = 0;n_cur < gen_nb_xmlLocationSetPtr;n_cur++) {
! 50988: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
! 50989: mem_base = xmlMemBlocks();
! 50990: cur = gen_xmlLocationSetPtr(n_cur, 0);
! 50991: val = gen_xmlXPathObjectPtr(n_val, 1);
! 50992:
! 50993: xmlXPtrLocationSetAdd(cur, val);
! 50994: call_tests++;
! 50995: des_xmlLocationSetPtr(n_cur, cur, 0);
! 50996: des_xmlXPathObjectPtr(n_val, val, 1);
! 50997: xmlResetLastError();
! 50998: if (mem_base != xmlMemBlocks()) {
! 50999: printf("Leak of %d blocks found in xmlXPtrLocationSetAdd",
! 51000: xmlMemBlocks() - mem_base);
! 51001: test_ret++;
! 51002: printf(" %d", n_cur);
! 51003: printf(" %d", n_val);
! 51004: printf("\n");
! 51005: }
! 51006: }
! 51007: }
! 51008: function_tests++;
! 51009: #endif
! 51010:
! 51011: return(test_ret);
! 51012: }
! 51013:
! 51014:
! 51015: static int
! 51016: test_xmlXPtrLocationSetCreate(void) {
! 51017: int test_ret = 0;
! 51018:
! 51019:
! 51020: /* missing type support */
! 51021: return(test_ret);
! 51022: }
! 51023:
! 51024:
! 51025: static int
! 51026: test_xmlXPtrLocationSetDel(void) {
! 51027: int test_ret = 0;
! 51028:
! 51029: #if defined(LIBXML_XPTR_ENABLED)
! 51030: int mem_base;
! 51031: xmlLocationSetPtr cur; /* the initial range set */
! 51032: int n_cur;
! 51033: xmlXPathObjectPtr val; /* an xmlXPathObjectPtr */
! 51034: int n_val;
! 51035:
! 51036: for (n_cur = 0;n_cur < gen_nb_xmlLocationSetPtr;n_cur++) {
! 51037: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
! 51038: mem_base = xmlMemBlocks();
! 51039: cur = gen_xmlLocationSetPtr(n_cur, 0);
! 51040: val = gen_xmlXPathObjectPtr(n_val, 1);
! 51041:
! 51042: xmlXPtrLocationSetDel(cur, val);
! 51043: call_tests++;
! 51044: des_xmlLocationSetPtr(n_cur, cur, 0);
! 51045: des_xmlXPathObjectPtr(n_val, val, 1);
! 51046: xmlResetLastError();
! 51047: if (mem_base != xmlMemBlocks()) {
! 51048: printf("Leak of %d blocks found in xmlXPtrLocationSetDel",
! 51049: xmlMemBlocks() - mem_base);
! 51050: test_ret++;
! 51051: printf(" %d", n_cur);
! 51052: printf(" %d", n_val);
! 51053: printf("\n");
! 51054: }
! 51055: }
! 51056: }
! 51057: function_tests++;
! 51058: #endif
! 51059:
! 51060: return(test_ret);
! 51061: }
! 51062:
! 51063:
! 51064: static int
! 51065: test_xmlXPtrLocationSetMerge(void) {
! 51066: int test_ret = 0;
! 51067:
! 51068:
! 51069: /* missing type support */
! 51070: return(test_ret);
! 51071: }
! 51072:
! 51073:
! 51074: static int
! 51075: test_xmlXPtrLocationSetRemove(void) {
! 51076: int test_ret = 0;
! 51077:
! 51078: #if defined(LIBXML_XPTR_ENABLED)
! 51079: int mem_base;
! 51080: xmlLocationSetPtr cur; /* the initial range set */
! 51081: int n_cur;
! 51082: int val; /* the index to remove */
! 51083: int n_val;
! 51084:
! 51085: for (n_cur = 0;n_cur < gen_nb_xmlLocationSetPtr;n_cur++) {
! 51086: for (n_val = 0;n_val < gen_nb_int;n_val++) {
! 51087: mem_base = xmlMemBlocks();
! 51088: cur = gen_xmlLocationSetPtr(n_cur, 0);
! 51089: val = gen_int(n_val, 1);
! 51090:
! 51091: xmlXPtrLocationSetRemove(cur, val);
! 51092: call_tests++;
! 51093: des_xmlLocationSetPtr(n_cur, cur, 0);
! 51094: des_int(n_val, val, 1);
! 51095: xmlResetLastError();
! 51096: if (mem_base != xmlMemBlocks()) {
! 51097: printf("Leak of %d blocks found in xmlXPtrLocationSetRemove",
! 51098: xmlMemBlocks() - mem_base);
! 51099: test_ret++;
! 51100: printf(" %d", n_cur);
! 51101: printf(" %d", n_val);
! 51102: printf("\n");
! 51103: }
! 51104: }
! 51105: }
! 51106: function_tests++;
! 51107: #endif
! 51108:
! 51109: return(test_ret);
! 51110: }
! 51111:
! 51112:
! 51113: static int
! 51114: test_xmlXPtrNewCollapsedRange(void) {
! 51115: int test_ret = 0;
! 51116:
! 51117: #if defined(LIBXML_XPTR_ENABLED)
! 51118: int mem_base;
! 51119: xmlXPathObjectPtr ret_val;
! 51120: xmlNodePtr start; /* the starting and ending node */
! 51121: int n_start;
! 51122:
! 51123: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
! 51124: mem_base = xmlMemBlocks();
! 51125: start = gen_xmlNodePtr(n_start, 0);
! 51126:
! 51127: ret_val = xmlXPtrNewCollapsedRange(start);
! 51128: desret_xmlXPathObjectPtr(ret_val);
! 51129: call_tests++;
! 51130: des_xmlNodePtr(n_start, start, 0);
! 51131: xmlResetLastError();
! 51132: if (mem_base != xmlMemBlocks()) {
! 51133: printf("Leak of %d blocks found in xmlXPtrNewCollapsedRange",
! 51134: xmlMemBlocks() - mem_base);
! 51135: test_ret++;
! 51136: printf(" %d", n_start);
! 51137: printf("\n");
! 51138: }
! 51139: }
! 51140: function_tests++;
! 51141: #endif
! 51142:
! 51143: return(test_ret);
! 51144: }
! 51145:
! 51146:
! 51147: static int
! 51148: test_xmlXPtrNewContext(void) {
! 51149: int test_ret = 0;
! 51150:
! 51151:
! 51152: /* missing type support */
! 51153: return(test_ret);
! 51154: }
! 51155:
! 51156:
! 51157: static int
! 51158: test_xmlXPtrNewLocationSetNodeSet(void) {
! 51159: int test_ret = 0;
! 51160:
! 51161: #if defined(LIBXML_XPTR_ENABLED)
! 51162: int mem_base;
! 51163: xmlXPathObjectPtr ret_val;
! 51164: xmlNodeSetPtr set; /* a node set */
! 51165: int n_set;
! 51166:
! 51167: for (n_set = 0;n_set < gen_nb_xmlNodeSetPtr;n_set++) {
! 51168: mem_base = xmlMemBlocks();
! 51169: set = gen_xmlNodeSetPtr(n_set, 0);
! 51170:
! 51171: ret_val = xmlXPtrNewLocationSetNodeSet(set);
! 51172: desret_xmlXPathObjectPtr(ret_val);
! 51173: call_tests++;
! 51174: des_xmlNodeSetPtr(n_set, set, 0);
! 51175: xmlResetLastError();
! 51176: if (mem_base != xmlMemBlocks()) {
! 51177: printf("Leak of %d blocks found in xmlXPtrNewLocationSetNodeSet",
! 51178: xmlMemBlocks() - mem_base);
! 51179: test_ret++;
! 51180: printf(" %d", n_set);
! 51181: printf("\n");
! 51182: }
! 51183: }
! 51184: function_tests++;
! 51185: #endif
! 51186:
! 51187: return(test_ret);
! 51188: }
! 51189:
! 51190:
! 51191: static int
! 51192: test_xmlXPtrNewLocationSetNodes(void) {
! 51193: int test_ret = 0;
! 51194:
! 51195: #if defined(LIBXML_XPTR_ENABLED)
! 51196: int mem_base;
! 51197: xmlXPathObjectPtr ret_val;
! 51198: xmlNodePtr start; /* the start NodePtr value */
! 51199: int n_start;
! 51200: xmlNodePtr end; /* the end NodePtr value or NULL */
! 51201: int n_end;
! 51202:
! 51203: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
! 51204: for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
! 51205: mem_base = xmlMemBlocks();
! 51206: start = gen_xmlNodePtr(n_start, 0);
! 51207: end = gen_xmlNodePtr(n_end, 1);
! 51208:
! 51209: ret_val = xmlXPtrNewLocationSetNodes(start, end);
! 51210: desret_xmlXPathObjectPtr(ret_val);
! 51211: call_tests++;
! 51212: des_xmlNodePtr(n_start, start, 0);
! 51213: des_xmlNodePtr(n_end, end, 1);
! 51214: xmlResetLastError();
! 51215: if (mem_base != xmlMemBlocks()) {
! 51216: printf("Leak of %d blocks found in xmlXPtrNewLocationSetNodes",
! 51217: xmlMemBlocks() - mem_base);
! 51218: test_ret++;
! 51219: printf(" %d", n_start);
! 51220: printf(" %d", n_end);
! 51221: printf("\n");
! 51222: }
! 51223: }
! 51224: }
! 51225: function_tests++;
! 51226: #endif
! 51227:
! 51228: return(test_ret);
! 51229: }
! 51230:
! 51231:
! 51232: static int
! 51233: test_xmlXPtrNewRange(void) {
! 51234: int test_ret = 0;
! 51235:
! 51236: #if defined(LIBXML_XPTR_ENABLED)
! 51237: int mem_base;
! 51238: xmlXPathObjectPtr ret_val;
! 51239: xmlNodePtr start; /* the starting node */
! 51240: int n_start;
! 51241: int startindex; /* the start index */
! 51242: int n_startindex;
! 51243: xmlNodePtr end; /* the ending point */
! 51244: int n_end;
! 51245: int endindex; /* the ending index */
! 51246: int n_endindex;
! 51247:
! 51248: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
! 51249: for (n_startindex = 0;n_startindex < gen_nb_int;n_startindex++) {
! 51250: for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
! 51251: for (n_endindex = 0;n_endindex < gen_nb_int;n_endindex++) {
! 51252: mem_base = xmlMemBlocks();
! 51253: start = gen_xmlNodePtr(n_start, 0);
! 51254: startindex = gen_int(n_startindex, 1);
! 51255: end = gen_xmlNodePtr(n_end, 2);
! 51256: endindex = gen_int(n_endindex, 3);
! 51257:
! 51258: ret_val = xmlXPtrNewRange(start, startindex, end, endindex);
! 51259: desret_xmlXPathObjectPtr(ret_val);
! 51260: call_tests++;
! 51261: des_xmlNodePtr(n_start, start, 0);
! 51262: des_int(n_startindex, startindex, 1);
! 51263: des_xmlNodePtr(n_end, end, 2);
! 51264: des_int(n_endindex, endindex, 3);
! 51265: xmlResetLastError();
! 51266: if (mem_base != xmlMemBlocks()) {
! 51267: printf("Leak of %d blocks found in xmlXPtrNewRange",
! 51268: xmlMemBlocks() - mem_base);
! 51269: test_ret++;
! 51270: printf(" %d", n_start);
! 51271: printf(" %d", n_startindex);
! 51272: printf(" %d", n_end);
! 51273: printf(" %d", n_endindex);
! 51274: printf("\n");
! 51275: }
! 51276: }
! 51277: }
! 51278: }
! 51279: }
! 51280: function_tests++;
! 51281: #endif
! 51282:
! 51283: return(test_ret);
! 51284: }
! 51285:
! 51286:
! 51287: static int
! 51288: test_xmlXPtrNewRangeNodeObject(void) {
! 51289: int test_ret = 0;
! 51290:
! 51291: #if defined(LIBXML_XPTR_ENABLED)
! 51292: int mem_base;
! 51293: xmlXPathObjectPtr ret_val;
! 51294: xmlNodePtr start; /* the starting node */
! 51295: int n_start;
! 51296: xmlXPathObjectPtr end; /* the ending object */
! 51297: int n_end;
! 51298:
! 51299: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
! 51300: for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) {
! 51301: mem_base = xmlMemBlocks();
! 51302: start = gen_xmlNodePtr(n_start, 0);
! 51303: end = gen_xmlXPathObjectPtr(n_end, 1);
! 51304:
! 51305: ret_val = xmlXPtrNewRangeNodeObject(start, end);
! 51306: desret_xmlXPathObjectPtr(ret_val);
! 51307: call_tests++;
! 51308: des_xmlNodePtr(n_start, start, 0);
! 51309: des_xmlXPathObjectPtr(n_end, end, 1);
! 51310: xmlResetLastError();
! 51311: if (mem_base != xmlMemBlocks()) {
! 51312: printf("Leak of %d blocks found in xmlXPtrNewRangeNodeObject",
! 51313: xmlMemBlocks() - mem_base);
! 51314: test_ret++;
! 51315: printf(" %d", n_start);
! 51316: printf(" %d", n_end);
! 51317: printf("\n");
! 51318: }
! 51319: }
! 51320: }
! 51321: function_tests++;
! 51322: #endif
! 51323:
! 51324: return(test_ret);
! 51325: }
! 51326:
! 51327:
! 51328: static int
! 51329: test_xmlXPtrNewRangeNodePoint(void) {
! 51330: int test_ret = 0;
! 51331:
! 51332: #if defined(LIBXML_XPTR_ENABLED)
! 51333: int mem_base;
! 51334: xmlXPathObjectPtr ret_val;
! 51335: xmlNodePtr start; /* the starting node */
! 51336: int n_start;
! 51337: xmlXPathObjectPtr end; /* the ending point */
! 51338: int n_end;
! 51339:
! 51340: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
! 51341: for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) {
! 51342: mem_base = xmlMemBlocks();
! 51343: start = gen_xmlNodePtr(n_start, 0);
! 51344: end = gen_xmlXPathObjectPtr(n_end, 1);
! 51345:
! 51346: ret_val = xmlXPtrNewRangeNodePoint(start, end);
! 51347: desret_xmlXPathObjectPtr(ret_val);
! 51348: call_tests++;
! 51349: des_xmlNodePtr(n_start, start, 0);
! 51350: des_xmlXPathObjectPtr(n_end, end, 1);
! 51351: xmlResetLastError();
! 51352: if (mem_base != xmlMemBlocks()) {
! 51353: printf("Leak of %d blocks found in xmlXPtrNewRangeNodePoint",
! 51354: xmlMemBlocks() - mem_base);
! 51355: test_ret++;
! 51356: printf(" %d", n_start);
! 51357: printf(" %d", n_end);
! 51358: printf("\n");
! 51359: }
! 51360: }
! 51361: }
! 51362: function_tests++;
! 51363: #endif
! 51364:
! 51365: return(test_ret);
! 51366: }
! 51367:
! 51368:
! 51369: static int
! 51370: test_xmlXPtrNewRangeNodes(void) {
! 51371: int test_ret = 0;
! 51372:
! 51373: #if defined(LIBXML_XPTR_ENABLED)
! 51374: int mem_base;
! 51375: xmlXPathObjectPtr ret_val;
! 51376: xmlNodePtr start; /* the starting node */
! 51377: int n_start;
! 51378: xmlNodePtr end; /* the ending node */
! 51379: int n_end;
! 51380:
! 51381: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
! 51382: for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
! 51383: mem_base = xmlMemBlocks();
! 51384: start = gen_xmlNodePtr(n_start, 0);
! 51385: end = gen_xmlNodePtr(n_end, 1);
! 51386:
! 51387: ret_val = xmlXPtrNewRangeNodes(start, end);
! 51388: desret_xmlXPathObjectPtr(ret_val);
! 51389: call_tests++;
! 51390: des_xmlNodePtr(n_start, start, 0);
! 51391: des_xmlNodePtr(n_end, end, 1);
! 51392: xmlResetLastError();
! 51393: if (mem_base != xmlMemBlocks()) {
! 51394: printf("Leak of %d blocks found in xmlXPtrNewRangeNodes",
! 51395: xmlMemBlocks() - mem_base);
! 51396: test_ret++;
! 51397: printf(" %d", n_start);
! 51398: printf(" %d", n_end);
! 51399: printf("\n");
! 51400: }
! 51401: }
! 51402: }
! 51403: function_tests++;
! 51404: #endif
! 51405:
! 51406: return(test_ret);
! 51407: }
! 51408:
! 51409:
! 51410: static int
! 51411: test_xmlXPtrNewRangePointNode(void) {
! 51412: int test_ret = 0;
! 51413:
! 51414: #if defined(LIBXML_XPTR_ENABLED)
! 51415: int mem_base;
! 51416: xmlXPathObjectPtr ret_val;
! 51417: xmlXPathObjectPtr start; /* the starting point */
! 51418: int n_start;
! 51419: xmlNodePtr end; /* the ending node */
! 51420: int n_end;
! 51421:
! 51422: for (n_start = 0;n_start < gen_nb_xmlXPathObjectPtr;n_start++) {
! 51423: for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
! 51424: mem_base = xmlMemBlocks();
! 51425: start = gen_xmlXPathObjectPtr(n_start, 0);
! 51426: end = gen_xmlNodePtr(n_end, 1);
! 51427:
! 51428: ret_val = xmlXPtrNewRangePointNode(start, end);
! 51429: desret_xmlXPathObjectPtr(ret_val);
! 51430: call_tests++;
! 51431: des_xmlXPathObjectPtr(n_start, start, 0);
! 51432: des_xmlNodePtr(n_end, end, 1);
! 51433: xmlResetLastError();
! 51434: if (mem_base != xmlMemBlocks()) {
! 51435: printf("Leak of %d blocks found in xmlXPtrNewRangePointNode",
! 51436: xmlMemBlocks() - mem_base);
! 51437: test_ret++;
! 51438: printf(" %d", n_start);
! 51439: printf(" %d", n_end);
! 51440: printf("\n");
! 51441: }
! 51442: }
! 51443: }
! 51444: function_tests++;
! 51445: #endif
! 51446:
! 51447: return(test_ret);
! 51448: }
! 51449:
! 51450:
! 51451: static int
! 51452: test_xmlXPtrNewRangePoints(void) {
! 51453: int test_ret = 0;
! 51454:
! 51455: #if defined(LIBXML_XPTR_ENABLED)
! 51456: int mem_base;
! 51457: xmlXPathObjectPtr ret_val;
! 51458: xmlXPathObjectPtr start; /* the starting point */
! 51459: int n_start;
! 51460: xmlXPathObjectPtr end; /* the ending point */
! 51461: int n_end;
! 51462:
! 51463: for (n_start = 0;n_start < gen_nb_xmlXPathObjectPtr;n_start++) {
! 51464: for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) {
! 51465: mem_base = xmlMemBlocks();
! 51466: start = gen_xmlXPathObjectPtr(n_start, 0);
! 51467: end = gen_xmlXPathObjectPtr(n_end, 1);
! 51468:
! 51469: ret_val = xmlXPtrNewRangePoints(start, end);
! 51470: desret_xmlXPathObjectPtr(ret_val);
! 51471: call_tests++;
! 51472: des_xmlXPathObjectPtr(n_start, start, 0);
! 51473: des_xmlXPathObjectPtr(n_end, end, 1);
! 51474: xmlResetLastError();
! 51475: if (mem_base != xmlMemBlocks()) {
! 51476: printf("Leak of %d blocks found in xmlXPtrNewRangePoints",
! 51477: xmlMemBlocks() - mem_base);
! 51478: test_ret++;
! 51479: printf(" %d", n_start);
! 51480: printf(" %d", n_end);
! 51481: printf("\n");
! 51482: }
! 51483: }
! 51484: }
! 51485: function_tests++;
! 51486: #endif
! 51487:
! 51488: return(test_ret);
! 51489: }
! 51490:
! 51491:
! 51492: static int
! 51493: test_xmlXPtrRangeToFunction(void) {
! 51494: int test_ret = 0;
! 51495:
! 51496: #if defined(LIBXML_XPTR_ENABLED)
! 51497: int mem_base;
! 51498: xmlXPathParserContextPtr ctxt; /* the XPointer Parser context */
! 51499: int n_ctxt;
! 51500: int nargs; /* the number of args */
! 51501: int n_nargs;
! 51502:
! 51503: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
! 51504: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
! 51505: mem_base = xmlMemBlocks();
! 51506: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
! 51507: nargs = gen_int(n_nargs, 1);
! 51508:
! 51509: xmlXPtrRangeToFunction(ctxt, nargs);
! 51510: call_tests++;
! 51511: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
! 51512: des_int(n_nargs, nargs, 1);
! 51513: xmlResetLastError();
! 51514: if (mem_base != xmlMemBlocks()) {
! 51515: printf("Leak of %d blocks found in xmlXPtrRangeToFunction",
! 51516: xmlMemBlocks() - mem_base);
! 51517: test_ret++;
! 51518: printf(" %d", n_ctxt);
! 51519: printf(" %d", n_nargs);
! 51520: printf("\n");
! 51521: }
! 51522: }
! 51523: }
! 51524: function_tests++;
! 51525: #endif
! 51526:
! 51527: return(test_ret);
! 51528: }
! 51529:
! 51530:
! 51531: static int
! 51532: test_xmlXPtrWrapLocationSet(void) {
! 51533: int test_ret = 0;
! 51534:
! 51535: #if defined(LIBXML_XPTR_ENABLED)
! 51536: int mem_base;
! 51537: xmlXPathObjectPtr ret_val;
! 51538: xmlLocationSetPtr val; /* the LocationSet value */
! 51539: int n_val;
! 51540:
! 51541: for (n_val = 0;n_val < gen_nb_xmlLocationSetPtr;n_val++) {
! 51542: mem_base = xmlMemBlocks();
! 51543: val = gen_xmlLocationSetPtr(n_val, 0);
! 51544:
! 51545: ret_val = xmlXPtrWrapLocationSet(val);
! 51546: desret_xmlXPathObjectPtr(ret_val);
! 51547: call_tests++;
! 51548: des_xmlLocationSetPtr(n_val, val, 0);
! 51549: xmlResetLastError();
! 51550: if (mem_base != xmlMemBlocks()) {
! 51551: printf("Leak of %d blocks found in xmlXPtrWrapLocationSet",
! 51552: xmlMemBlocks() - mem_base);
! 51553: test_ret++;
! 51554: printf(" %d", n_val);
! 51555: printf("\n");
! 51556: }
! 51557: }
! 51558: function_tests++;
! 51559: #endif
! 51560:
! 51561: return(test_ret);
! 51562: }
! 51563:
! 51564: static int
! 51565: test_xpointer(void) {
! 51566: int test_ret = 0;
! 51567:
! 51568: if (quiet == 0) printf("Testing xpointer : 17 of 21 functions ...\n");
! 51569: test_ret += test_xmlXPtrBuildNodeList();
! 51570: test_ret += test_xmlXPtrEval();
! 51571: test_ret += test_xmlXPtrEvalRangePredicate();
! 51572: test_ret += test_xmlXPtrLocationSetAdd();
! 51573: test_ret += test_xmlXPtrLocationSetCreate();
! 51574: test_ret += test_xmlXPtrLocationSetDel();
! 51575: test_ret += test_xmlXPtrLocationSetMerge();
! 51576: test_ret += test_xmlXPtrLocationSetRemove();
! 51577: test_ret += test_xmlXPtrNewCollapsedRange();
! 51578: test_ret += test_xmlXPtrNewContext();
! 51579: test_ret += test_xmlXPtrNewLocationSetNodeSet();
! 51580: test_ret += test_xmlXPtrNewLocationSetNodes();
! 51581: test_ret += test_xmlXPtrNewRange();
! 51582: test_ret += test_xmlXPtrNewRangeNodeObject();
! 51583: test_ret += test_xmlXPtrNewRangeNodePoint();
! 51584: test_ret += test_xmlXPtrNewRangeNodes();
! 51585: test_ret += test_xmlXPtrNewRangePointNode();
! 51586: test_ret += test_xmlXPtrNewRangePoints();
! 51587: test_ret += test_xmlXPtrRangeToFunction();
! 51588: test_ret += test_xmlXPtrWrapLocationSet();
! 51589:
! 51590: if (test_ret != 0)
! 51591: printf("Module xpointer: %d errors\n", test_ret);
! 51592: return(test_ret);
! 51593: }
! 51594: static int
! 51595: test_module(const char *module) {
! 51596: if (!strcmp(module, "HTMLparser")) return(test_HTMLparser());
! 51597: if (!strcmp(module, "HTMLtree")) return(test_HTMLtree());
! 51598: if (!strcmp(module, "SAX2")) return(test_SAX2());
! 51599: if (!strcmp(module, "c14n")) return(test_c14n());
! 51600: if (!strcmp(module, "catalog")) return(test_catalog());
! 51601: if (!strcmp(module, "chvalid")) return(test_chvalid());
! 51602: if (!strcmp(module, "debugXML")) return(test_debugXML());
! 51603: if (!strcmp(module, "dict")) return(test_dict());
! 51604: if (!strcmp(module, "encoding")) return(test_encoding());
! 51605: if (!strcmp(module, "entities")) return(test_entities());
! 51606: if (!strcmp(module, "hash")) return(test_hash());
! 51607: if (!strcmp(module, "list")) return(test_list());
! 51608: if (!strcmp(module, "nanoftp")) return(test_nanoftp());
! 51609: if (!strcmp(module, "nanohttp")) return(test_nanohttp());
! 51610: if (!strcmp(module, "parser")) return(test_parser());
! 51611: if (!strcmp(module, "parserInternals")) return(test_parserInternals());
! 51612: if (!strcmp(module, "pattern")) return(test_pattern());
! 51613: if (!strcmp(module, "relaxng")) return(test_relaxng());
! 51614: if (!strcmp(module, "schemasInternals")) return(test_schemasInternals());
! 51615: if (!strcmp(module, "schematron")) return(test_schematron());
! 51616: if (!strcmp(module, "tree")) return(test_tree());
! 51617: if (!strcmp(module, "uri")) return(test_uri());
! 51618: if (!strcmp(module, "valid")) return(test_valid());
! 51619: if (!strcmp(module, "xinclude")) return(test_xinclude());
! 51620: if (!strcmp(module, "xmlIO")) return(test_xmlIO());
! 51621: if (!strcmp(module, "xmlautomata")) return(test_xmlautomata());
! 51622: if (!strcmp(module, "xmlerror")) return(test_xmlerror());
! 51623: if (!strcmp(module, "xmlmodule")) return(test_xmlmodule());
! 51624: if (!strcmp(module, "xmlreader")) return(test_xmlreader());
! 51625: if (!strcmp(module, "xmlregexp")) return(test_xmlregexp());
! 51626: if (!strcmp(module, "xmlsave")) return(test_xmlsave());
! 51627: if (!strcmp(module, "xmlschemas")) return(test_xmlschemas());
! 51628: if (!strcmp(module, "xmlschemastypes")) return(test_xmlschemastypes());
! 51629: if (!strcmp(module, "xmlstring")) return(test_xmlstring());
! 51630: if (!strcmp(module, "xmlunicode")) return(test_xmlunicode());
! 51631: if (!strcmp(module, "xmlwriter")) return(test_xmlwriter());
! 51632: if (!strcmp(module, "xpath")) return(test_xpath());
! 51633: if (!strcmp(module, "xpathInternals")) return(test_xpathInternals());
! 51634: if (!strcmp(module, "xpointer")) return(test_xpointer());
! 51635: return(0);
! 51636: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to testapi.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2