third_party/libxml/src/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