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