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