Annotation of embedaddon/libxml2/testrecurse.c, revision 1.1
1.1 ! misho 1: /*
! 2: * testrecurse.c: C program to run libxml2 regression tests checking entities
! 3: * recursions
! 4: *
! 5: * To compile on Unixes:
! 6: * cc -o testrecurse `xml2-config --cflags` testrecurse.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:
! 27: #include <libxml/parser.h>
! 28: #include <libxml/tree.h>
! 29: #include <libxml/uri.h>
! 30: #ifdef LIBXML_READER_ENABLED
! 31: #include <libxml/xmlreader.h>
! 32: #endif
! 33:
! 34: /*
! 35: * O_BINARY is just for Windows compatibility - if it isn't defined
! 36: * on this system, avoid any compilation error
! 37: */
! 38: #ifdef O_BINARY
! 39: #define RD_FLAGS O_RDONLY | O_BINARY
! 40: #else
! 41: #define RD_FLAGS O_RDONLY
! 42: #endif
! 43:
! 44: typedef int (*functest) (const char *filename, const char *result,
! 45: const char *error, int options);
! 46:
! 47: typedef struct testDesc testDesc;
! 48: typedef testDesc *testDescPtr;
! 49: struct testDesc {
! 50: const char *desc; /* descripton of the test */
! 51: functest func; /* function implementing the test */
! 52: const char *in; /* glob to path for input files */
! 53: const char *out; /* output directory */
! 54: const char *suffix;/* suffix for output files */
! 55: const char *err; /* suffix for error output files */
! 56: int options; /* parser options for the test */
! 57: };
! 58:
! 59: static int checkTestFile(const char *filename);
! 60:
! 61:
! 62: #if defined(_WIN32) && !defined(__CYGWIN__)
! 63:
! 64: #include <windows.h>
! 65: #include <io.h>
! 66:
! 67: typedef struct
! 68: {
! 69: size_t gl_pathc; /* Count of paths matched so far */
! 70: char **gl_pathv; /* List of matched pathnames. */
! 71: size_t gl_offs; /* Slots to reserve in 'gl_pathv'. */
! 72: } glob_t;
! 73:
! 74: #define GLOB_DOOFFS 0
! 75: static int glob(const char *pattern, int flags,
! 76: int errfunc(const char *epath, int eerrno),
! 77: glob_t *pglob) {
! 78: glob_t *ret;
! 79: WIN32_FIND_DATA FindFileData;
! 80: HANDLE hFind;
! 81: unsigned int nb_paths = 0;
! 82: char directory[500];
! 83: int len;
! 84:
! 85: if ((pattern == NULL) || (pglob == NULL)) return(-1);
! 86:
! 87: strncpy(directory, pattern, 499);
! 88: for (len = strlen(directory);len >= 0;len--) {
! 89: if (directory[len] == '/') {
! 90: len++;
! 91: directory[len] = 0;
! 92: break;
! 93: }
! 94: }
! 95: if (len <= 0)
! 96: len = 0;
! 97:
! 98:
! 99: ret = pglob;
! 100: memset(ret, 0, sizeof(glob_t));
! 101:
! 102: hFind = FindFirstFileA(pattern, &FindFileData);
! 103: if (hFind == INVALID_HANDLE_VALUE)
! 104: return(0);
! 105: nb_paths = 20;
! 106: ret->gl_pathv = (char **) malloc(nb_paths * sizeof(char *));
! 107: if (ret->gl_pathv == NULL) {
! 108: FindClose(hFind);
! 109: return(-1);
! 110: }
! 111: strncpy(directory + len, FindFileData.cFileName, 499 - len);
! 112: ret->gl_pathv[ret->gl_pathc] = strdup(directory);
! 113: if (ret->gl_pathv[ret->gl_pathc] == NULL)
! 114: goto done;
! 115: ret->gl_pathc++;
! 116: while(FindNextFileA(hFind, &FindFileData)) {
! 117: if (FindFileData.cFileName[0] == '.')
! 118: continue;
! 119: if (ret->gl_pathc + 2 > nb_paths) {
! 120: char **tmp = realloc(ret->gl_pathv, nb_paths * 2 * sizeof(char *));
! 121: if (tmp == NULL)
! 122: break;
! 123: ret->gl_pathv = tmp;
! 124: nb_paths *= 2;
! 125: }
! 126: strncpy(directory + len, FindFileData.cFileName, 499 - len);
! 127: ret->gl_pathv[ret->gl_pathc] = strdup(directory);
! 128: if (ret->gl_pathv[ret->gl_pathc] == NULL)
! 129: break;
! 130: ret->gl_pathc++;
! 131: }
! 132: ret->gl_pathv[ret->gl_pathc] = NULL;
! 133:
! 134: done:
! 135: FindClose(hFind);
! 136: return(0);
! 137: }
! 138:
! 139:
! 140:
! 141: static void globfree(glob_t *pglob) {
! 142: unsigned int i;
! 143: if (pglob == NULL)
! 144: return;
! 145:
! 146: for (i = 0;i < pglob->gl_pathc;i++) {
! 147: if (pglob->gl_pathv[i] != NULL)
! 148: free(pglob->gl_pathv[i]);
! 149: }
! 150: }
! 151: #define vsnprintf _vsnprintf
! 152: #define snprintf _snprintf
! 153: #else
! 154: #include <glob.h>
! 155: #endif
! 156:
! 157: /************************************************************************
! 158: * *
! 159: * Huge document generator *
! 160: * *
! 161: ************************************************************************/
! 162:
! 163: #include <libxml/xmlIO.h>
! 164:
! 165:
! 166: static const char *start = "<!DOCTYPE foo [\
! 167: <!ENTITY f 'some internal data'> \
! 168: <!ENTITY e '&f;&f;'> \
! 169: <!ENTITY d '&e;&e;'> \
! 170: ]> \
! 171: <foo>";
! 172:
! 173: static const char *segment = " <bar>&e; &f; &d;</bar>\n";
! 174: static const char *finish = "</foo>";
! 175:
! 176: static int curseg = 0;
! 177: static const char *current;
! 178: static int rlen;
! 179:
! 180: /**
! 181: * hugeMatch:
! 182: * @URI: an URI to test
! 183: *
! 184: * Check for an huge: query
! 185: *
! 186: * Returns 1 if yes and 0 if another Input module should be used
! 187: */
! 188: static int
! 189: hugeMatch(const char * URI) {
! 190: if ((URI != NULL) && (!strncmp(URI, "huge:", 4)))
! 191: return(1);
! 192: return(0);
! 193: }
! 194:
! 195: /**
! 196: * hugeOpen:
! 197: * @URI: an URI to test
! 198: *
! 199: * Return a pointer to the huge: query handler, in this example simply
! 200: * the current pointer...
! 201: *
! 202: * Returns an Input context or NULL in case or error
! 203: */
! 204: static void *
! 205: hugeOpen(const char * URI) {
! 206: if ((URI == NULL) || (strncmp(URI, "huge:", 4)))
! 207: return(NULL);
! 208: rlen = strlen(start);
! 209: current = start;
! 210: return((void *) current);
! 211: }
! 212:
! 213: /**
! 214: * hugeClose:
! 215: * @context: the read context
! 216: *
! 217: * Close the huge: query handler
! 218: *
! 219: * Returns 0 or -1 in case of error
! 220: */
! 221: static int
! 222: hugeClose(void * context) {
! 223: if (context == NULL) return(-1);
! 224: return(0);
! 225: }
! 226:
! 227: #define MAX_NODES 1000000
! 228:
! 229: /**
! 230: * hugeRead:
! 231: * @context: the read context
! 232: * @buffer: where to store data
! 233: * @len: number of bytes to read
! 234: *
! 235: * Implement an huge: query read.
! 236: *
! 237: * Returns the number of bytes read or -1 in case of error
! 238: */
! 239: static int
! 240: hugeRead(void *context, char *buffer, int len)
! 241: {
! 242: if ((context == NULL) || (buffer == NULL) || (len < 0))
! 243: return (-1);
! 244:
! 245: if (len >= rlen) {
! 246: if (curseg >= MAX_NODES + 1) {
! 247: rlen = 0;
! 248: return(0);
! 249: }
! 250: len = rlen;
! 251: rlen = 0;
! 252: memcpy(buffer, current, len);
! 253: curseg ++;
! 254: if (curseg == MAX_NODES) {
! 255: fprintf(stderr, "\n");
! 256: rlen = strlen(finish);
! 257: current = finish;
! 258: } else {
! 259: if (curseg % (MAX_NODES / 10) == 0)
! 260: fprintf(stderr, ".");
! 261: rlen = strlen(segment);
! 262: current = segment;
! 263: }
! 264: } else {
! 265: memcpy(buffer, current, len);
! 266: rlen -= len;
! 267: current += len;
! 268: }
! 269: return (len);
! 270: }
! 271:
! 272: /************************************************************************
! 273: * *
! 274: * Libxml2 specific routines *
! 275: * *
! 276: ************************************************************************/
! 277:
! 278: static int nb_tests = 0;
! 279: static int nb_errors = 0;
! 280: static int nb_leaks = 0;
! 281: static int extraMemoryFromResolver = 0;
! 282:
! 283: static int
! 284: fatalError(void) {
! 285: fprintf(stderr, "Exitting tests on fatal error\n");
! 286: exit(1);
! 287: }
! 288:
! 289: /*
! 290: * We need to trap calls to the resolver to not account memory for the catalog
! 291: * which is shared to the current running test. We also don't want to have
! 292: * network downloads modifying tests.
! 293: */
! 294: static xmlParserInputPtr
! 295: testExternalEntityLoader(const char *URL, const char *ID,
! 296: xmlParserCtxtPtr ctxt) {
! 297: xmlParserInputPtr ret;
! 298:
! 299: if (checkTestFile(URL)) {
! 300: ret = xmlNoNetExternalEntityLoader(URL, ID, ctxt);
! 301: } else {
! 302: int memused = xmlMemUsed();
! 303: ret = xmlNoNetExternalEntityLoader(URL, ID, ctxt);
! 304: extraMemoryFromResolver += xmlMemUsed() - memused;
! 305: }
! 306:
! 307: return(ret);
! 308: }
! 309:
! 310: /*
! 311: * Trapping the error messages at the generic level to grab the equivalent of
! 312: * stderr messages on CLI tools.
! 313: */
! 314: static char testErrors[32769];
! 315: static int testErrorsSize = 0;
! 316:
! 317: static void XMLCDECL
! 318: channel(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) {
! 319: va_list args;
! 320: int res;
! 321:
! 322: if (testErrorsSize >= 32768)
! 323: return;
! 324: va_start(args, msg);
! 325: res = vsnprintf(&testErrors[testErrorsSize],
! 326: 32768 - testErrorsSize,
! 327: msg, args);
! 328: va_end(args);
! 329: if (testErrorsSize + res >= 32768) {
! 330: /* buffer is full */
! 331: testErrorsSize = 32768;
! 332: testErrors[testErrorsSize] = 0;
! 333: } else {
! 334: testErrorsSize += res;
! 335: }
! 336: testErrors[testErrorsSize] = 0;
! 337: }
! 338:
! 339: /**
! 340: * xmlParserPrintFileContext:
! 341: * @input: an xmlParserInputPtr input
! 342: *
! 343: * Displays current context within the input content for error tracking
! 344: */
! 345:
! 346: static void
! 347: xmlParserPrintFileContextInternal(xmlParserInputPtr input ,
! 348: xmlGenericErrorFunc chanl, void *data ) {
! 349: const xmlChar *cur, *base;
! 350: unsigned int n, col; /* GCC warns if signed, because compared with sizeof() */
! 351: xmlChar content[81]; /* space for 80 chars + line terminator */
! 352: xmlChar *ctnt;
! 353:
! 354: if (input == NULL) return;
! 355: cur = input->cur;
! 356: base = input->base;
! 357: /* skip backwards over any end-of-lines */
! 358: while ((cur > base) && ((*(cur) == '\n') || (*(cur) == '\r'))) {
! 359: cur--;
! 360: }
! 361: n = 0;
! 362: /* search backwards for beginning-of-line (to max buff size) */
! 363: while ((n++ < (sizeof(content)-1)) && (cur > base) &&
! 364: (*(cur) != '\n') && (*(cur) != '\r'))
! 365: cur--;
! 366: if ((*(cur) == '\n') || (*(cur) == '\r')) cur++;
! 367: /* calculate the error position in terms of the current position */
! 368: col = input->cur - cur;
! 369: /* search forward for end-of-line (to max buff size) */
! 370: n = 0;
! 371: ctnt = content;
! 372: /* copy selected text to our buffer */
! 373: while ((*cur != 0) && (*(cur) != '\n') &&
! 374: (*(cur) != '\r') && (n < sizeof(content)-1)) {
! 375: *ctnt++ = *cur++;
! 376: n++;
! 377: }
! 378: *ctnt = 0;
! 379: /* print out the selected text */
! 380: chanl(data ,"%s\n", content);
! 381: /* create blank line with problem pointer */
! 382: n = 0;
! 383: ctnt = content;
! 384: /* (leave buffer space for pointer + line terminator) */
! 385: while ((n<col) && (n++ < sizeof(content)-2) && (*ctnt != 0)) {
! 386: if (*(ctnt) != '\t')
! 387: *(ctnt) = ' ';
! 388: ctnt++;
! 389: }
! 390: *ctnt++ = '^';
! 391: *ctnt = 0;
! 392: chanl(data ,"%s\n", content);
! 393: }
! 394:
! 395: static void
! 396: testStructuredErrorHandler(void *ctx ATTRIBUTE_UNUSED, xmlErrorPtr err) {
! 397: char *file = NULL;
! 398: int line = 0;
! 399: int code = -1;
! 400: int domain;
! 401: void *data = NULL;
! 402: const char *str;
! 403: const xmlChar *name = NULL;
! 404: xmlNodePtr node;
! 405: xmlErrorLevel level;
! 406: xmlParserInputPtr input = NULL;
! 407: xmlParserInputPtr cur = NULL;
! 408: xmlParserCtxtPtr ctxt = NULL;
! 409:
! 410: if (err == NULL)
! 411: return;
! 412:
! 413: file = err->file;
! 414: line = err->line;
! 415: code = err->code;
! 416: domain = err->domain;
! 417: level = err->level;
! 418: node = err->node;
! 419: if ((domain == XML_FROM_PARSER) || (domain == XML_FROM_HTML) ||
! 420: (domain == XML_FROM_DTD) || (domain == XML_FROM_NAMESPACE) ||
! 421: (domain == XML_FROM_IO) || (domain == XML_FROM_VALID)) {
! 422: ctxt = err->ctxt;
! 423: }
! 424: str = err->message;
! 425:
! 426: if (code == XML_ERR_OK)
! 427: return;
! 428:
! 429: if ((node != NULL) && (node->type == XML_ELEMENT_NODE))
! 430: name = node->name;
! 431:
! 432: /*
! 433: * Maintain the compatibility with the legacy error handling
! 434: */
! 435: if (ctxt != NULL) {
! 436: input = ctxt->input;
! 437: if ((input != NULL) && (input->filename == NULL) &&
! 438: (ctxt->inputNr > 1)) {
! 439: cur = input;
! 440: input = ctxt->inputTab[ctxt->inputNr - 2];
! 441: }
! 442: if (input != NULL) {
! 443: if (input->filename)
! 444: channel(data, "%s:%d: ", input->filename, input->line);
! 445: else if ((line != 0) && (domain == XML_FROM_PARSER))
! 446: channel(data, "Entity: line %d: ", input->line);
! 447: }
! 448: } else {
! 449: if (file != NULL)
! 450: channel(data, "%s:%d: ", file, line);
! 451: else if ((line != 0) && (domain == XML_FROM_PARSER))
! 452: channel(data, "Entity: line %d: ", line);
! 453: }
! 454: if (name != NULL) {
! 455: channel(data, "element %s: ", name);
! 456: }
! 457: if (code == XML_ERR_OK)
! 458: return;
! 459: switch (domain) {
! 460: case XML_FROM_PARSER:
! 461: channel(data, "parser ");
! 462: break;
! 463: case XML_FROM_NAMESPACE:
! 464: channel(data, "namespace ");
! 465: break;
! 466: case XML_FROM_DTD:
! 467: case XML_FROM_VALID:
! 468: channel(data, "validity ");
! 469: break;
! 470: case XML_FROM_HTML:
! 471: channel(data, "HTML parser ");
! 472: break;
! 473: case XML_FROM_MEMORY:
! 474: channel(data, "memory ");
! 475: break;
! 476: case XML_FROM_OUTPUT:
! 477: channel(data, "output ");
! 478: break;
! 479: case XML_FROM_IO:
! 480: channel(data, "I/O ");
! 481: break;
! 482: case XML_FROM_XINCLUDE:
! 483: channel(data, "XInclude ");
! 484: break;
! 485: case XML_FROM_XPATH:
! 486: channel(data, "XPath ");
! 487: break;
! 488: case XML_FROM_XPOINTER:
! 489: channel(data, "parser ");
! 490: break;
! 491: case XML_FROM_REGEXP:
! 492: channel(data, "regexp ");
! 493: break;
! 494: case XML_FROM_MODULE:
! 495: channel(data, "module ");
! 496: break;
! 497: case XML_FROM_SCHEMASV:
! 498: channel(data, "Schemas validity ");
! 499: break;
! 500: case XML_FROM_SCHEMASP:
! 501: channel(data, "Schemas parser ");
! 502: break;
! 503: case XML_FROM_RELAXNGP:
! 504: channel(data, "Relax-NG parser ");
! 505: break;
! 506: case XML_FROM_RELAXNGV:
! 507: channel(data, "Relax-NG validity ");
! 508: break;
! 509: case XML_FROM_CATALOG:
! 510: channel(data, "Catalog ");
! 511: break;
! 512: case XML_FROM_C14N:
! 513: channel(data, "C14N ");
! 514: break;
! 515: case XML_FROM_XSLT:
! 516: channel(data, "XSLT ");
! 517: break;
! 518: default:
! 519: break;
! 520: }
! 521: if (code == XML_ERR_OK)
! 522: return;
! 523: switch (level) {
! 524: case XML_ERR_NONE:
! 525: channel(data, ": ");
! 526: break;
! 527: case XML_ERR_WARNING:
! 528: channel(data, "warning : ");
! 529: break;
! 530: case XML_ERR_ERROR:
! 531: channel(data, "error : ");
! 532: break;
! 533: case XML_ERR_FATAL:
! 534: channel(data, "error : ");
! 535: break;
! 536: }
! 537: if (code == XML_ERR_OK)
! 538: return;
! 539: if (str != NULL) {
! 540: int len;
! 541: len = xmlStrlen((const xmlChar *)str);
! 542: if ((len > 0) && (str[len - 1] != '\n'))
! 543: channel(data, "%s\n", str);
! 544: else
! 545: channel(data, "%s", str);
! 546: } else {
! 547: channel(data, "%s\n", "out of memory error");
! 548: }
! 549: if (code == XML_ERR_OK)
! 550: return;
! 551:
! 552: if (ctxt != NULL) {
! 553: xmlParserPrintFileContextInternal(input, channel, data);
! 554: if (cur != NULL) {
! 555: if (cur->filename)
! 556: channel(data, "%s:%d: \n", cur->filename, cur->line);
! 557: else if ((line != 0) && (domain == XML_FROM_PARSER))
! 558: channel(data, "Entity: line %d: \n", cur->line);
! 559: xmlParserPrintFileContextInternal(cur, channel, data);
! 560: }
! 561: }
! 562: if ((domain == XML_FROM_XPATH) && (err->str1 != NULL) &&
! 563: (err->int1 < 100) &&
! 564: (err->int1 < xmlStrlen((const xmlChar *)err->str1))) {
! 565: xmlChar buf[150];
! 566: int i;
! 567:
! 568: channel(data, "%s\n", err->str1);
! 569: for (i=0;i < err->int1;i++)
! 570: buf[i] = ' ';
! 571: buf[i++] = '^';
! 572: buf[i] = 0;
! 573: channel(data, "%s\n", buf);
! 574: }
! 575: }
! 576:
! 577: static void
! 578: initializeLibxml2(void) {
! 579: xmlGetWarningsDefaultValue = 0;
! 580: xmlPedanticParserDefault(0);
! 581:
! 582: xmlMemSetup(xmlMemFree, xmlMemMalloc, xmlMemRealloc, xmlMemoryStrdup);
! 583: xmlInitParser();
! 584: xmlSetExternalEntityLoader(testExternalEntityLoader);
! 585: xmlSetStructuredErrorFunc(NULL, testStructuredErrorHandler);
! 586: /*
! 587: * register the new I/O handlers
! 588: */
! 589: if (xmlRegisterInputCallbacks(hugeMatch, hugeOpen,
! 590: hugeRead, hugeClose) < 0) {
! 591: fprintf(stderr, "failed to register Huge handler\n");
! 592: exit(1);
! 593: }
! 594: }
! 595:
! 596: /************************************************************************
! 597: * *
! 598: * File name and path utilities *
! 599: * *
! 600: ************************************************************************/
! 601:
! 602: static const char *baseFilename(const char *filename) {
! 603: const char *cur;
! 604: if (filename == NULL)
! 605: return(NULL);
! 606: cur = &filename[strlen(filename)];
! 607: while ((cur > filename) && (*cur != '/'))
! 608: cur--;
! 609: if (*cur == '/')
! 610: return(cur + 1);
! 611: return(cur);
! 612: }
! 613:
! 614: static char *resultFilename(const char *filename, const char *out,
! 615: const char *suffix) {
! 616: const char *base;
! 617: char res[500];
! 618: char suffixbuff[500];
! 619:
! 620: /*************
! 621: if ((filename[0] == 't') && (filename[1] == 'e') &&
! 622: (filename[2] == 's') && (filename[3] == 't') &&
! 623: (filename[4] == '/'))
! 624: filename = &filename[5];
! 625: *************/
! 626:
! 627: base = baseFilename(filename);
! 628: if (suffix == NULL)
! 629: suffix = ".tmp";
! 630: if (out == NULL)
! 631: out = "";
! 632:
! 633: strncpy(suffixbuff,suffix,499);
! 634: #ifdef VMS
! 635: if(strstr(base,".") && suffixbuff[0]=='.')
! 636: suffixbuff[0]='_';
! 637: #endif
! 638:
! 639: snprintf(res, 499, "%s%s%s", out, base, suffixbuff);
! 640: res[499] = 0;
! 641: return(strdup(res));
! 642: }
! 643:
! 644: static int checkTestFile(const char *filename) {
! 645: struct stat buf;
! 646:
! 647: if (stat(filename, &buf) == -1)
! 648: return(0);
! 649:
! 650: #if defined(_WIN32) && !defined(__CYGWIN__)
! 651: if (!(buf.st_mode & _S_IFREG))
! 652: return(0);
! 653: #else
! 654: if (!S_ISREG(buf.st_mode))
! 655: return(0);
! 656: #endif
! 657:
! 658: return(1);
! 659: }
! 660:
! 661:
! 662:
! 663: /************************************************************************
! 664: * *
! 665: * Test to detect or not recursive entities *
! 666: * *
! 667: ************************************************************************/
! 668: /**
! 669: * recursiveDetectTest:
! 670: * @filename: the file to parse
! 671: * @result: the file with expected result
! 672: * @err: the file with error messages: unused
! 673: *
! 674: * Parse a file loading DTD and replacing entities check it fails for
! 675: * lol cases
! 676: *
! 677: * Returns 0 in case of success, an error code otherwise
! 678: */
! 679: static int
! 680: recursiveDetectTest(const char *filename,
! 681: const char *result ATTRIBUTE_UNUSED,
! 682: const char *err ATTRIBUTE_UNUSED,
! 683: int options ATTRIBUTE_UNUSED) {
! 684: xmlDocPtr doc;
! 685: xmlParserCtxtPtr ctxt;
! 686: int res = 0;
! 687: int mem;
! 688:
! 689: nb_tests++;
! 690:
! 691: ctxt = xmlNewParserCtxt();
! 692: mem = xmlMemUsed();
! 693: /*
! 694: * base of the test, parse with the old API
! 695: */
! 696: doc = xmlCtxtReadFile(ctxt, filename, NULL,
! 697: XML_PARSE_NOENT | XML_PARSE_DTDLOAD);
! 698: if ((doc != NULL) || (ctxt->lastError.code != XML_ERR_ENTITY_LOOP)) {
! 699: fprintf(stderr, "Failed to detect recursion in %s\n", filename);
! 700: xmlFreeParserCtxt(ctxt);
! 701: xmlFreeDoc(doc);
! 702: return(1);
! 703: }
! 704: xmlFreeParserCtxt(ctxt);
! 705:
! 706: return(res);
! 707: }
! 708:
! 709: /**
! 710: * notRecursiveDetectTest:
! 711: * @filename: the file to parse
! 712: * @result: the file with expected result
! 713: * @err: the file with error messages: unused
! 714: *
! 715: * Parse a file loading DTD and replacing entities check it works for
! 716: * good cases
! 717: *
! 718: * Returns 0 in case of success, an error code otherwise
! 719: */
! 720: static int
! 721: notRecursiveDetectTest(const char *filename,
! 722: const char *result ATTRIBUTE_UNUSED,
! 723: const char *err ATTRIBUTE_UNUSED,
! 724: int options ATTRIBUTE_UNUSED) {
! 725: xmlDocPtr doc;
! 726: xmlParserCtxtPtr ctxt;
! 727: int res = 0;
! 728: int mem;
! 729:
! 730: nb_tests++;
! 731:
! 732: ctxt = xmlNewParserCtxt();
! 733: mem = xmlMemUsed();
! 734: /*
! 735: * base of the test, parse with the old API
! 736: */
! 737: doc = xmlCtxtReadFile(ctxt, filename, NULL,
! 738: XML_PARSE_NOENT | XML_PARSE_DTDLOAD);
! 739: if (doc == NULL) {
! 740: fprintf(stderr, "Failed to parse correct file %s\n", filename);
! 741: xmlFreeParserCtxt(ctxt);
! 742: return(1);
! 743: }
! 744: xmlFreeDoc(doc);
! 745: xmlFreeParserCtxt(ctxt);
! 746:
! 747: return(res);
! 748: }
! 749:
! 750: #ifdef LIBXML_READER_ENABLED
! 751: /**
! 752: * notRecursiveHugeTest:
! 753: * @filename: the file to parse
! 754: * @result: the file with expected result
! 755: * @err: the file with error messages: unused
! 756: *
! 757: * Parse a memory generated file
! 758: * good cases
! 759: *
! 760: * Returns 0 in case of success, an error code otherwise
! 761: */
! 762: static int
! 763: notRecursiveHugeTest(const char *filename ATTRIBUTE_UNUSED,
! 764: const char *result ATTRIBUTE_UNUSED,
! 765: const char *err ATTRIBUTE_UNUSED,
! 766: int options ATTRIBUTE_UNUSED) {
! 767: xmlTextReaderPtr reader;
! 768: int res = 0;
! 769: int ret;
! 770:
! 771: nb_tests++;
! 772:
! 773: reader = xmlReaderForFile("huge:test" , NULL,
! 774: XML_PARSE_NOENT | XML_PARSE_DTDLOAD);
! 775: if (reader == NULL) {
! 776: fprintf(stderr, "Failed to open huge:test\n");
! 777: return(1);
! 778: }
! 779: ret = xmlTextReaderRead(reader);
! 780: while (ret == 1) {
! 781: ret = xmlTextReaderRead(reader);
! 782: }
! 783: if (ret != 0) {
! 784: fprintf(stderr, "Failed to parser huge:test with entities\n");
! 785: res = 1;
! 786: }
! 787: xmlFreeTextReader(reader);
! 788:
! 789: return(res);
! 790: }
! 791: #endif
! 792:
! 793: /************************************************************************
! 794: * *
! 795: * Tests Descriptions *
! 796: * *
! 797: ************************************************************************/
! 798:
! 799: static
! 800: testDesc testDescriptions[] = {
! 801: { "Parsing recursive test cases" ,
! 802: recursiveDetectTest, "./test/recurse/lol*.xml", NULL, NULL, NULL,
! 803: 0 },
! 804: { "Parsing non-recursive test cases" ,
! 805: notRecursiveDetectTest, "./test/recurse/good*.xml", NULL, NULL, NULL,
! 806: 0 },
! 807: #ifdef LIBXML_READER_ENABLED
! 808: { "Parsing non-recursive huge case" ,
! 809: notRecursiveHugeTest, NULL, NULL, NULL, NULL,
! 810: 0 },
! 811: #endif
! 812: {NULL, NULL, NULL, NULL, NULL, NULL, 0}
! 813: };
! 814:
! 815: /************************************************************************
! 816: * *
! 817: * The main code driving the tests *
! 818: * *
! 819: ************************************************************************/
! 820:
! 821: static int
! 822: launchTests(testDescPtr tst) {
! 823: int res = 0, err = 0;
! 824: size_t i;
! 825: char *result;
! 826: char *error;
! 827: int mem;
! 828:
! 829: if (tst == NULL) return(-1);
! 830: if (tst->in != NULL) {
! 831: glob_t globbuf;
! 832:
! 833: globbuf.gl_offs = 0;
! 834: glob(tst->in, GLOB_DOOFFS, NULL, &globbuf);
! 835: for (i = 0;i < globbuf.gl_pathc;i++) {
! 836: if (!checkTestFile(globbuf.gl_pathv[i]))
! 837: continue;
! 838: if (tst->suffix != NULL) {
! 839: result = resultFilename(globbuf.gl_pathv[i], tst->out,
! 840: tst->suffix);
! 841: if (result == NULL) {
! 842: fprintf(stderr, "Out of memory !\n");
! 843: fatalError();
! 844: }
! 845: } else {
! 846: result = NULL;
! 847: }
! 848: if (tst->err != NULL) {
! 849: error = resultFilename(globbuf.gl_pathv[i], tst->out,
! 850: tst->err);
! 851: if (error == NULL) {
! 852: fprintf(stderr, "Out of memory !\n");
! 853: fatalError();
! 854: }
! 855: } else {
! 856: error = NULL;
! 857: }
! 858: if ((result) &&(!checkTestFile(result))) {
! 859: fprintf(stderr, "Missing result file %s\n", result);
! 860: } else if ((error) &&(!checkTestFile(error))) {
! 861: fprintf(stderr, "Missing error file %s\n", error);
! 862: } else {
! 863: mem = xmlMemUsed();
! 864: extraMemoryFromResolver = 0;
! 865: testErrorsSize = 0;
! 866: testErrors[0] = 0;
! 867: res = tst->func(globbuf.gl_pathv[i], result, error,
! 868: tst->options | XML_PARSE_COMPACT);
! 869: xmlResetLastError();
! 870: if (res != 0) {
! 871: fprintf(stderr, "File %s generated an error\n",
! 872: globbuf.gl_pathv[i]);
! 873: nb_errors++;
! 874: err++;
! 875: }
! 876: else if (xmlMemUsed() != mem) {
! 877: if ((xmlMemUsed() != mem) &&
! 878: (extraMemoryFromResolver == 0)) {
! 879: fprintf(stderr, "File %s leaked %d bytes\n",
! 880: globbuf.gl_pathv[i], xmlMemUsed() - mem);
! 881: nb_leaks++;
! 882: err++;
! 883: }
! 884: }
! 885: testErrorsSize = 0;
! 886: }
! 887: if (result)
! 888: free(result);
! 889: if (error)
! 890: free(error);
! 891: }
! 892: globfree(&globbuf);
! 893: } else {
! 894: testErrorsSize = 0;
! 895: testErrors[0] = 0;
! 896: extraMemoryFromResolver = 0;
! 897: res = tst->func(NULL, NULL, NULL, tst->options);
! 898: if (res != 0) {
! 899: nb_errors++;
! 900: err++;
! 901: }
! 902: }
! 903: return(err);
! 904: }
! 905:
! 906: static int verbose = 0;
! 907: static int tests_quiet = 0;
! 908:
! 909: static int
! 910: runtest(int i) {
! 911: int ret = 0, res;
! 912: int old_errors, old_tests, old_leaks;
! 913:
! 914: old_errors = nb_errors;
! 915: old_tests = nb_tests;
! 916: old_leaks = nb_leaks;
! 917: if ((tests_quiet == 0) && (testDescriptions[i].desc != NULL))
! 918: printf("## %s\n", testDescriptions[i].desc);
! 919: res = launchTests(&testDescriptions[i]);
! 920: if (res != 0)
! 921: ret++;
! 922: if (verbose) {
! 923: if ((nb_errors == old_errors) && (nb_leaks == old_leaks))
! 924: printf("Ran %d tests, no errors\n", nb_tests - old_tests);
! 925: else
! 926: printf("Ran %d tests, %d errors, %d leaks\n",
! 927: nb_tests - old_tests,
! 928: nb_errors - old_errors,
! 929: nb_leaks - old_leaks);
! 930: }
! 931: return(ret);
! 932: }
! 933:
! 934: int
! 935: main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
! 936: int i, a, ret = 0;
! 937: int subset = 0;
! 938:
! 939: initializeLibxml2();
! 940:
! 941: for (a = 1; a < argc;a++) {
! 942: if (!strcmp(argv[a], "-v"))
! 943: verbose = 1;
! 944: else if (!strcmp(argv[a], "-quiet"))
! 945: tests_quiet = 1;
! 946: else {
! 947: for (i = 0; testDescriptions[i].func != NULL; i++) {
! 948: if (strstr(testDescriptions[i].desc, argv[a])) {
! 949: ret += runtest(i);
! 950: subset++;
! 951: }
! 952: }
! 953: }
! 954: }
! 955: if (subset == 0) {
! 956: for (i = 0; testDescriptions[i].func != NULL; i++) {
! 957: ret += runtest(i);
! 958: }
! 959: }
! 960: if ((nb_errors == 0) && (nb_leaks == 0)) {
! 961: ret = 0;
! 962: printf("Total %d tests, no errors\n",
! 963: nb_tests);
! 964: } else {
! 965: ret = 1;
! 966: printf("Total %d tests, %d errors, %d leaks\n",
! 967: nb_tests, nb_errors, nb_leaks);
! 968: }
! 969: xmlCleanupParser();
! 970: xmlMemoryDump();
! 971:
! 972: return(ret);
! 973: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to testrecurse.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