runsuite.c
1 /* 2 * runsuite.c: C program to run libxml2 againts published testsuites 3 * 4 * See Copyright for the status of this software. 5 * 6 * daniel@veillard.com 7 */ 8 9 #include "libxml.h" 10 #include <stdio.h> 11 12 #if !defined(_WIN32) || defined(__CYGWIN__) 13 #include <unistd.h> 14 #endif 15 #include <string.h> 16 #include <sys/types.h> 17 #include <sys/stat.h> 18 #include <fcntl.h> 19 20 #include <libxml/parser.h> 21 #include <libxml/parserInternals.h> 22 #include <libxml/tree.h> 23 #include <libxml/uri.h> 24 #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_XPATH_ENABLED) 25 #include <libxml/xmlreader.h> 26 27 #include <libxml/xpath.h> 28 #include <libxml/xpathInternals.h> 29 30 #include <libxml/relaxng.h> 31 #include <libxml/xmlschemas.h> 32 #include <libxml/xmlschemastypes.h> 33 34 #define LOGFILE "runsuite.log" 35 static FILE *logfile = NULL; 36 static int verbose = 0; 37 38 39 /************************************************************************ 40 * * 41 * File name and path utilities * 42 * * 43 ************************************************************************/ 44 45 static int checkTestFile(const char *filename) { 46 struct stat buf; 47 48 if (stat(filename, &buf) == -1) 49 return(0); 50 51 #if defined(_WIN32) && !defined(__CYGWIN__) 52 if (!(buf.st_mode & _S_IFREG)) 53 return(0); 54 #else 55 if (!S_ISREG(buf.st_mode)) 56 return(0); 57 #endif 58 59 return(1); 60 } 61 62 static xmlChar *composeDir(const xmlChar *dir, const xmlChar *path) { 63 char buf[500]; 64 65 if (dir == NULL) return(xmlStrdup(path)); 66 if (path == NULL) return(NULL); 67 68 snprintf(buf, 500, "%s/%s", (const char *) dir, (const char *) path); 69 return(xmlStrdup((const xmlChar *) buf)); 70 } 71 72 /************************************************************************ 73 * * 74 * Libxml2 specific routines * 75 * * 76 ************************************************************************/ 77 78 static int nb_tests = 0; 79 static int nb_errors = 0; 80 static int nb_internals = 0; 81 static int nb_schematas = 0; 82 static int nb_unimplemented = 0; 83 static int nb_leaks = 0; 84 static int extraMemoryFromResolver = 0; 85 86 static int 87 fatalError(void) { 88 fprintf(stderr, "Exitting tests on fatal error\n"); 89 exit(1); 90 } 91 92 /* 93 * that's needed to implement <resource> 94 */ 95 #define MAX_ENTITIES 20 96 static char *testEntitiesName[MAX_ENTITIES]; 97 static char *testEntitiesValue[MAX_ENTITIES]; 98 static int nb_entities = 0; 99 static void resetEntities(void) { 100 int i; 101 102 for (i = 0;i < nb_entities;i++) { 103 if (testEntitiesName[i] != NULL) 104 xmlFree(testEntitiesName[i]); 105 if (testEntitiesValue[i] != NULL) 106 xmlFree(testEntitiesValue[i]); 107 } 108 nb_entities = 0; 109 } 110 static int addEntity(char *name, char *content) { 111 if (nb_entities >= MAX_ENTITIES) { 112 fprintf(stderr, "Too many entities defined\n"); 113 return(-1); 114 } 115 testEntitiesName[nb_entities] = name; 116 testEntitiesValue[nb_entities] = content; 117 nb_entities++; 118 return(0); 119 } 120 121 /* 122 * We need to trap calls to the resolver to not account memory for the catalog 123 * which is shared to the current running test. We also don't want to have 124 * network downloads modifying tests. 125 */ 126 static xmlParserInputPtr 127 testExternalEntityLoader(const char *URL, const char *ID, 128 xmlParserCtxtPtr ctxt) { 129 xmlParserInputPtr ret; 130 int i; 131 132 for (i = 0;i < nb_entities;i++) { 133 if (!strcmp(testEntitiesName[i], URL)) { 134 ret = xmlNewStringInputStream(ctxt, 135 (const xmlChar *) testEntitiesValue[i]); 136 if (ret != NULL) { 137 ret->filename = (const char *) 138 xmlStrdup((xmlChar *)testEntitiesName[i]); 139 } 140 return(ret); 141 } 142 } 143 if (checkTestFile(URL)) { 144 ret = xmlNoNetExternalEntityLoader(URL, ID, ctxt); 145 } else { 146 int memused = xmlMemUsed(); 147 ret = xmlNoNetExternalEntityLoader(URL, ID, ctxt); 148 extraMemoryFromResolver += xmlMemUsed() - memused; 149 } 150 #if 0 151 if (ret == NULL) { 152 fprintf(stderr, "Failed to find resource %s\n", URL); 153 } 154 #endif 155 156 return(ret); 157 } 158 159 /* 160 * Trapping the error messages at the generic level to grab the equivalent of 161 * stderr messages on CLI tools. 162 */ 163 static char testErrors[32769]; 164 static int testErrorsSize = 0; 165 166 static void test_log(const char *msg, ...) { 167 va_list args; 168 if (logfile != NULL) { 169 fprintf(logfile, "\n------------\n"); 170 va_start(args, msg); 171 vfprintf(logfile, msg, args); 172 va_end(args); 173 fprintf(logfile, "%s", testErrors); 174 testErrorsSize = 0; testErrors[0] = 0; 175 } 176 if (verbose) { 177 va_start(args, msg); 178 vfprintf(stderr, msg, args); 179 va_end(args); 180 } 181 } 182 183 static void 184 testErrorHandler(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) { 185 va_list args; 186 int res; 187 188 if (testErrorsSize >= 32768) 189 return; 190 va_start(args, msg); 191 res = vsnprintf(&testErrors[testErrorsSize], 192 32768 - testErrorsSize, 193 msg, args); 194 va_end(args); 195 if (testErrorsSize + res >= 32768) { 196 /* buffer is full */ 197 testErrorsSize = 32768; 198 testErrors[testErrorsSize] = 0; 199 } else { 200 testErrorsSize += res; 201 } 202 testErrors[testErrorsSize] = 0; 203 } 204 205 static xmlXPathContextPtr ctxtXPath; 206 207 static void 208 initializeLibxml2(void) { 209 xmlGetWarningsDefaultValue = 0; 210 xmlPedanticParserDefault(0); 211 212 xmlMemSetup(xmlMemFree, xmlMemMalloc, xmlMemRealloc, xmlMemoryStrdup); 213 xmlInitParser(); 214 xmlSetExternalEntityLoader(testExternalEntityLoader); 215 ctxtXPath = xmlXPathNewContext(NULL); 216 /* 217 * Deactivate the cache if created; otherwise we have to create/free it 218 * for every test, since it will confuse the memory leak detection. 219 * Note that normally this need not be done, since the cache is not 220 * created until set explicitely with xmlXPathContextSetCache(); 221 * but for test purposes it is sometimes usefull to activate the 222 * cache by default for the whole library. 223 */ 224 if (ctxtXPath->cache != NULL) 225 xmlXPathContextSetCache(ctxtXPath, 0, -1, 0); 226 /* used as default nanemspace in xstc tests */ 227 xmlXPathRegisterNs(ctxtXPath, BAD_CAST "ts", BAD_CAST "TestSuite"); 228 xmlXPathRegisterNs(ctxtXPath, BAD_CAST "xlink", 229 BAD_CAST "http://www.w3.org/1999/xlink"); 230 xmlSetGenericErrorFunc(NULL, testErrorHandler); 231 #ifdef LIBXML_SCHEMAS_ENABLED 232 xmlSchemaInitTypes(); 233 xmlRelaxNGInitTypes(); 234 #endif 235 } 236 237 static xmlNodePtr 238 getNext(xmlNodePtr cur, const char *xpath) { 239 xmlNodePtr ret = NULL; 240 xmlXPathObjectPtr res; 241 xmlXPathCompExprPtr comp; 242 243 if ((cur == NULL) || (cur->doc == NULL) || (xpath == NULL)) 244 return(NULL); 245 ctxtXPath->doc = cur->doc; 246 ctxtXPath->node = cur; 247 comp = xmlXPathCompile(BAD_CAST xpath); 248 if (comp == NULL) { 249 fprintf(stderr, "Failed to compile %s\n", xpath); 250 return(NULL); 251 } 252 res = xmlXPathCompiledEval(comp, ctxtXPath); 253 xmlXPathFreeCompExpr(comp); 254 if (res == NULL) 255 return(NULL); 256 if ((res->type == XPATH_NODESET) && 257 (res->nodesetval != NULL) && 258 (res->nodesetval->nodeNr > 0) && 259 (res->nodesetval->nodeTab != NULL)) 260 ret = res->nodesetval->nodeTab[0]; 261 xmlXPathFreeObject(res); 262 return(ret); 263 } 264 265 static xmlChar * 266 getString(xmlNodePtr cur, const char *xpath) { 267 xmlChar *ret = NULL; 268 xmlXPathObjectPtr res; 269 xmlXPathCompExprPtr comp; 270 271 if ((cur == NULL) || (cur->doc == NULL) || (xpath == NULL)) 272 return(NULL); 273 ctxtXPath->doc = cur->doc; 274 ctxtXPath->node = cur; 275 comp = xmlXPathCompile(BAD_CAST xpath); 276 if (comp == NULL) { 277 fprintf(stderr, "Failed to compile %s\n", xpath); 278 return(NULL); 279 } 280 res = xmlXPathCompiledEval(comp, ctxtXPath); 281 xmlXPathFreeCompExpr(comp); 282 if (res == NULL) 283 return(NULL); 284 if (res->type == XPATH_STRING) { 285 ret = res->stringval; 286 res->stringval = NULL; 287 } 288 xmlXPathFreeObject(res); 289 return(ret); 290 } 291 292 /************************************************************************ 293 * * 294 * Test test/xsdtest/xsdtestsuite.xml * 295 * * 296 ************************************************************************/ 297 298 static int 299 xsdIncorectTestCase(xmlNodePtr cur) { 300 xmlNodePtr test; 301 xmlBufferPtr buf; 302 xmlRelaxNGParserCtxtPtr pctxt; 303 xmlRelaxNGPtr rng = NULL; 304 int ret = 0, memt; 305 306 cur = getNext(cur, "./incorrect[1]"); 307 if (cur == NULL) { 308 return(0); 309 } 310 311 test = getNext(cur, "./*"); 312 if (test == NULL) { 313 test_log("Failed to find test in correct line %ld\n", 314 xmlGetLineNo(cur)); 315 return(1); 316 } 317 318 memt = xmlMemUsed(); 319 extraMemoryFromResolver = 0; 320 /* 321 * dump the schemas to a buffer, then reparse it and compile the schemas 322 */ 323 buf = xmlBufferCreate(); 324 if (buf == NULL) { 325 fprintf(stderr, "out of memory !\n"); 326 fatalError(); 327 } 328 xmlNodeDump(buf, test->doc, test, 0, 0); 329 pctxt = xmlRelaxNGNewMemParserCtxt((const char *)buf->content, buf->use); 330 xmlRelaxNGSetParserErrors(pctxt, 331 (xmlRelaxNGValidityErrorFunc) testErrorHandler, 332 (xmlRelaxNGValidityWarningFunc) testErrorHandler, 333 pctxt); 334 rng = xmlRelaxNGParse(pctxt); 335 xmlRelaxNGFreeParserCtxt(pctxt); 336 if (rng != NULL) { 337 test_log("Failed to detect incorect RNG line %ld\n", 338 xmlGetLineNo(test)); 339 ret = 1; 340 goto done; 341 } 342 343 done: 344 if (buf != NULL) 345 xmlBufferFree(buf); 346 if (rng != NULL) 347 xmlRelaxNGFree(rng); 348 xmlResetLastError(); 349 if ((memt < xmlMemUsed()) && (extraMemoryFromResolver == 0)) { 350 test_log("Validation of tests starting line %ld leaked %d\n", 351 xmlGetLineNo(cur), xmlMemUsed() - memt); 352 nb_leaks++; 353 } 354 return(ret); 355 } 356 357 static void 358 installResources(xmlNodePtr tst, const xmlChar *base) { 359 xmlNodePtr test; 360 xmlBufferPtr buf; 361 xmlChar *name, *content, *res; 362 363 buf = xmlBufferCreate(); 364 if (buf == NULL) { 365 fprintf(stderr, "out of memory !\n"); 366 fatalError(); 367 } 368 xmlNodeDump(buf, tst->doc, tst, 0, 0); 369 370 while (tst != NULL) { 371 test = getNext(tst, "./*"); 372 if (test != NULL) { 373 xmlBufferEmpty(buf); 374 xmlNodeDump(buf, test->doc, test, 0, 0); 375 name = getString(tst, "string(@name)"); 376 content = xmlStrdup(buf->content); 377 if ((name != NULL) && (content != NULL)) { 378 res = composeDir(base, name); 379 xmlFree(name); 380 addEntity((char *) res, (char *) content); 381 } else { 382 if (name != NULL) xmlFree(name); 383 if (content != NULL) xmlFree(content); 384 } 385 } 386 tst = getNext(tst, "following-sibling::resource[1]"); 387 } 388 if (buf != NULL) 389 xmlBufferFree(buf); 390 } 391 392 static void 393 installDirs(xmlNodePtr tst, const xmlChar *base) { 394 xmlNodePtr test; 395 xmlChar *name, *res; 396 397 name = getString(tst, "string(@name)"); 398 if (name == NULL) 399 return; 400 res = composeDir(base, name); 401 xmlFree(name); 402 if (res == NULL) { 403 return; 404 } 405 /* Now process resources and subdir recursively */ 406 test = getNext(tst, "./resource[1]"); 407 if (test != NULL) { 408 installResources(test, res); 409 } 410 test = getNext(tst, "./dir[1]"); 411 while (test != NULL) { 412 installDirs(test, res); 413 test = getNext(test, "following-sibling::dir[1]"); 414 } 415 xmlFree(res); 416 } 417 418 static int 419 xsdTestCase(xmlNodePtr tst) { 420 xmlNodePtr test, tmp, cur; 421 xmlBufferPtr buf; 422 xmlDocPtr doc = NULL; 423 xmlRelaxNGParserCtxtPtr pctxt; 424 xmlRelaxNGValidCtxtPtr ctxt; 425 xmlRelaxNGPtr rng = NULL; 426 int ret = 0, mem, memt; 427 xmlChar *dtd; 428 429 resetEntities(); 430 testErrorsSize = 0; testErrors[0] = 0; 431 432 tmp = getNext(tst, "./dir[1]"); 433 if (tmp != NULL) { 434 installDirs(tmp, NULL); 435 } 436 tmp = getNext(tst, "./resource[1]"); 437 if (tmp != NULL) { 438 installResources(tmp, NULL); 439 } 440 441 cur = getNext(tst, "./correct[1]"); 442 if (cur == NULL) { 443 return(xsdIncorectTestCase(tst)); 444 } 445 446 test = getNext(cur, "./*"); 447 if (test == NULL) { 448 fprintf(stderr, "Failed to find test in correct line %ld\n", 449 xmlGetLineNo(cur)); 450 return(1); 451 } 452 453 memt = xmlMemUsed(); 454 extraMemoryFromResolver = 0; 455 /* 456 * dump the schemas to a buffer, then reparse it and compile the schemas 457 */ 458 buf = xmlBufferCreate(); 459 if (buf == NULL) { 460 fprintf(stderr, "out of memory !\n"); 461 fatalError(); 462 } 463 xmlNodeDump(buf, test->doc, test, 0, 0); 464 pctxt = xmlRelaxNGNewMemParserCtxt((const char *)buf->content, buf->use); 465 xmlRelaxNGSetParserErrors(pctxt, 466 (xmlRelaxNGValidityErrorFunc) testErrorHandler, 467 (xmlRelaxNGValidityWarningFunc) testErrorHandler, 468 pctxt); 469 rng = xmlRelaxNGParse(pctxt); 470 xmlRelaxNGFreeParserCtxt(pctxt); 471 if (extraMemoryFromResolver) 472 memt = 0; 473 474 if (rng == NULL) { 475 test_log("Failed to parse RNGtest line %ld\n", 476 xmlGetLineNo(test)); 477 nb_errors++; 478 ret = 1; 479 goto done; 480 } 481 /* 482 * now scan all the siblings of correct to process the <valid> tests 483 */ 484 tmp = getNext(cur, "following-sibling::valid[1]"); 485 while (tmp != NULL) { 486 dtd = xmlGetProp(tmp, BAD_CAST "dtd"); 487 test = getNext(tmp, "./*"); 488 if (test == NULL) { 489 fprintf(stderr, "Failed to find test in <valid> line %ld\n", 490 xmlGetLineNo(tmp)); 491 492 } else { 493 xmlBufferEmpty(buf); 494 if (dtd != NULL) 495 xmlBufferAdd(buf, dtd, -1); 496 xmlNodeDump(buf, test->doc, test, 0, 0); 497 498 /* 499 * We are ready to run the test 500 */ 501 mem = xmlMemUsed(); 502 extraMemoryFromResolver = 0; 503 doc = xmlReadMemory((const char *)buf->content, buf->use, 504 "test", NULL, 0); 505 if (doc == NULL) { 506 test_log("Failed to parse valid instance line %ld\n", 507 xmlGetLineNo(tmp)); 508 nb_errors++; 509 } else { 510 nb_tests++; 511 ctxt = xmlRelaxNGNewValidCtxt(rng); 512 xmlRelaxNGSetValidErrors(ctxt, 513 (xmlRelaxNGValidityErrorFunc) testErrorHandler, 514 (xmlRelaxNGValidityWarningFunc) testErrorHandler, 515 ctxt); 516 ret = xmlRelaxNGValidateDoc(ctxt, doc); 517 xmlRelaxNGFreeValidCtxt(ctxt); 518 if (ret > 0) { 519 test_log("Failed to validate valid instance line %ld\n", 520 xmlGetLineNo(tmp)); 521 nb_errors++; 522 } else if (ret < 0) { 523 test_log("Internal error validating instance line %ld\n", 524 xmlGetLineNo(tmp)); 525 nb_errors++; 526 } 527 xmlFreeDoc(doc); 528 } 529 xmlResetLastError(); 530 if ((mem != xmlMemUsed()) && (extraMemoryFromResolver == 0)) { 531 test_log("Validation of instance line %ld leaked %d\n", 532 xmlGetLineNo(tmp), xmlMemUsed() - mem); 533 xmlMemoryDump(); 534 nb_leaks++; 535 } 536 } 537 if (dtd != NULL) 538 xmlFree(dtd); 539 tmp = getNext(tmp, "following-sibling::valid[1]"); 540 } 541 /* 542 * now scan all the siblings of correct to process the <invalid> tests 543 */ 544 tmp = getNext(cur, "following-sibling::invalid[1]"); 545 while (tmp != NULL) { 546 test = getNext(tmp, "./*"); 547 if (test == NULL) { 548 fprintf(stderr, "Failed to find test in <invalid> line %ld\n", 549 xmlGetLineNo(tmp)); 550 551 } else { 552 xmlBufferEmpty(buf); 553 xmlNodeDump(buf, test->doc, test, 0, 0); 554 555 /* 556 * We are ready to run the test 557 */ 558 mem = xmlMemUsed(); 559 extraMemoryFromResolver = 0; 560 doc = xmlReadMemory((const char *)buf->content, buf->use, 561 "test", NULL, 0); 562 if (doc == NULL) { 563 test_log("Failed to parse valid instance line %ld\n", 564 xmlGetLineNo(tmp)); 565 nb_errors++; 566 } else { 567 nb_tests++; 568 ctxt = xmlRelaxNGNewValidCtxt(rng); 569 xmlRelaxNGSetValidErrors(ctxt, 570 (xmlRelaxNGValidityErrorFunc) testErrorHandler, 571 (xmlRelaxNGValidityWarningFunc) testErrorHandler, 572 ctxt); 573 ret = xmlRelaxNGValidateDoc(ctxt, doc); 574 xmlRelaxNGFreeValidCtxt(ctxt); 575 if (ret == 0) { 576 test_log("Failed to detect invalid instance line %ld\n", 577 xmlGetLineNo(tmp)); 578 nb_errors++; 579 } else if (ret < 0) { 580 test_log("Internal error validating instance line %ld\n", 581 xmlGetLineNo(tmp)); 582 nb_errors++; 583 } 584 xmlFreeDoc(doc); 585 } 586 xmlResetLastError(); 587 if ((mem != xmlMemUsed()) && (extraMemoryFromResolver == 0)) { 588 test_log("Validation of instance line %ld leaked %d\n", 589 xmlGetLineNo(tmp), xmlMemUsed() - mem); 590 xmlMemoryDump(); 591 nb_leaks++; 592 } 593 } 594 tmp = getNext(tmp, "following-sibling::invalid[1]"); 595 } 596 597 done: 598 if (buf != NULL) 599 xmlBufferFree(buf); 600 if (rng != NULL) 601 xmlRelaxNGFree(rng); 602 xmlResetLastError(); 603 if ((memt != xmlMemUsed()) && (memt != 0)) { 604 test_log("Validation of tests starting line %ld leaked %d\n", 605 xmlGetLineNo(cur), xmlMemUsed() - memt); 606 nb_leaks++; 607 } 608 return(ret); 609 } 610 611 static int 612 xsdTestSuite(xmlNodePtr cur) { 613 if (verbose) { 614 xmlChar *doc = getString(cur, "string(documentation)"); 615 616 if (doc != NULL) { 617 printf("Suite %s\n", doc); 618 xmlFree(doc); 619 } 620 } 621 cur = getNext(cur, "./testCase[1]"); 622 while (cur != NULL) { 623 xsdTestCase(cur); 624 cur = getNext(cur, "following-sibling::testCase[1]"); 625 } 626 627 return(0); 628 } 629 630 static int 631 xsdTest(void) { 632 xmlDocPtr doc; 633 xmlNodePtr cur; 634 const char *filename = "test/xsdtest/xsdtestsuite.xml"; 635 int ret = 0; 636 637 doc = xmlReadFile(filename, NULL, XML_PARSE_NOENT); 638 if (doc == NULL) { 639 fprintf(stderr, "Failed to parse %s\n", filename); 640 return(-1); 641 } 642 printf("## XML Schemas datatypes test suite from James Clark\n"); 643 644 cur = xmlDocGetRootElement(doc); 645 if ((cur == NULL) || (!xmlStrEqual(cur->name, BAD_CAST "testSuite"))) { 646 fprintf(stderr, "Unexpected format %s\n", filename); 647 ret = -1; 648 goto done; 649 } 650 651 cur = getNext(cur, "./testSuite[1]"); 652 if ((cur == NULL) || (!xmlStrEqual(cur->name, BAD_CAST "testSuite"))) { 653 fprintf(stderr, "Unexpected format %s\n", filename); 654 ret = -1; 655 goto done; 656 } 657 while (cur != NULL) { 658 xsdTestSuite(cur); 659 cur = getNext(cur, "following-sibling::testSuite[1]"); 660 } 661 662 done: 663 if (doc != NULL) 664 xmlFreeDoc(doc); 665 return(ret); 666 } 667 668 static int 669 rngTestSuite(xmlNodePtr cur) { 670 if (verbose) { 671 xmlChar *doc = getString(cur, "string(documentation)"); 672 673 if (doc != NULL) { 674 printf("Suite %s\n", doc); 675 xmlFree(doc); 676 } else { 677 doc = getString(cur, "string(section)"); 678 if (doc != NULL) { 679 printf("Section %s\n", doc); 680 xmlFree(doc); 681 } 682 } 683 } 684 cur = getNext(cur, "./testSuite[1]"); 685 while (cur != NULL) { 686 xsdTestSuite(cur); 687 cur = getNext(cur, "following-sibling::testSuite[1]"); 688 } 689 690 return(0); 691 } 692 693 static int 694 rngTest1(void) { 695 xmlDocPtr doc; 696 xmlNodePtr cur; 697 const char *filename = "test/relaxng/OASIS/spectest.xml"; 698 int ret = 0; 699 700 doc = xmlReadFile(filename, NULL, XML_PARSE_NOENT); 701 if (doc == NULL) { 702 fprintf(stderr, "Failed to parse %s\n", filename); 703 return(-1); 704 } 705 printf("## Relax NG test suite from James Clark\n"); 706 707 cur = xmlDocGetRootElement(doc); 708 if ((cur == NULL) || (!xmlStrEqual(cur->name, BAD_CAST "testSuite"))) { 709 fprintf(stderr, "Unexpected format %s\n", filename); 710 ret = -1; 711 goto done; 712 } 713 714 cur = getNext(cur, "./testSuite[1]"); 715 if ((cur == NULL) || (!xmlStrEqual(cur->name, BAD_CAST "testSuite"))) { 716 fprintf(stderr, "Unexpected format %s\n", filename); 717 ret = -1; 718 goto done; 719 } 720 while (cur != NULL) { 721 rngTestSuite(cur); 722 cur = getNext(cur, "following-sibling::testSuite[1]"); 723 } 724 725 done: 726 if (doc != NULL) 727 xmlFreeDoc(doc); 728 return(ret); 729 } 730 731 static int 732 rngTest2(void) { 733 xmlDocPtr doc; 734 xmlNodePtr cur; 735 const char *filename = "test/relaxng/testsuite.xml"; 736 int ret = 0; 737 738 doc = xmlReadFile(filename, NULL, XML_PARSE_NOENT); 739 if (doc == NULL) { 740 fprintf(stderr, "Failed to parse %s\n", filename); 741 return(-1); 742 } 743 printf("## Relax NG test suite for libxml2\n"); 744 745 cur = xmlDocGetRootElement(doc); 746 if ((cur == NULL) || (!xmlStrEqual(cur->name, BAD_CAST "testSuite"))) { 747 fprintf(stderr, "Unexpected format %s\n", filename); 748 ret = -1; 749 goto done; 750 } 751 752 cur = getNext(cur, "./testSuite[1]"); 753 if ((cur == NULL) || (!xmlStrEqual(cur->name, BAD_CAST "testSuite"))) { 754 fprintf(stderr, "Unexpected format %s\n", filename); 755 ret = -1; 756 goto done; 757 } 758 while (cur != NULL) { 759 xsdTestSuite(cur); 760 cur = getNext(cur, "following-sibling::testSuite[1]"); 761 } 762 763 done: 764 if (doc != NULL) 765 xmlFreeDoc(doc); 766 return(ret); 767 } 768 769 /************************************************************************ 770 * * 771 * Schemas test suites from W3C/NIST/MS/Sun * 772 * * 773 ************************************************************************/ 774 775 static int 776 xstcTestInstance(xmlNodePtr cur, xmlSchemaPtr schemas, 777 const xmlChar *spath, const char *base) { 778 xmlChar *href = NULL; 779 xmlChar *path = NULL; 780 xmlChar *validity = NULL; 781 xmlSchemaValidCtxtPtr ctxt = NULL; 782 xmlDocPtr doc = NULL; 783 int ret = 0, mem; 784 785 xmlResetLastError(); 786 testErrorsSize = 0; testErrors[0] = 0; 787 mem = xmlMemUsed(); 788 href = getString(cur, 789 "string(ts:instanceDocument/@xlink:href)"); 790 if ((href == NULL) || (href[0] == 0)) { 791 test_log("testGroup line %ld misses href for schemaDocument\n", 792 xmlGetLineNo(cur)); 793 ret = -1; 794 goto done; 795 } 796 path = xmlBuildURI(href, BAD_CAST base); 797 if (path == NULL) { 798 fprintf(stderr, 799 "Failed to build path to schemas testGroup line %ld : %s\n", 800 xmlGetLineNo(cur), href); 801 ret = -1; 802 goto done; 803 } 804 if (checkTestFile((const char *) path) <= 0) { 805 test_log("schemas for testGroup line %ld is missing: %s\n", 806 xmlGetLineNo(cur), path); 807 ret = -1; 808 goto done; 809 } 810 validity = getString(cur, 811 "string(ts:expected/@validity)"); 812 if (validity == NULL) { 813 fprintf(stderr, "instanceDocument line %ld misses expected validity\n", 814 xmlGetLineNo(cur)); 815 ret = -1; 816 goto done; 817 } 818 nb_tests++; 819 doc = xmlReadFile((const char *) path, NULL, XML_PARSE_NOENT); 820 if (doc == NULL) { 821 fprintf(stderr, "instance %s fails to parse\n", path); 822 ret = -1; 823 nb_errors++; 824 goto done; 825 } 826 827 ctxt = xmlSchemaNewValidCtxt(schemas); 828 xmlSchemaSetValidErrors(ctxt, 829 (xmlSchemaValidityErrorFunc) testErrorHandler, 830 (xmlSchemaValidityWarningFunc) testErrorHandler, 831 ctxt); 832 ret = xmlSchemaValidateDoc(ctxt, doc); 833 834 if (xmlStrEqual(validity, BAD_CAST "valid")) { 835 if (ret > 0) { 836 test_log("valid instance %s failed to validate against %s\n", 837 path, spath); 838 nb_errors++; 839 } else if (ret < 0) { 840 test_log("valid instance %s got internal error validating %s\n", 841 path, spath); 842 nb_internals++; 843 nb_errors++; 844 } 845 } else if (xmlStrEqual(validity, BAD_CAST "invalid")) { 846 if (ret == 0) { 847 test_log("Failed to detect invalid instance %s against %s\n", 848 path, spath); 849 nb_errors++; 850 } 851 } else { 852 test_log("instanceDocument line %ld has unexpected validity value%s\n", 853 xmlGetLineNo(cur), validity); 854 ret = -1; 855 goto done; 856 } 857 858 done: 859 if (href != NULL) xmlFree(href); 860 if (path != NULL) xmlFree(path); 861 if (validity != NULL) xmlFree(validity); 862 if (ctxt != NULL) xmlSchemaFreeValidCtxt(ctxt); 863 if (doc != NULL) xmlFreeDoc(doc); 864 xmlResetLastError(); 865 if (mem != xmlMemUsed()) { 866 test_log("Validation of tests starting line %ld leaked %d\n", 867 xmlGetLineNo(cur), xmlMemUsed() - mem); 868 nb_leaks++; 869 } 870 return(ret); 871 } 872 873 static int 874 xstcTestGroup(xmlNodePtr cur, const char *base) { 875 xmlChar *href = NULL; 876 xmlChar *path = NULL; 877 xmlChar *validity = NULL; 878 xmlSchemaPtr schemas = NULL; 879 xmlSchemaParserCtxtPtr ctxt; 880 xmlNodePtr instance; 881 int ret = 0, mem; 882 883 xmlResetLastError(); 884 testErrorsSize = 0; testErrors[0] = 0; 885 mem = xmlMemUsed(); 886 href = getString(cur, 887 "string(ts:schemaTest/ts:schemaDocument/@xlink:href)"); 888 if ((href == NULL) || (href[0] == 0)) { 889 test_log("testGroup line %ld misses href for schemaDocument\n", 890 xmlGetLineNo(cur)); 891 ret = -1; 892 goto done; 893 } 894 path = xmlBuildURI(href, BAD_CAST base); 895 if (path == NULL) { 896 test_log("Failed to build path to schemas testGroup line %ld : %s\n", 897 xmlGetLineNo(cur), href); 898 ret = -1; 899 goto done; 900 } 901 if (checkTestFile((const char *) path) <= 0) { 902 test_log("schemas for testGroup line %ld is missing: %s\n", 903 xmlGetLineNo(cur), path); 904 ret = -1; 905 goto done; 906 } 907 validity = getString(cur, 908 "string(ts:schemaTest/ts:expected/@validity)"); 909 if (validity == NULL) { 910 test_log("testGroup line %ld misses expected validity\n", 911 xmlGetLineNo(cur)); 912 ret = -1; 913 goto done; 914 } 915 nb_tests++; 916 if (xmlStrEqual(validity, BAD_CAST "valid")) { 917 nb_schematas++; 918 ctxt = xmlSchemaNewParserCtxt((const char *) path); 919 xmlSchemaSetParserErrors(ctxt, 920 (xmlSchemaValidityErrorFunc) testErrorHandler, 921 (xmlSchemaValidityWarningFunc) testErrorHandler, 922 ctxt); 923 schemas = xmlSchemaParse(ctxt); 924 xmlSchemaFreeParserCtxt(ctxt); 925 if (schemas == NULL) { 926 test_log("valid schemas %s failed to parse\n", 927 path); 928 ret = 1; 929 nb_errors++; 930 } 931 if ((ret == 0) && (strstr(testErrors, "nimplemented") != NULL)) { 932 test_log("valid schemas %s hit an unimplemented block\n", 933 path); 934 ret = 1; 935 nb_unimplemented++; 936 nb_errors++; 937 } 938 instance = getNext(cur, "./ts:instanceTest[1]"); 939 while (instance != NULL) { 940 if (schemas != NULL) { 941 xstcTestInstance(instance, schemas, path, base); 942 } else { 943 /* 944 * We'll automatically mark the instances as failed 945 * if the schema was broken. 946 */ 947 nb_errors++; 948 } 949 instance = getNext(instance, 950 "following-sibling::ts:instanceTest[1]"); 951 } 952 } else if (xmlStrEqual(validity, BAD_CAST "invalid")) { 953 nb_schematas++; 954 ctxt = xmlSchemaNewParserCtxt((const char *) path); 955 xmlSchemaSetParserErrors(ctxt, 956 (xmlSchemaValidityErrorFunc) testErrorHandler, 957 (xmlSchemaValidityWarningFunc) testErrorHandler, 958 ctxt); 959 schemas = xmlSchemaParse(ctxt); 960 xmlSchemaFreeParserCtxt(ctxt); 961 if (schemas != NULL) { 962 test_log("Failed to detect error in schemas %s\n", 963 path); 964 nb_errors++; 965 ret = 1; 966 } 967 if ((ret == 0) && (strstr(testErrors, "nimplemented") != NULL)) { 968 nb_unimplemented++; 969 test_log("invalid schemas %s hit an unimplemented block\n", 970 path); 971 ret = 1; 972 nb_errors++; 973 } 974 } else { 975 test_log("testGroup line %ld misses unexpected validity value%s\n", 976 xmlGetLineNo(cur), validity); 977 ret = -1; 978 goto done; 979 } 980 981 done: 982 if (href != NULL) xmlFree(href); 983 if (path != NULL) xmlFree(path); 984 if (validity != NULL) xmlFree(validity); 985 if (schemas != NULL) xmlSchemaFree(schemas); 986 xmlResetLastError(); 987 if ((mem != xmlMemUsed()) && (extraMemoryFromResolver == 0)) { 988 test_log("Processing test line %ld %s leaked %d\n", 989 xmlGetLineNo(cur), path, xmlMemUsed() - mem); 990 nb_leaks++; 991 } 992 return(ret); 993 } 994 995 static int 996 xstcMetadata(const char *metadata, const char *base) { 997 xmlDocPtr doc; 998 xmlNodePtr cur; 999 xmlChar *contributor; 1000 xmlChar *name; 1001 int ret = 0; 1002 1003 doc = xmlReadFile(metadata, NULL, XML_PARSE_NOENT); 1004 if (doc == NULL) { 1005 fprintf(stderr, "Failed to parse %s\n", metadata); 1006 return(-1); 1007 } 1008 1009 cur = xmlDocGetRootElement(doc); 1010 if ((cur == NULL) || (!xmlStrEqual(cur->name, BAD_CAST "testSet"))) { 1011 fprintf(stderr, "Unexpected format %s\n", metadata); 1012 return(-1); 1013 } 1014 contributor = xmlGetProp(cur, BAD_CAST "contributor"); 1015 if (contributor == NULL) { 1016 contributor = xmlStrdup(BAD_CAST "Unknown"); 1017 } 1018 name = xmlGetProp(cur, BAD_CAST "name"); 1019 if (name == NULL) { 1020 name = xmlStrdup(BAD_CAST "Unknown"); 1021 } 1022 printf("## %s test suite for Schemas version %s\n", contributor, name); 1023 xmlFree(contributor); 1024 xmlFree(name); 1025 1026 cur = getNext(cur, "./ts:testGroup[1]"); 1027 if ((cur == NULL) || (!xmlStrEqual(cur->name, BAD_CAST "testGroup"))) { 1028 fprintf(stderr, "Unexpected format %s\n", metadata); 1029 ret = -1; 1030 goto done; 1031 } 1032 while (cur != NULL) { 1033 xstcTestGroup(cur, base); 1034 cur = getNext(cur, "following-sibling::ts:testGroup[1]"); 1035 } 1036 1037 done: 1038 xmlFreeDoc(doc); 1039 return(ret); 1040 } 1041 1042 /************************************************************************ 1043 * * 1044 * The driver for the tests * 1045 * * 1046 ************************************************************************/ 1047 1048 int 1049 main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) { 1050 int ret = 0; 1051 int old_errors, old_tests, old_leaks; 1052 1053 logfile = fopen(LOGFILE, "w"); 1054 if (logfile == NULL) { 1055 fprintf(stderr, 1056 "Could not open the log file, running in verbose mode\n"); 1057 verbose = 1; 1058 } 1059 initializeLibxml2(); 1060 1061 if ((argc >= 2) && (!strcmp(argv[1], "-v"))) 1062 verbose = 1; 1063 1064 1065 old_errors = nb_errors; 1066 old_tests = nb_tests; 1067 old_leaks = nb_leaks; 1068 xsdTest(); 1069 if ((nb_errors == old_errors) && (nb_leaks == old_leaks)) 1070 printf("Ran %d tests, no errors\n", nb_tests - old_tests); 1071 else 1072 printf("Ran %d tests, %d errors, %d leaks\n", 1073 nb_tests - old_tests, 1074 nb_errors - old_errors, 1075 nb_leaks - old_leaks); 1076 old_errors = nb_errors; 1077 old_tests = nb_tests; 1078 old_leaks = nb_leaks; 1079 rngTest1(); 1080 if ((nb_errors == old_errors) && (nb_leaks == old_leaks)) 1081 printf("Ran %d tests, no errors\n", nb_tests - old_tests); 1082 else 1083 printf("Ran %d tests, %d errors, %d leaks\n", 1084 nb_tests - old_tests, 1085 nb_errors - old_errors, 1086 nb_leaks - old_leaks); 1087 old_errors = nb_errors; 1088 old_tests = nb_tests; 1089 old_leaks = nb_leaks; 1090 rngTest2(); 1091 if ((nb_errors == old_errors) && (nb_leaks == old_leaks)) 1092 printf("Ran %d tests, no errors\n", nb_tests - old_tests); 1093 else 1094 printf("Ran %d tests, %d errors, %d leaks\n", 1095 nb_tests - old_tests, 1096 nb_errors - old_errors, 1097 nb_leaks - old_leaks); 1098 old_errors = nb_errors; 1099 old_tests = nb_tests; 1100 old_leaks = nb_leaks; 1101 nb_internals = 0; 1102 nb_schematas = 0; 1103 xstcMetadata("xstc/Tests/Metadata/NISTXMLSchemaDatatypes.testSet", 1104 "xstc/Tests/Metadata/"); 1105 if ((nb_errors == old_errors) && (nb_leaks == old_leaks)) 1106 printf("Ran %d tests (%d schemata), no errors\n", 1107 nb_tests - old_tests, nb_schematas); 1108 else 1109 printf("Ran %d tests (%d schemata), %d errors (%d internals), %d leaks\n", 1110 nb_tests - old_tests, 1111 nb_schematas, 1112 nb_errors - old_errors, 1113 nb_internals, 1114 nb_leaks - old_leaks); 1115 old_errors = nb_errors; 1116 old_tests = nb_tests; 1117 old_leaks = nb_leaks; 1118 nb_internals = 0; 1119 nb_schematas = 0; 1120 xstcMetadata("xstc/Tests/Metadata/SunXMLSchema1-0-20020116.testSet", 1121 "xstc/Tests/"); 1122 if ((nb_errors == old_errors) && (nb_leaks == old_leaks)) 1123 printf("Ran %d tests (%d schemata), no errors\n", 1124 nb_tests - old_tests, nb_schematas); 1125 else 1126 printf("Ran %d tests (%d schemata), %d errors (%d internals), %d leaks\n", 1127 nb_tests - old_tests, 1128 nb_schematas, 1129 nb_errors - old_errors, 1130 nb_internals, 1131 nb_leaks - old_leaks); 1132 old_errors = nb_errors; 1133 old_tests = nb_tests; 1134 old_leaks = nb_leaks; 1135 nb_internals = 0; 1136 nb_schematas = 0; 1137 xstcMetadata("xstc/Tests/Metadata/MSXMLSchema1-0-20020116.testSet", 1138 "xstc/Tests/"); 1139 if ((nb_errors == old_errors) && (nb_leaks == old_leaks)) 1140 printf("Ran %d tests (%d schemata), no errors\n", 1141 nb_tests - old_tests, nb_schematas); 1142 else 1143 printf("Ran %d tests (%d schemata), %d errors (%d internals), %d leaks\n", 1144 nb_tests - old_tests, 1145 nb_schematas, 1146 nb_errors - old_errors, 1147 nb_internals, 1148 nb_leaks - old_leaks); 1149 1150 if ((nb_errors == 0) && (nb_leaks == 0)) { 1151 ret = 0; 1152 printf("Total %d tests, no errors\n", 1153 nb_tests); 1154 } else { 1155 ret = 1; 1156 printf("Total %d tests, %d errors, %d leaks\n", 1157 nb_tests, nb_errors, nb_leaks); 1158 } 1159 xmlXPathFreeContext(ctxtXPath); 1160 xmlCleanupParser(); 1161 xmlMemoryDump(); 1162 1163 if (logfile != NULL) 1164 fclose(logfile); 1165 return(ret); 1166 } 1167 #else /* !SCHEMAS */ 1168 int 1169 main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) { 1170 fprintf(stderr, "runsuite requires support for schemas and xpath in libxml2\n"); 1171 } 1172 #endif