Home | History | Annotate | Download | only in src 
      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 (at) 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
   1185