Annotation of embedaddon/libxml2/testlimits.c, revision 1.1
1.1 ! misho 1: /*
! 2: * testlimits.c: C program to run libxml2 regression tests checking various
! 3: * limits in document size. Will consume a lot of RAM and CPU cycles
! 4: *
! 5: * To compile on Unixes:
! 6: * cc -o testlimits `xml2-config --cflags` testlimits.c `xml2-config --libs` -lpthread
! 7: *
! 8: * See Copyright for the status of this software.
! 9: *
! 10: * daniel@veillard.com
! 11: */
! 12:
! 13: #ifdef HAVE_CONFIG_H
! 14: #include "libxml.h"
! 15: #else
! 16: #include <stdio.h>
! 17: #endif
! 18:
! 19: #if !defined(_WIN32) || defined(__CYGWIN__)
! 20: #include <unistd.h>
! 21: #endif
! 22: #include <string.h>
! 23: #include <sys/types.h>
! 24: #include <sys/stat.h>
! 25: #include <fcntl.h>
! 26: #include <time.h>
! 27:
! 28: #include <libxml/parser.h>
! 29: #include <libxml/parserInternals.h>
! 30: #include <libxml/tree.h>
! 31: #include <libxml/uri.h>
! 32: #ifdef LIBXML_READER_ENABLED
! 33: #include <libxml/xmlreader.h>
! 34: #endif
! 35:
! 36: static int verbose = 0;
! 37: static int tests_quiet = 0;
! 38:
! 39: /************************************************************************
! 40: * *
! 41: * time handling *
! 42: * *
! 43: ************************************************************************/
! 44:
! 45: /* maximum time for one parsing before declaring a timeout */
! 46: #define MAX_TIME 2 /* seconds */
! 47:
! 48: static clock_t t0;
! 49: int timeout = 0;
! 50:
! 51: static void reset_timout(void) {
! 52: timeout = 0;
! 53: t0 = clock();
! 54: }
! 55:
! 56: static int check_time(void) {
! 57: clock_t tnow = clock();
! 58: if (((tnow - t0) / CLOCKS_PER_SEC) > MAX_TIME) {
! 59: timeout = 1;
! 60: return(0);
! 61: }
! 62: return(1);
! 63: }
! 64:
! 65: /************************************************************************
! 66: * *
! 67: * Huge document generator *
! 68: * *
! 69: ************************************************************************/
! 70:
! 71: #include <libxml/xmlIO.h>
! 72:
! 73: /*
! 74: * Huge documents are built using fixed start and end chunks
! 75: * and filling between the two an unconventional amount of char data
! 76: */
! 77: typedef struct hugeTest hugeTest;
! 78: typedef hugeTest *hugeTestPtr;
! 79: struct hugeTest {
! 80: const char *description;
! 81: const char *name;
! 82: const char *start;
! 83: const char *end;
! 84: };
! 85:
! 86: static struct hugeTest hugeTests[] = {
! 87: { "Huge text node", "huge:textNode", "<foo>", "</foo>" },
! 88: { "Huge attribute node", "huge:attrNode", "<foo bar='", "'/>" },
! 89: { "Huge comment node", "huge:commentNode", "<foo><!--", "--></foo>" },
! 90: { "Huge PI node", "huge:piNode", "<foo><?bar ", "?></foo>" },
! 91: };
! 92:
! 93: static const char *current;
! 94: static int rlen;
! 95: static unsigned int currentTest = 0;
! 96: static int instate = 0;
! 97:
! 98: /**
! 99: * hugeMatch:
! 100: * @URI: an URI to test
! 101: *
! 102: * Check for an huge: query
! 103: *
! 104: * Returns 1 if yes and 0 if another Input module should be used
! 105: */
! 106: static int
! 107: hugeMatch(const char * URI) {
! 108: if ((URI != NULL) && (!strncmp(URI, "huge:", 5)))
! 109: return(1);
! 110: return(0);
! 111: }
! 112:
! 113: /**
! 114: * hugeOpen:
! 115: * @URI: an URI to test
! 116: *
! 117: * Return a pointer to the huge: query handler, in this example simply
! 118: * the current pointer...
! 119: *
! 120: * Returns an Input context or NULL in case or error
! 121: */
! 122: static void *
! 123: hugeOpen(const char * URI) {
! 124: if ((URI == NULL) || (strncmp(URI, "huge:", 5)))
! 125: return(NULL);
! 126:
! 127: for (currentTest = 0;currentTest < sizeof(hugeTests)/sizeof(hugeTests[0]);
! 128: currentTest++)
! 129: if (!strcmp(hugeTests[currentTest].name, URI))
! 130: goto found;
! 131:
! 132: return(NULL);
! 133:
! 134: found:
! 135: rlen = strlen(hugeTests[currentTest].start);
! 136: current = hugeTests[currentTest].start;
! 137: instate = 0;
! 138: return((void *) current);
! 139: }
! 140:
! 141: /**
! 142: * hugeClose:
! 143: * @context: the read context
! 144: *
! 145: * Close the huge: query handler
! 146: *
! 147: * Returns 0 or -1 in case of error
! 148: */
! 149: static int
! 150: hugeClose(void * context) {
! 151: if (context == NULL) return(-1);
! 152: fprintf(stderr, "\n");
! 153: return(0);
! 154: }
! 155:
! 156: #define CHUNK 4096
! 157:
! 158: char filling[CHUNK + 1];
! 159:
! 160: static void fillFilling(void) {
! 161: int i;
! 162:
! 163: for (i = 0;i < CHUNK;i++) {
! 164: filling[i] = 'a';
! 165: }
! 166: filling[CHUNK] = 0;
! 167: }
! 168:
! 169: size_t maxlen = 64 * 1024 * 1024;
! 170: size_t curlen = 0;
! 171: size_t dotlen;
! 172:
! 173: /**
! 174: * hugeRead:
! 175: * @context: the read context
! 176: * @buffer: where to store data
! 177: * @len: number of bytes to read
! 178: *
! 179: * Implement an huge: query read.
! 180: *
! 181: * Returns the number of bytes read or -1 in case of error
! 182: */
! 183: static int
! 184: hugeRead(void *context, char *buffer, int len)
! 185: {
! 186: if ((context == NULL) || (buffer == NULL) || (len < 0))
! 187: return (-1);
! 188:
! 189: if (instate == 0) {
! 190: if (len >= rlen) {
! 191: len = rlen;
! 192: rlen = 0;
! 193: memcpy(buffer, current, len);
! 194: instate = 1;
! 195: curlen = 0;
! 196: dotlen = maxlen / 10;
! 197: } else {
! 198: memcpy(buffer, current, len);
! 199: rlen -= len;
! 200: current += len;
! 201: }
! 202: } else if (instate == 2) {
! 203: if (len >= rlen) {
! 204: len = rlen;
! 205: rlen = 0;
! 206: memcpy(buffer, current, len);
! 207: instate = 3;
! 208: curlen = 0;
! 209: } else {
! 210: memcpy(buffer, current, len);
! 211: rlen -= len;
! 212: current += len;
! 213: }
! 214: } else if (instate == 1) {
! 215: if (len > CHUNK) len = CHUNK;
! 216: memcpy(buffer, &filling[0], len);
! 217: curlen += len;
! 218: if (curlen >= maxlen) {
! 219: rlen = strlen(hugeTests[currentTest].end);
! 220: current = hugeTests[currentTest].end;
! 221: instate = 2;
! 222: } else {
! 223: if (curlen > dotlen) {
! 224: fprintf(stderr, ".");
! 225: dotlen += maxlen / 10;
! 226: }
! 227: }
! 228: } else
! 229: len = 0;
! 230: return (len);
! 231: }
! 232:
! 233: /************************************************************************
! 234: * *
! 235: * Crazy document generator *
! 236: * *
! 237: ************************************************************************/
! 238:
! 239: unsigned int crazy_indx = 0;
! 240:
! 241: const char *crazy = "<?xml version='1.0' encoding='UTF-8'?>\
! 242: <?tst ?>\
! 243: <!-- tst -->\
! 244: <!DOCTYPE foo [\
! 245: <?tst ?>\
! 246: <!-- tst -->\
! 247: <!ELEMENT foo (#PCDATA)>\
! 248: <!ELEMENT p (#PCDATA|emph)* >\
! 249: ]>\
! 250: <?tst ?>\
! 251: <!-- tst -->\
! 252: <foo bar='foo'>\
! 253: <?tst ?>\
! 254: <!-- tst -->\
! 255: foo\
! 256: <![CDATA[ ]]>\
! 257: </foo>\
! 258: <?tst ?>\
! 259: <!-- tst -->";
! 260:
! 261: /**
! 262: * crazyMatch:
! 263: * @URI: an URI to test
! 264: *
! 265: * Check for a crazy: query
! 266: *
! 267: * Returns 1 if yes and 0 if another Input module should be used
! 268: */
! 269: static int
! 270: crazyMatch(const char * URI) {
! 271: if ((URI != NULL) && (!strncmp(URI, "crazy:", 6)))
! 272: return(1);
! 273: return(0);
! 274: }
! 275:
! 276: /**
! 277: * crazyOpen:
! 278: * @URI: an URI to test
! 279: *
! 280: * Return a pointer to the crazy: query handler, in this example simply
! 281: * the current pointer...
! 282: *
! 283: * Returns an Input context or NULL in case or error
! 284: */
! 285: static void *
! 286: crazyOpen(const char * URI) {
! 287: if ((URI == NULL) || (strncmp(URI, "crazy:", 6)))
! 288: return(NULL);
! 289:
! 290: if (crazy_indx > strlen(crazy))
! 291: return(NULL);
! 292: reset_timout();
! 293: rlen = crazy_indx;
! 294: current = &crazy[0];
! 295: instate = 0;
! 296: return((void *) current);
! 297: }
! 298:
! 299: /**
! 300: * crazyClose:
! 301: * @context: the read context
! 302: *
! 303: * Close the crazy: query handler
! 304: *
! 305: * Returns 0 or -1 in case of error
! 306: */
! 307: static int
! 308: crazyClose(void * context) {
! 309: if (context == NULL) return(-1);
! 310: return(0);
! 311: }
! 312:
! 313:
! 314: /**
! 315: * crazyRead:
! 316: * @context: the read context
! 317: * @buffer: where to store data
! 318: * @len: number of bytes to read
! 319: *
! 320: * Implement an crazy: query read.
! 321: *
! 322: * Returns the number of bytes read or -1 in case of error
! 323: */
! 324: static int
! 325: crazyRead(void *context, char *buffer, int len)
! 326: {
! 327: if ((context == NULL) || (buffer == NULL) || (len < 0))
! 328: return (-1);
! 329:
! 330: if ((check_time() <= 0) && (instate == 1)) {
! 331: fprintf(stderr, "\ntimeout in crazy(%d)\n", crazy_indx);
! 332: rlen = strlen(crazy) - crazy_indx;
! 333: current = &crazy[crazy_indx];
! 334: instate = 2;
! 335: }
! 336: if (instate == 0) {
! 337: if (len >= rlen) {
! 338: len = rlen;
! 339: rlen = 0;
! 340: memcpy(buffer, current, len);
! 341: instate = 1;
! 342: curlen = 0;
! 343: } else {
! 344: memcpy(buffer, current, len);
! 345: rlen -= len;
! 346: current += len;
! 347: }
! 348: } else if (instate == 2) {
! 349: if (len >= rlen) {
! 350: len = rlen;
! 351: rlen = 0;
! 352: memcpy(buffer, current, len);
! 353: instate = 3;
! 354: curlen = 0;
! 355: } else {
! 356: memcpy(buffer, current, len);
! 357: rlen -= len;
! 358: current += len;
! 359: }
! 360: } else if (instate == 1) {
! 361: if (len > CHUNK) len = CHUNK;
! 362: memcpy(buffer, &filling[0], len);
! 363: curlen += len;
! 364: if (curlen >= maxlen) {
! 365: rlen = strlen(crazy) - crazy_indx;
! 366: current = &crazy[crazy_indx];
! 367: instate = 2;
! 368: }
! 369: } else
! 370: len = 0;
! 371: return (len);
! 372: }
! 373: /************************************************************************
! 374: * *
! 375: * Libxml2 specific routines *
! 376: * *
! 377: ************************************************************************/
! 378:
! 379: static int nb_tests = 0;
! 380: static int nb_errors = 0;
! 381: static int nb_leaks = 0;
! 382: static int extraMemoryFromResolver = 0;
! 383:
! 384: /*
! 385: * We need to trap calls to the resolver to not account memory for the catalog
! 386: * which is shared to the current running test. We also don't want to have
! 387: * network downloads modifying tests.
! 388: */
! 389: static xmlParserInputPtr
! 390: testExternalEntityLoader(const char *URL, const char *ID,
! 391: xmlParserCtxtPtr ctxt) {
! 392: xmlParserInputPtr ret;
! 393: int memused = xmlMemUsed();
! 394:
! 395: ret = xmlNoNetExternalEntityLoader(URL, ID, ctxt);
! 396: extraMemoryFromResolver += xmlMemUsed() - memused;
! 397:
! 398: return(ret);
! 399: }
! 400:
! 401: /*
! 402: * Trapping the error messages at the generic level to grab the equivalent of
! 403: * stderr messages on CLI tools.
! 404: */
! 405: static char testErrors[32769];
! 406: static int testErrorsSize = 0;
! 407:
! 408: static void XMLCDECL
! 409: channel(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) {
! 410: va_list args;
! 411: int res;
! 412:
! 413: if (testErrorsSize >= 32768)
! 414: return;
! 415: va_start(args, msg);
! 416: res = vsnprintf(&testErrors[testErrorsSize],
! 417: 32768 - testErrorsSize,
! 418: msg, args);
! 419: va_end(args);
! 420: if (testErrorsSize + res >= 32768) {
! 421: /* buffer is full */
! 422: testErrorsSize = 32768;
! 423: testErrors[testErrorsSize] = 0;
! 424: } else {
! 425: testErrorsSize += res;
! 426: }
! 427: testErrors[testErrorsSize] = 0;
! 428: }
! 429:
! 430: /**
! 431: * xmlParserPrintFileContext:
! 432: * @input: an xmlParserInputPtr input
! 433: *
! 434: * Displays current context within the input content for error tracking
! 435: */
! 436:
! 437: static void
! 438: xmlParserPrintFileContextInternal(xmlParserInputPtr input ,
! 439: xmlGenericErrorFunc chanl, void *data ) {
! 440: const xmlChar *cur, *base;
! 441: unsigned int n, col; /* GCC warns if signed, because compared with sizeof() */
! 442: xmlChar content[81]; /* space for 80 chars + line terminator */
! 443: xmlChar *ctnt;
! 444:
! 445: if (input == NULL) return;
! 446: cur = input->cur;
! 447: base = input->base;
! 448: /* skip backwards over any end-of-lines */
! 449: while ((cur > base) && ((*(cur) == '\n') || (*(cur) == '\r'))) {
! 450: cur--;
! 451: }
! 452: n = 0;
! 453: /* search backwards for beginning-of-line (to max buff size) */
! 454: while ((n++ < (sizeof(content)-1)) && (cur > base) &&
! 455: (*(cur) != '\n') && (*(cur) != '\r'))
! 456: cur--;
! 457: if ((*(cur) == '\n') || (*(cur) == '\r')) cur++;
! 458: /* calculate the error position in terms of the current position */
! 459: col = input->cur - cur;
! 460: /* search forward for end-of-line (to max buff size) */
! 461: n = 0;
! 462: ctnt = content;
! 463: /* copy selected text to our buffer */
! 464: while ((*cur != 0) && (*(cur) != '\n') &&
! 465: (*(cur) != '\r') && (n < sizeof(content)-1)) {
! 466: *ctnt++ = *cur++;
! 467: n++;
! 468: }
! 469: *ctnt = 0;
! 470: /* print out the selected text */
! 471: chanl(data ,"%s\n", content);
! 472: /* create blank line with problem pointer */
! 473: n = 0;
! 474: ctnt = content;
! 475: /* (leave buffer space for pointer + line terminator) */
! 476: while ((n<col) && (n++ < sizeof(content)-2) && (*ctnt != 0)) {
! 477: if (*(ctnt) != '\t')
! 478: *(ctnt) = ' ';
! 479: ctnt++;
! 480: }
! 481: *ctnt++ = '^';
! 482: *ctnt = 0;
! 483: chanl(data ,"%s\n", content);
! 484: }
! 485:
! 486: static void
! 487: testStructuredErrorHandler(void *ctx ATTRIBUTE_UNUSED, xmlErrorPtr err) {
! 488: char *file = NULL;
! 489: int line = 0;
! 490: int code = -1;
! 491: int domain;
! 492: void *data = NULL;
! 493: const char *str;
! 494: const xmlChar *name = NULL;
! 495: xmlNodePtr node;
! 496: xmlErrorLevel level;
! 497: xmlParserInputPtr input = NULL;
! 498: xmlParserInputPtr cur = NULL;
! 499: xmlParserCtxtPtr ctxt = NULL;
! 500:
! 501: if (err == NULL)
! 502: return;
! 503:
! 504: file = err->file;
! 505: line = err->line;
! 506: code = err->code;
! 507: domain = err->domain;
! 508: level = err->level;
! 509: node = err->node;
! 510: if ((domain == XML_FROM_PARSER) || (domain == XML_FROM_HTML) ||
! 511: (domain == XML_FROM_DTD) || (domain == XML_FROM_NAMESPACE) ||
! 512: (domain == XML_FROM_IO) || (domain == XML_FROM_VALID)) {
! 513: ctxt = err->ctxt;
! 514: }
! 515: str = err->message;
! 516:
! 517: if (code == XML_ERR_OK)
! 518: return;
! 519:
! 520: if ((node != NULL) && (node->type == XML_ELEMENT_NODE))
! 521: name = node->name;
! 522:
! 523: /*
! 524: * Maintain the compatibility with the legacy error handling
! 525: */
! 526: if (ctxt != NULL) {
! 527: input = ctxt->input;
! 528: if ((input != NULL) && (input->filename == NULL) &&
! 529: (ctxt->inputNr > 1)) {
! 530: cur = input;
! 531: input = ctxt->inputTab[ctxt->inputNr - 2];
! 532: }
! 533: if (input != NULL) {
! 534: if (input->filename)
! 535: channel(data, "%s:%d: ", input->filename, input->line);
! 536: else if ((line != 0) && (domain == XML_FROM_PARSER))
! 537: channel(data, "Entity: line %d: ", input->line);
! 538: }
! 539: } else {
! 540: if (file != NULL)
! 541: channel(data, "%s:%d: ", file, line);
! 542: else if ((line != 0) && (domain == XML_FROM_PARSER))
! 543: channel(data, "Entity: line %d: ", line);
! 544: }
! 545: if (name != NULL) {
! 546: channel(data, "element %s: ", name);
! 547: }
! 548: if (code == XML_ERR_OK)
! 549: return;
! 550: switch (domain) {
! 551: case XML_FROM_PARSER:
! 552: channel(data, "parser ");
! 553: break;
! 554: case XML_FROM_NAMESPACE:
! 555: channel(data, "namespace ");
! 556: break;
! 557: case XML_FROM_DTD:
! 558: case XML_FROM_VALID:
! 559: channel(data, "validity ");
! 560: break;
! 561: case XML_FROM_HTML:
! 562: channel(data, "HTML parser ");
! 563: break;
! 564: case XML_FROM_MEMORY:
! 565: channel(data, "memory ");
! 566: break;
! 567: case XML_FROM_OUTPUT:
! 568: channel(data, "output ");
! 569: break;
! 570: case XML_FROM_IO:
! 571: channel(data, "I/O ");
! 572: break;
! 573: case XML_FROM_XINCLUDE:
! 574: channel(data, "XInclude ");
! 575: break;
! 576: case XML_FROM_XPATH:
! 577: channel(data, "XPath ");
! 578: break;
! 579: case XML_FROM_XPOINTER:
! 580: channel(data, "parser ");
! 581: break;
! 582: case XML_FROM_REGEXP:
! 583: channel(data, "regexp ");
! 584: break;
! 585: case XML_FROM_MODULE:
! 586: channel(data, "module ");
! 587: break;
! 588: case XML_FROM_SCHEMASV:
! 589: channel(data, "Schemas validity ");
! 590: break;
! 591: case XML_FROM_SCHEMASP:
! 592: channel(data, "Schemas parser ");
! 593: break;
! 594: case XML_FROM_RELAXNGP:
! 595: channel(data, "Relax-NG parser ");
! 596: break;
! 597: case XML_FROM_RELAXNGV:
! 598: channel(data, "Relax-NG validity ");
! 599: break;
! 600: case XML_FROM_CATALOG:
! 601: channel(data, "Catalog ");
! 602: break;
! 603: case XML_FROM_C14N:
! 604: channel(data, "C14N ");
! 605: break;
! 606: case XML_FROM_XSLT:
! 607: channel(data, "XSLT ");
! 608: break;
! 609: default:
! 610: break;
! 611: }
! 612: if (code == XML_ERR_OK)
! 613: return;
! 614: switch (level) {
! 615: case XML_ERR_NONE:
! 616: channel(data, ": ");
! 617: break;
! 618: case XML_ERR_WARNING:
! 619: channel(data, "warning : ");
! 620: break;
! 621: case XML_ERR_ERROR:
! 622: channel(data, "error : ");
! 623: break;
! 624: case XML_ERR_FATAL:
! 625: channel(data, "error : ");
! 626: break;
! 627: }
! 628: if (code == XML_ERR_OK)
! 629: return;
! 630: if (str != NULL) {
! 631: int len;
! 632: len = xmlStrlen((const xmlChar *)str);
! 633: if ((len > 0) && (str[len - 1] != '\n'))
! 634: channel(data, "%s\n", str);
! 635: else
! 636: channel(data, "%s", str);
! 637: } else {
! 638: channel(data, "%s\n", "out of memory error");
! 639: }
! 640: if (code == XML_ERR_OK)
! 641: return;
! 642:
! 643: if (ctxt != NULL) {
! 644: xmlParserPrintFileContextInternal(input, channel, data);
! 645: if (cur != NULL) {
! 646: if (cur->filename)
! 647: channel(data, "%s:%d: \n", cur->filename, cur->line);
! 648: else if ((line != 0) && (domain == XML_FROM_PARSER))
! 649: channel(data, "Entity: line %d: \n", cur->line);
! 650: xmlParserPrintFileContextInternal(cur, channel, data);
! 651: }
! 652: }
! 653: if ((domain == XML_FROM_XPATH) && (err->str1 != NULL) &&
! 654: (err->int1 < 100) &&
! 655: (err->int1 < xmlStrlen((const xmlChar *)err->str1))) {
! 656: xmlChar buf[150];
! 657: int i;
! 658:
! 659: channel(data, "%s\n", err->str1);
! 660: for (i=0;i < err->int1;i++)
! 661: buf[i] = ' ';
! 662: buf[i++] = '^';
! 663: buf[i] = 0;
! 664: channel(data, "%s\n", buf);
! 665: }
! 666: }
! 667:
! 668: static void
! 669: initializeLibxml2(void) {
! 670: xmlGetWarningsDefaultValue = 0;
! 671: xmlPedanticParserDefault(0);
! 672:
! 673: xmlMemSetup(xmlMemFree, xmlMemMalloc, xmlMemRealloc, xmlMemoryStrdup);
! 674: xmlInitParser();
! 675: xmlSetExternalEntityLoader(testExternalEntityLoader);
! 676: xmlSetStructuredErrorFunc(NULL, testStructuredErrorHandler);
! 677: /*
! 678: * register the new I/O handlers
! 679: */
! 680: if (xmlRegisterInputCallbacks(hugeMatch, hugeOpen,
! 681: hugeRead, hugeClose) < 0) {
! 682: fprintf(stderr, "failed to register Huge handlers\n");
! 683: exit(1);
! 684: }
! 685: if (xmlRegisterInputCallbacks(crazyMatch, crazyOpen,
! 686: crazyRead, crazyClose) < 0) {
! 687: fprintf(stderr, "failed to register Crazy handlers\n");
! 688: exit(1);
! 689: }
! 690: }
! 691:
! 692: /************************************************************************
! 693: * *
! 694: * SAX empty callbacks *
! 695: * *
! 696: ************************************************************************/
! 697:
! 698: unsigned long callbacks = 0;
! 699:
! 700: /**
! 701: * isStandaloneCallback:
! 702: * @ctxt: An XML parser context
! 703: *
! 704: * Is this document tagged standalone ?
! 705: *
! 706: * Returns 1 if true
! 707: */
! 708: static int
! 709: isStandaloneCallback(void *ctx ATTRIBUTE_UNUSED)
! 710: {
! 711: callbacks++;
! 712: return (0);
! 713: }
! 714:
! 715: /**
! 716: * hasInternalSubsetCallback:
! 717: * @ctxt: An XML parser context
! 718: *
! 719: * Does this document has an internal subset
! 720: *
! 721: * Returns 1 if true
! 722: */
! 723: static int
! 724: hasInternalSubsetCallback(void *ctx ATTRIBUTE_UNUSED)
! 725: {
! 726: callbacks++;
! 727: return (0);
! 728: }
! 729:
! 730: /**
! 731: * hasExternalSubsetCallback:
! 732: * @ctxt: An XML parser context
! 733: *
! 734: * Does this document has an external subset
! 735: *
! 736: * Returns 1 if true
! 737: */
! 738: static int
! 739: hasExternalSubsetCallback(void *ctx ATTRIBUTE_UNUSED)
! 740: {
! 741: callbacks++;
! 742: return (0);
! 743: }
! 744:
! 745: /**
! 746: * internalSubsetCallback:
! 747: * @ctxt: An XML parser context
! 748: *
! 749: * Does this document has an internal subset
! 750: */
! 751: static void
! 752: internalSubsetCallback(void *ctx ATTRIBUTE_UNUSED,
! 753: const xmlChar * name ATTRIBUTE_UNUSED,
! 754: const xmlChar * ExternalID ATTRIBUTE_UNUSED,
! 755: const xmlChar * SystemID ATTRIBUTE_UNUSED)
! 756: {
! 757: callbacks++;
! 758: return;
! 759: }
! 760:
! 761: /**
! 762: * externalSubsetCallback:
! 763: * @ctxt: An XML parser context
! 764: *
! 765: * Does this document has an external subset
! 766: */
! 767: static void
! 768: externalSubsetCallback(void *ctx ATTRIBUTE_UNUSED,
! 769: const xmlChar * name ATTRIBUTE_UNUSED,
! 770: const xmlChar * ExternalID ATTRIBUTE_UNUSED,
! 771: const xmlChar * SystemID ATTRIBUTE_UNUSED)
! 772: {
! 773: callbacks++;
! 774: return;
! 775: }
! 776:
! 777: /**
! 778: * resolveEntityCallback:
! 779: * @ctxt: An XML parser context
! 780: * @publicId: The public ID of the entity
! 781: * @systemId: The system ID of the entity
! 782: *
! 783: * Special entity resolver, better left to the parser, it has
! 784: * more context than the application layer.
! 785: * The default behaviour is to NOT resolve the entities, in that case
! 786: * the ENTITY_REF nodes are built in the structure (and the parameter
! 787: * values).
! 788: *
! 789: * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
! 790: */
! 791: static xmlParserInputPtr
! 792: resolveEntityCallback(void *ctx ATTRIBUTE_UNUSED,
! 793: const xmlChar * publicId ATTRIBUTE_UNUSED,
! 794: const xmlChar * systemId ATTRIBUTE_UNUSED)
! 795: {
! 796: callbacks++;
! 797: return (NULL);
! 798: }
! 799:
! 800: /**
! 801: * getEntityCallback:
! 802: * @ctxt: An XML parser context
! 803: * @name: The entity name
! 804: *
! 805: * Get an entity by name
! 806: *
! 807: * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
! 808: */
! 809: static xmlEntityPtr
! 810: getEntityCallback(void *ctx ATTRIBUTE_UNUSED,
! 811: const xmlChar * name ATTRIBUTE_UNUSED)
! 812: {
! 813: callbacks++;
! 814: return (NULL);
! 815: }
! 816:
! 817: /**
! 818: * getParameterEntityCallback:
! 819: * @ctxt: An XML parser context
! 820: * @name: The entity name
! 821: *
! 822: * Get a parameter entity by name
! 823: *
! 824: * Returns the xmlParserInputPtr
! 825: */
! 826: static xmlEntityPtr
! 827: getParameterEntityCallback(void *ctx ATTRIBUTE_UNUSED,
! 828: const xmlChar * name ATTRIBUTE_UNUSED)
! 829: {
! 830: callbacks++;
! 831: return (NULL);
! 832: }
! 833:
! 834:
! 835: /**
! 836: * entityDeclCallback:
! 837: * @ctxt: An XML parser context
! 838: * @name: the entity name
! 839: * @type: the entity type
! 840: * @publicId: The public ID of the entity
! 841: * @systemId: The system ID of the entity
! 842: * @content: the entity value (without processing).
! 843: *
! 844: * An entity definition has been parsed
! 845: */
! 846: static void
! 847: entityDeclCallback(void *ctx ATTRIBUTE_UNUSED,
! 848: const xmlChar * name ATTRIBUTE_UNUSED,
! 849: int type ATTRIBUTE_UNUSED,
! 850: const xmlChar * publicId ATTRIBUTE_UNUSED,
! 851: const xmlChar * systemId ATTRIBUTE_UNUSED,
! 852: xmlChar * content ATTRIBUTE_UNUSED)
! 853: {
! 854: callbacks++;
! 855: return;
! 856: }
! 857:
! 858: /**
! 859: * attributeDeclCallback:
! 860: * @ctxt: An XML parser context
! 861: * @name: the attribute name
! 862: * @type: the attribute type
! 863: *
! 864: * An attribute definition has been parsed
! 865: */
! 866: static void
! 867: attributeDeclCallback(void *ctx ATTRIBUTE_UNUSED,
! 868: const xmlChar * elem ATTRIBUTE_UNUSED,
! 869: const xmlChar * name ATTRIBUTE_UNUSED,
! 870: int type ATTRIBUTE_UNUSED, int def ATTRIBUTE_UNUSED,
! 871: const xmlChar * defaultValue ATTRIBUTE_UNUSED,
! 872: xmlEnumerationPtr tree ATTRIBUTE_UNUSED)
! 873: {
! 874: callbacks++;
! 875: return;
! 876: }
! 877:
! 878: /**
! 879: * elementDeclCallback:
! 880: * @ctxt: An XML parser context
! 881: * @name: the element name
! 882: * @type: the element type
! 883: * @content: the element value (without processing).
! 884: *
! 885: * An element definition has been parsed
! 886: */
! 887: static void
! 888: elementDeclCallback(void *ctx ATTRIBUTE_UNUSED,
! 889: const xmlChar * name ATTRIBUTE_UNUSED,
! 890: int type ATTRIBUTE_UNUSED,
! 891: xmlElementContentPtr content ATTRIBUTE_UNUSED)
! 892: {
! 893: callbacks++;
! 894: return;
! 895: }
! 896:
! 897: /**
! 898: * notationDeclCallback:
! 899: * @ctxt: An XML parser context
! 900: * @name: The name of the notation
! 901: * @publicId: The public ID of the entity
! 902: * @systemId: The system ID of the entity
! 903: *
! 904: * What to do when a notation declaration has been parsed.
! 905: */
! 906: static void
! 907: notationDeclCallback(void *ctx ATTRIBUTE_UNUSED,
! 908: const xmlChar * name ATTRIBUTE_UNUSED,
! 909: const xmlChar * publicId ATTRIBUTE_UNUSED,
! 910: const xmlChar * systemId ATTRIBUTE_UNUSED)
! 911: {
! 912: callbacks++;
! 913: return;
! 914: }
! 915:
! 916: /**
! 917: * unparsedEntityDeclCallback:
! 918: * @ctxt: An XML parser context
! 919: * @name: The name of the entity
! 920: * @publicId: The public ID of the entity
! 921: * @systemId: The system ID of the entity
! 922: * @notationName: the name of the notation
! 923: *
! 924: * What to do when an unparsed entity declaration is parsed
! 925: */
! 926: static void
! 927: unparsedEntityDeclCallback(void *ctx ATTRIBUTE_UNUSED,
! 928: const xmlChar * name ATTRIBUTE_UNUSED,
! 929: const xmlChar * publicId ATTRIBUTE_UNUSED,
! 930: const xmlChar * systemId ATTRIBUTE_UNUSED,
! 931: const xmlChar * notationName ATTRIBUTE_UNUSED)
! 932: {
! 933: callbacks++;
! 934: return;
! 935: }
! 936:
! 937: /**
! 938: * setDocumentLocatorCallback:
! 939: * @ctxt: An XML parser context
! 940: * @loc: A SAX Locator
! 941: *
! 942: * Receive the document locator at startup, actually xmlDefaultSAXLocator
! 943: * Everything is available on the context, so this is useless in our case.
! 944: */
! 945: static void
! 946: setDocumentLocatorCallback(void *ctx ATTRIBUTE_UNUSED,
! 947: xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
! 948: {
! 949: callbacks++;
! 950: return;
! 951: }
! 952:
! 953: /**
! 954: * startDocumentCallback:
! 955: * @ctxt: An XML parser context
! 956: *
! 957: * called when the document start being processed.
! 958: */
! 959: static void
! 960: startDocumentCallback(void *ctx ATTRIBUTE_UNUSED)
! 961: {
! 962: callbacks++;
! 963: return;
! 964: }
! 965:
! 966: /**
! 967: * endDocumentCallback:
! 968: * @ctxt: An XML parser context
! 969: *
! 970: * called when the document end has been detected.
! 971: */
! 972: static void
! 973: endDocumentCallback(void *ctx ATTRIBUTE_UNUSED)
! 974: {
! 975: callbacks++;
! 976: return;
! 977: }
! 978:
! 979: #if 0
! 980: /**
! 981: * startElementCallback:
! 982: * @ctxt: An XML parser context
! 983: * @name: The element name
! 984: *
! 985: * called when an opening tag has been processed.
! 986: */
! 987: static void
! 988: startElementCallback(void *ctx ATTRIBUTE_UNUSED,
! 989: const xmlChar * name ATTRIBUTE_UNUSED,
! 990: const xmlChar ** atts ATTRIBUTE_UNUSED)
! 991: {
! 992: callbacks++;
! 993: return;
! 994: }
! 995:
! 996: /**
! 997: * endElementCallback:
! 998: * @ctxt: An XML parser context
! 999: * @name: The element name
! 1000: *
! 1001: * called when the end of an element has been detected.
! 1002: */
! 1003: static void
! 1004: endElementCallback(void *ctx ATTRIBUTE_UNUSED,
! 1005: const xmlChar * name ATTRIBUTE_UNUSED)
! 1006: {
! 1007: callbacks++;
! 1008: return;
! 1009: }
! 1010: #endif
! 1011:
! 1012: /**
! 1013: * charactersCallback:
! 1014: * @ctxt: An XML parser context
! 1015: * @ch: a xmlChar string
! 1016: * @len: the number of xmlChar
! 1017: *
! 1018: * receiving some chars from the parser.
! 1019: * Question: how much at a time ???
! 1020: */
! 1021: static void
! 1022: charactersCallback(void *ctx ATTRIBUTE_UNUSED,
! 1023: const xmlChar * ch ATTRIBUTE_UNUSED,
! 1024: int len ATTRIBUTE_UNUSED)
! 1025: {
! 1026: callbacks++;
! 1027: return;
! 1028: }
! 1029:
! 1030: /**
! 1031: * referenceCallback:
! 1032: * @ctxt: An XML parser context
! 1033: * @name: The entity name
! 1034: *
! 1035: * called when an entity reference is detected.
! 1036: */
! 1037: static void
! 1038: referenceCallback(void *ctx ATTRIBUTE_UNUSED,
! 1039: const xmlChar * name ATTRIBUTE_UNUSED)
! 1040: {
! 1041: callbacks++;
! 1042: return;
! 1043: }
! 1044:
! 1045: /**
! 1046: * ignorableWhitespaceCallback:
! 1047: * @ctxt: An XML parser context
! 1048: * @ch: a xmlChar string
! 1049: * @start: the first char in the string
! 1050: * @len: the number of xmlChar
! 1051: *
! 1052: * receiving some ignorable whitespaces from the parser.
! 1053: * Question: how much at a time ???
! 1054: */
! 1055: static void
! 1056: ignorableWhitespaceCallback(void *ctx ATTRIBUTE_UNUSED,
! 1057: const xmlChar * ch ATTRIBUTE_UNUSED,
! 1058: int len ATTRIBUTE_UNUSED)
! 1059: {
! 1060: callbacks++;
! 1061: return;
! 1062: }
! 1063:
! 1064: /**
! 1065: * processingInstructionCallback:
! 1066: * @ctxt: An XML parser context
! 1067: * @target: the target name
! 1068: * @data: the PI data's
! 1069: * @len: the number of xmlChar
! 1070: *
! 1071: * A processing instruction has been parsed.
! 1072: */
! 1073: static void
! 1074: processingInstructionCallback(void *ctx ATTRIBUTE_UNUSED,
! 1075: const xmlChar * target ATTRIBUTE_UNUSED,
! 1076: const xmlChar * data ATTRIBUTE_UNUSED)
! 1077: {
! 1078: callbacks++;
! 1079: return;
! 1080: }
! 1081:
! 1082: /**
! 1083: * cdataBlockCallback:
! 1084: * @ctx: the user data (XML parser context)
! 1085: * @value: The pcdata content
! 1086: * @len: the block length
! 1087: *
! 1088: * called when a pcdata block has been parsed
! 1089: */
! 1090: static void
! 1091: cdataBlockCallback(void *ctx ATTRIBUTE_UNUSED,
! 1092: const xmlChar * value ATTRIBUTE_UNUSED,
! 1093: int len ATTRIBUTE_UNUSED)
! 1094: {
! 1095: callbacks++;
! 1096: return;
! 1097: }
! 1098:
! 1099: /**
! 1100: * commentCallback:
! 1101: * @ctxt: An XML parser context
! 1102: * @value: the comment content
! 1103: *
! 1104: * A comment has been parsed.
! 1105: */
! 1106: static void
! 1107: commentCallback(void *ctx ATTRIBUTE_UNUSED,
! 1108: const xmlChar * value ATTRIBUTE_UNUSED)
! 1109: {
! 1110: callbacks++;
! 1111: return;
! 1112: }
! 1113:
! 1114: /**
! 1115: * warningCallback:
! 1116: * @ctxt: An XML parser context
! 1117: * @msg: the message to display/transmit
! 1118: * @...: extra parameters for the message display
! 1119: *
! 1120: * Display and format a warning messages, gives file, line, position and
! 1121: * extra parameters.
! 1122: */
! 1123: static void XMLCDECL
! 1124: warningCallback(void *ctx ATTRIBUTE_UNUSED,
! 1125: const char *msg ATTRIBUTE_UNUSED, ...)
! 1126: {
! 1127: callbacks++;
! 1128: return;
! 1129: }
! 1130:
! 1131: /**
! 1132: * errorCallback:
! 1133: * @ctxt: An XML parser context
! 1134: * @msg: the message to display/transmit
! 1135: * @...: extra parameters for the message display
! 1136: *
! 1137: * Display and format a error messages, gives file, line, position and
! 1138: * extra parameters.
! 1139: */
! 1140: static void XMLCDECL
! 1141: errorCallback(void *ctx ATTRIBUTE_UNUSED, const char *msg ATTRIBUTE_UNUSED,
! 1142: ...)
! 1143: {
! 1144: callbacks++;
! 1145: return;
! 1146: }
! 1147:
! 1148: /**
! 1149: * fatalErrorCallback:
! 1150: * @ctxt: An XML parser context
! 1151: * @msg: the message to display/transmit
! 1152: * @...: extra parameters for the message display
! 1153: *
! 1154: * Display and format a fatalError messages, gives file, line, position and
! 1155: * extra parameters.
! 1156: */
! 1157: static void XMLCDECL
! 1158: fatalErrorCallback(void *ctx ATTRIBUTE_UNUSED,
! 1159: const char *msg ATTRIBUTE_UNUSED, ...)
! 1160: {
! 1161: return;
! 1162: }
! 1163:
! 1164:
! 1165: /*
! 1166: * SAX2 specific callbacks
! 1167: */
! 1168:
! 1169: /**
! 1170: * startElementNsCallback:
! 1171: * @ctxt: An XML parser context
! 1172: * @name: The element name
! 1173: *
! 1174: * called when an opening tag has been processed.
! 1175: */
! 1176: static void
! 1177: startElementNsCallback(void *ctx ATTRIBUTE_UNUSED,
! 1178: const xmlChar * localname ATTRIBUTE_UNUSED,
! 1179: const xmlChar * prefix ATTRIBUTE_UNUSED,
! 1180: const xmlChar * URI ATTRIBUTE_UNUSED,
! 1181: int nb_namespaces ATTRIBUTE_UNUSED,
! 1182: const xmlChar ** namespaces ATTRIBUTE_UNUSED,
! 1183: int nb_attributes ATTRIBUTE_UNUSED,
! 1184: int nb_defaulted ATTRIBUTE_UNUSED,
! 1185: const xmlChar ** attributes ATTRIBUTE_UNUSED)
! 1186: {
! 1187: callbacks++;
! 1188: return;
! 1189: }
! 1190:
! 1191: /**
! 1192: * endElementCallback:
! 1193: * @ctxt: An XML parser context
! 1194: * @name: The element name
! 1195: *
! 1196: * called when the end of an element has been detected.
! 1197: */
! 1198: static void
! 1199: endElementNsCallback(void *ctx ATTRIBUTE_UNUSED,
! 1200: const xmlChar * localname ATTRIBUTE_UNUSED,
! 1201: const xmlChar * prefix ATTRIBUTE_UNUSED,
! 1202: const xmlChar * URI ATTRIBUTE_UNUSED)
! 1203: {
! 1204: callbacks++;
! 1205: return;
! 1206: }
! 1207:
! 1208: static xmlSAXHandler callbackSAX2HandlerStruct = {
! 1209: internalSubsetCallback,
! 1210: isStandaloneCallback,
! 1211: hasInternalSubsetCallback,
! 1212: hasExternalSubsetCallback,
! 1213: resolveEntityCallback,
! 1214: getEntityCallback,
! 1215: entityDeclCallback,
! 1216: notationDeclCallback,
! 1217: attributeDeclCallback,
! 1218: elementDeclCallback,
! 1219: unparsedEntityDeclCallback,
! 1220: setDocumentLocatorCallback,
! 1221: startDocumentCallback,
! 1222: endDocumentCallback,
! 1223: NULL,
! 1224: NULL,
! 1225: referenceCallback,
! 1226: charactersCallback,
! 1227: ignorableWhitespaceCallback,
! 1228: processingInstructionCallback,
! 1229: commentCallback,
! 1230: warningCallback,
! 1231: errorCallback,
! 1232: fatalErrorCallback,
! 1233: getParameterEntityCallback,
! 1234: cdataBlockCallback,
! 1235: externalSubsetCallback,
! 1236: XML_SAX2_MAGIC,
! 1237: NULL,
! 1238: startElementNsCallback,
! 1239: endElementNsCallback,
! 1240: NULL
! 1241: };
! 1242:
! 1243: static xmlSAXHandlerPtr callbackSAX2Handler = &callbackSAX2HandlerStruct;
! 1244:
! 1245: /************************************************************************
! 1246: * *
! 1247: * The tests front-ends *
! 1248: * *
! 1249: ************************************************************************/
! 1250:
! 1251: /**
! 1252: * readerTest:
! 1253: * @filename: the file to parse
! 1254: * @max_size: size of the limit to test
! 1255: * @options: parsing options
! 1256: * @fail: should a failure be reported
! 1257: *
! 1258: * Parse a memory generated file using SAX
! 1259: *
! 1260: * Returns 0 in case of success, an error code otherwise
! 1261: */
! 1262: static int
! 1263: saxTest(const char *filename, size_t limit, int options, int fail) {
! 1264: int res = 0;
! 1265: xmlParserCtxtPtr ctxt;
! 1266: xmlDocPtr doc;
! 1267: xmlSAXHandlerPtr old_sax;
! 1268:
! 1269: nb_tests++;
! 1270:
! 1271: maxlen = limit;
! 1272: ctxt = xmlNewParserCtxt();
! 1273: if (ctxt == NULL) {
! 1274: fprintf(stderr, "Failed to create parser context\n");
! 1275: return(1);
! 1276: }
! 1277: old_sax = ctxt->sax;
! 1278: ctxt->sax = callbackSAX2Handler;
! 1279: ctxt->userData = NULL;
! 1280: doc = xmlCtxtReadFile(ctxt, filename, NULL, options);
! 1281:
! 1282: if (doc != NULL) {
! 1283: fprintf(stderr, "SAX parsing generated a document !\n");
! 1284: xmlFreeDoc(doc);
! 1285: res = 0;
! 1286: } else if (ctxt->wellFormed == 0) {
! 1287: if (fail)
! 1288: res = 0;
! 1289: else {
! 1290: fprintf(stderr, "Failed to parse '%s' %lu\n", filename, limit);
! 1291: res = 1;
! 1292: }
! 1293: } else {
! 1294: if (fail) {
! 1295: fprintf(stderr, "Failed to get failure for '%s' %lu\n",
! 1296: filename, limit);
! 1297: res = 1;
! 1298: } else
! 1299: res = 0;
! 1300: }
! 1301: ctxt->sax = old_sax;
! 1302: xmlFreeParserCtxt(ctxt);
! 1303:
! 1304: return(res);
! 1305: }
! 1306: #ifdef LIBXML_READER_ENABLED
! 1307: /**
! 1308: * readerTest:
! 1309: * @filename: the file to parse
! 1310: * @max_size: size of the limit to test
! 1311: * @options: parsing options
! 1312: * @fail: should a failure be reported
! 1313: *
! 1314: * Parse a memory generated file using the xmlReader
! 1315: *
! 1316: * Returns 0 in case of success, an error code otherwise
! 1317: */
! 1318: static int
! 1319: readerTest(const char *filename, size_t limit, int options, int fail) {
! 1320: xmlTextReaderPtr reader;
! 1321: int res = 0;
! 1322: int ret;
! 1323:
! 1324: nb_tests++;
! 1325:
! 1326: maxlen = limit;
! 1327: reader = xmlReaderForFile(filename , NULL, options);
! 1328: if (reader == NULL) {
! 1329: fprintf(stderr, "Failed to open '%s' test\n", filename);
! 1330: return(1);
! 1331: }
! 1332: ret = xmlTextReaderRead(reader);
! 1333: while (ret == 1) {
! 1334: ret = xmlTextReaderRead(reader);
! 1335: }
! 1336: if (ret != 0) {
! 1337: if (fail)
! 1338: res = 0;
! 1339: else {
! 1340: if (strncmp(filename, "crazy:", 6) == 0)
! 1341: fprintf(stderr, "Failed to parse '%s' %u\n",
! 1342: filename, crazy_indx);
! 1343: else
! 1344: fprintf(stderr, "Failed to parse '%s' %lu\n",
! 1345: filename, limit);
! 1346: res = 1;
! 1347: }
! 1348: } else {
! 1349: if (fail) {
! 1350: if (strncmp(filename, "crazy:", 6) == 0)
! 1351: fprintf(stderr, "Failed to get failure for '%s' %u\n",
! 1352: filename, crazy_indx);
! 1353: else
! 1354: fprintf(stderr, "Failed to get failure for '%s' %lu\n",
! 1355: filename, limit);
! 1356: res = 1;
! 1357: } else
! 1358: res = 0;
! 1359: }
! 1360: if (timeout)
! 1361: res = 1;
! 1362: xmlFreeTextReader(reader);
! 1363:
! 1364: return(res);
! 1365: }
! 1366: #endif
! 1367:
! 1368: /************************************************************************
! 1369: * *
! 1370: * Tests descriptions *
! 1371: * *
! 1372: ************************************************************************/
! 1373:
! 1374: typedef int (*functest) (const char *filename, size_t limit, int options,
! 1375: int fail);
! 1376:
! 1377: typedef struct limitDesc limitDesc;
! 1378: typedef limitDesc *limitDescPtr;
! 1379: struct limitDesc {
! 1380: const char *name; /* the huge generator name */
! 1381: size_t limit; /* the limit to test */
! 1382: int options; /* extra parser options */
! 1383: int fail; /* whether the test should fail */
! 1384: };
! 1385:
! 1386: static limitDesc limitDescriptions[] = {
! 1387: /* max length of a text node in content */
! 1388: {"huge:textNode", XML_MAX_TEXT_LENGTH - CHUNK, 0, 0},
! 1389: {"huge:textNode", XML_MAX_TEXT_LENGTH + CHUNK, 0, 1},
! 1390: {"huge:textNode", XML_MAX_TEXT_LENGTH + CHUNK, XML_PARSE_HUGE, 0},
! 1391: /* max length of a text node in content */
! 1392: {"huge:attrNode", XML_MAX_TEXT_LENGTH - CHUNK, 0, 0},
! 1393: {"huge:attrNode", XML_MAX_TEXT_LENGTH + CHUNK, 0, 1},
! 1394: {"huge:attrNode", XML_MAX_TEXT_LENGTH + CHUNK, XML_PARSE_HUGE, 0},
! 1395: /* max length of a comment node */
! 1396: {"huge:commentNode", XML_MAX_TEXT_LENGTH - CHUNK, 0, 0},
! 1397: {"huge:commentNode", XML_MAX_TEXT_LENGTH + CHUNK, 0, 1},
! 1398: {"huge:commentNode", XML_MAX_TEXT_LENGTH + CHUNK, XML_PARSE_HUGE, 0},
! 1399: /* max length of a PI node */
! 1400: {"huge:piNode", XML_MAX_TEXT_LENGTH - CHUNK, 0, 0},
! 1401: {"huge:piNode", XML_MAX_TEXT_LENGTH + CHUNK, 0, 1},
! 1402: {"huge:piNode", XML_MAX_TEXT_LENGTH + CHUNK, XML_PARSE_HUGE, 0},
! 1403: };
! 1404:
! 1405: typedef struct testDesc testDesc;
! 1406: typedef testDesc *testDescPtr;
! 1407: struct testDesc {
! 1408: const char *desc; /* descripton of the test */
! 1409: functest func; /* function implementing the test */
! 1410: };
! 1411:
! 1412: static
! 1413: testDesc testDescriptions[] = {
! 1414: { "Parsing of huge files with the sax parser", saxTest},
! 1415: /* { "Parsing of huge files with the tree parser", treeTest}, */
! 1416: #ifdef LIBXML_READER_ENABLED
! 1417: { "Parsing of huge files with the reader", readerTest},
! 1418: #endif
! 1419: {NULL, NULL}
! 1420: };
! 1421:
! 1422: typedef struct testException testException;
! 1423: typedef testException *testExceptionPtr;
! 1424: struct testException {
! 1425: unsigned int test; /* the parser test number */
! 1426: unsigned int limit; /* the limit test number */
! 1427: int fail; /* new fail value or -1*/
! 1428: size_t size; /* new limit value or 0 */
! 1429: };
! 1430:
! 1431: static
! 1432: testException testExceptions[] = {
! 1433: /* the SAX parser doesn't hit a limit of XML_MAX_TEXT_LENGTH text nodes */
! 1434: { 0, 1, 0, 0},
! 1435: };
! 1436:
! 1437: static int
! 1438: launchTests(testDescPtr tst, unsigned int test) {
! 1439: int res = 0, err = 0;
! 1440: unsigned int i, j;
! 1441: size_t limit;
! 1442: int fail;
! 1443:
! 1444: if (tst == NULL) return(-1);
! 1445:
! 1446: for (i = 0;i < sizeof(limitDescriptions)/sizeof(limitDescriptions[0]);i++) {
! 1447: limit = limitDescriptions[i].limit;
! 1448: fail = limitDescriptions[i].fail;
! 1449: /*
! 1450: * Handle exceptions if any
! 1451: */
! 1452: for (j = 0;j < sizeof(testExceptions)/sizeof(testExceptions[0]);j++) {
! 1453: if ((testExceptions[j].test == test) &&
! 1454: (testExceptions[j].limit == i)) {
! 1455: if (testExceptions[j].fail != -1)
! 1456: fail = testExceptions[j].fail;
! 1457: if (testExceptions[j].size != 0)
! 1458: limit = testExceptions[j].size;
! 1459: break;
! 1460: }
! 1461: }
! 1462: res = tst->func(limitDescriptions[i].name, limit,
! 1463: limitDescriptions[i].options, fail);
! 1464: if (res != 0) {
! 1465: nb_errors++;
! 1466: err++;
! 1467: }
! 1468: }
! 1469: return(err);
! 1470: }
! 1471:
! 1472:
! 1473: static int
! 1474: runtest(unsigned int i) {
! 1475: int ret = 0, res;
! 1476: int old_errors, old_tests, old_leaks;
! 1477:
! 1478: old_errors = nb_errors;
! 1479: old_tests = nb_tests;
! 1480: old_leaks = nb_leaks;
! 1481: if ((tests_quiet == 0) && (testDescriptions[i].desc != NULL))
! 1482: printf("## %s\n", testDescriptions[i].desc);
! 1483: res = launchTests(&testDescriptions[i], i);
! 1484: if (res != 0)
! 1485: ret++;
! 1486: if (verbose) {
! 1487: if ((nb_errors == old_errors) && (nb_leaks == old_leaks))
! 1488: printf("Ran %d tests, no errors\n", nb_tests - old_tests);
! 1489: else
! 1490: printf("Ran %d tests, %d errors, %d leaks\n",
! 1491: nb_tests - old_tests,
! 1492: nb_errors - old_errors,
! 1493: nb_leaks - old_leaks);
! 1494: }
! 1495: return(ret);
! 1496: }
! 1497:
! 1498: static int
! 1499: launchCrazySAX(unsigned int test, int fail) {
! 1500: int res = 0, err = 0;
! 1501:
! 1502: crazy_indx = test;
! 1503:
! 1504: res = saxTest("crazy::test", XML_MAX_LOOKUP_LIMIT - CHUNK, 0, fail);
! 1505: if (res != 0) {
! 1506: nb_errors++;
! 1507: err++;
! 1508: }
! 1509: if (tests_quiet == 0)
! 1510: fprintf(stderr, "%c", crazy[test]);
! 1511:
! 1512: return(err);
! 1513: }
! 1514:
! 1515: static int
! 1516: launchCrazy(unsigned int test, int fail) {
! 1517: int res = 0, err = 0;
! 1518:
! 1519: crazy_indx = test;
! 1520:
! 1521: res = readerTest("crazy::test", XML_MAX_LOOKUP_LIMIT - CHUNK, 0, fail);
! 1522: if (res != 0) {
! 1523: nb_errors++;
! 1524: err++;
! 1525: }
! 1526: if (tests_quiet == 0)
! 1527: fprintf(stderr, "%c", crazy[test]);
! 1528:
! 1529: return(err);
! 1530: }
! 1531:
! 1532: static int get_crazy_fail(int test) {
! 1533: /*
! 1534: * adding 1000000 of character 'a' leads to parser failure mostly
! 1535: * everywhere except in those special spots. Need to be updated
! 1536: * each time crazy is updated
! 1537: */
! 1538: int fail = 1;
! 1539: if ((test == 44) || /* PI in Misc */
! 1540: ((test >= 50) && (test <= 55)) || /* Comment in Misc */
! 1541: (test == 79) || /* PI in DTD */
! 1542: ((test >= 85) && (test <= 90)) || /* Comment in DTD */
! 1543: (test == 154) || /* PI in Misc */
! 1544: ((test >= 160) && (test <= 165)) || /* Comment in Misc */
! 1545: ((test >= 178) && (test <= 181)) || /* attribute value */
! 1546: (test == 183) || /* Text */
! 1547: (test == 189) || /* PI in Content */
! 1548: (test == 191) || /* Text */
! 1549: ((test >= 195) && (test <= 200)) || /* Comment in Content */
! 1550: ((test >= 203) && (test <= 206)) || /* Text */
! 1551: (test == 215) || (test == 216) || /* in CDATA */
! 1552: (test == 219) || /* Text */
! 1553: (test == 231) || /* PI in Misc */
! 1554: ((test >= 237) && (test <= 242))) /* Comment in Misc */
! 1555: fail = 0;
! 1556: return(fail);
! 1557: }
! 1558:
! 1559: static int
! 1560: runcrazy(void) {
! 1561: int ret = 0, res = 0;
! 1562: int old_errors, old_tests, old_leaks;
! 1563: unsigned int i;
! 1564:
! 1565: old_errors = nb_errors;
! 1566: old_tests = nb_tests;
! 1567: old_leaks = nb_leaks;
! 1568: if (tests_quiet == 0) {
! 1569: printf("## Crazy tests on reader\n");
! 1570: }
! 1571: for (i = 0;i < strlen(crazy);i++) {
! 1572: res += launchCrazy(i, get_crazy_fail(i));
! 1573: if (res != 0)
! 1574: ret++;
! 1575: }
! 1576: if (tests_quiet == 0) {
! 1577: printf("\n## Crazy tests on SAX\n");
! 1578: }
! 1579: for (i = 0;i < strlen(crazy);i++) {
! 1580: res += launchCrazySAX(i, get_crazy_fail(i));
! 1581: if (res != 0)
! 1582: ret++;
! 1583: }
! 1584: if (tests_quiet == 0)
! 1585: fprintf(stderr, "\n");
! 1586: if (verbose) {
! 1587: if ((nb_errors == old_errors) && (nb_leaks == old_leaks))
! 1588: printf("Ran %d tests, no errors\n", nb_tests - old_tests);
! 1589: else
! 1590: printf("Ran %d tests, %d errors, %d leaks\n",
! 1591: nb_tests - old_tests,
! 1592: nb_errors - old_errors,
! 1593: nb_leaks - old_leaks);
! 1594: }
! 1595: return(ret);
! 1596: }
! 1597:
! 1598:
! 1599: int
! 1600: main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
! 1601: int i, a, ret = 0;
! 1602: int subset = 0;
! 1603:
! 1604: fillFilling();
! 1605: initializeLibxml2();
! 1606:
! 1607: for (a = 1; a < argc;a++) {
! 1608: if (!strcmp(argv[a], "-v"))
! 1609: verbose = 1;
! 1610: else if (!strcmp(argv[a], "-quiet"))
! 1611: tests_quiet = 1;
! 1612: else if (!strcmp(argv[a], "-crazy"))
! 1613: subset = 1;
! 1614: }
! 1615: if (subset == 0) {
! 1616: for (i = 0; testDescriptions[i].func != NULL; i++) {
! 1617: ret += runtest(i);
! 1618: }
! 1619: }
! 1620: ret += runcrazy();
! 1621: if ((nb_errors == 0) && (nb_leaks == 0)) {
! 1622: ret = 0;
! 1623: printf("Total %d tests, no errors\n",
! 1624: nb_tests);
! 1625: } else {
! 1626: ret = 1;
! 1627: printf("Total %d tests, %d errors, %d leaks\n",
! 1628: nb_tests, nb_errors, nb_leaks);
! 1629: }
! 1630: xmlCleanupParser();
! 1631: xmlMemoryDump();
! 1632:
! 1633: return(ret);
! 1634: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to testlimits.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