Home | History | Annotate | Download | only in libxml2 
      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 #include "libxml.h"
     10 #include <stdio.h>
     11 
     12 #ifdef LIBXML_XPATH_ENABLED
     13 
     14 #if !defined(_WIN32) || defined(__CYGWIN__)
     15 #include <unistd.h>
     16 #endif
     17 #include <string.h>
     18 #include <sys/types.h>
     19 #include <sys/stat.h>
     20 #include <fcntl.h>
     21 
     22 #include <libxml/parser.h>
     23 #include <libxml/parserInternals.h>
     24 #include <libxml/tree.h>
     25 #include <libxml/uri.h>
     26 #include <libxml/xmlreader.h>
     27 
     28 #include <libxml/xpath.h>
     29 #include <libxml/xpathInternals.h>
     30 
     31 #define LOGFILE "runxmlconf.log"
     32 static FILE *logfile = NULL;
     33 static int verbose = 0;
     34 
     35 #define NB_EXPECTED_ERRORS 15
     36 
     37 
     38 const char *skipped_tests[] = {
     39 /* http://lists.w3.org/Archives/Public/public-xml-testsuite/2008Jul/0000.html */
     40     "rmt-ns10-035",
     41     NULL
     42 };
     43 
     44 /************************************************************************
     45  *									*
     46  *		File name and path utilities				*
     47  *									*
     48  ************************************************************************/
     49 
     50 static int checkTestFile(const char *filename) {
     51     struct stat buf;
     52 
     53     if (stat(filename, &buf) == -1)
     54         return(0);
     55 
     56 #if defined(_WIN32) && !defined(__CYGWIN__)
     57     if (!(buf.st_mode & _S_IFREG))
     58         return(0);
     59 #else
     60     if (!S_ISREG(buf.st_mode))
     61         return(0);
     62 #endif
     63 
     64     return(1);
     65 }
     66 
     67 static xmlChar *composeDir(const xmlChar *dir, const xmlChar *path) {
     68     char buf[500];
     69 
     70     if (dir == NULL) return(xmlStrdup(path));
     71     if (path == NULL) return(NULL);
     72 
     73     snprintf(buf, 500, "%s/%s", (const char *) dir, (const char *) path);
     74     return(xmlStrdup((const xmlChar *) buf));
     75 }
     76 
     77 /************************************************************************
     78  *									*
     79  *		Libxml2 specific routines				*
     80  *									*
     81  ************************************************************************/
     82 
     83 static int nb_skipped = 0;
     84 static int nb_tests = 0;
     85 static int nb_errors = 0;
     86 static int nb_leaks = 0;
     87 
     88 /*
     89  * We need to trap calls to the resolver to not account memory for the catalog
     90  * and not rely on any external resources.
     91  */
     92 static xmlParserInputPtr
     93 testExternalEntityLoader(const char *URL, const char *ID ATTRIBUTE_UNUSED,
     94 			 xmlParserCtxtPtr ctxt) {
     95     xmlParserInputPtr ret;
     96 
     97     ret = xmlNewInputFromFile(ctxt, (const char *) URL);
     98 
     99     return(ret);
    100 }
    101 
    102 /*
    103  * Trapping the error messages at the generic level to grab the equivalent of
    104  * stderr messages on CLI tools.
    105  */
    106 static char testErrors[32769];
    107 static int testErrorsSize = 0;
    108 static int nbError = 0;
    109 static int nbFatal = 0;
    110 
    111 static void test_log(const char *msg, ...) {
    112     va_list args;
    113     if (logfile != NULL) {
    114         fprintf(logfile, "\n------------\n");
    115 	va_start(args, msg);
    116 	vfprintf(logfile, msg, args);
    117 	va_end(args);
    118 	fprintf(logfile, "%s", testErrors);
    119 	testErrorsSize = 0; testErrors[0] = 0;
    120     }
    121     if (verbose) {
    122 	va_start(args, msg);
    123 	vfprintf(stderr, msg, args);
    124 	va_end(args);
    125     }
    126 }
    127 
    128 static void
    129 testErrorHandler(void *userData ATTRIBUTE_UNUSED, xmlErrorPtr error) {
    130     int res;
    131 
    132     if (testErrorsSize >= 32768)
    133         return;
    134     res = snprintf(&testErrors[testErrorsSize],
    135                     32768 - testErrorsSize,
    136 		   "%s:%d: %s\n", (error->file ? error->file : "entity"),
    137 		   error->line, error->message);
    138     if (error->level == XML_ERR_FATAL)
    139         nbFatal++;
    140     else if (error->level == XML_ERR_ERROR)
    141         nbError++;
    142     if (testErrorsSize + res >= 32768) {
    143         /* buffer is full */
    144 	testErrorsSize = 32768;
    145 	testErrors[testErrorsSize] = 0;
    146     } else {
    147         testErrorsSize += res;
    148     }
    149     testErrors[testErrorsSize] = 0;
    150 }
    151 
    152 static xmlXPathContextPtr ctxtXPath;
    153 
    154 static void
    155 initializeLibxml2(void) {
    156     xmlGetWarningsDefaultValue = 0;
    157     xmlPedanticParserDefault(0);
    158 
    159     xmlMemSetup(xmlMemFree, xmlMemMalloc, xmlMemRealloc, xmlMemoryStrdup);
    160     xmlInitParser();
    161     xmlSetExternalEntityLoader(testExternalEntityLoader);
    162     ctxtXPath = xmlXPathNewContext(NULL);
    163     /*
    164     * Deactivate the cache if created; otherwise we have to create/free it
    165     * for every test, since it will confuse the memory leak detection.
    166     * Note that normally this need not be done, since the cache is not
    167     * created until set explicitely with xmlXPathContextSetCache();
    168     * but for test purposes it is sometimes usefull to activate the
    169     * cache by default for the whole library.
    170     */
    171     if (ctxtXPath->cache != NULL)
    172 	xmlXPathContextSetCache(ctxtXPath, 0, -1, 0);
    173     xmlSetStructuredErrorFunc(NULL, testErrorHandler);
    174 }
    175 
    176 /************************************************************************
    177  *									*
    178  *		Run the xmlconf test if found				*
    179  *									*
    180  ************************************************************************/
    181 
    182 static int
    183 xmlconfTestInvalid(const char *id, const char *filename, int options) {
    184     xmlDocPtr doc;
    185     xmlParserCtxtPtr ctxt;
    186     int ret = 1;
    187 
    188     ctxt = xmlNewParserCtxt();
    189     if (ctxt == NULL) {
    190         test_log("test %s : %s out of memory\n",
    191 	         id, filename);
    192         return(0);
    193     }
    194     doc = xmlCtxtReadFile(ctxt, filename, NULL, options);
    195     if (doc == NULL) {
    196         test_log("test %s : %s invalid document turned not well-formed too\n",
    197 	         id, filename);
    198     } else {
    199     /* invalidity should be reported both in the context and in the document */
    200         if ((ctxt->valid != 0) || (doc->properties & XML_DOC_DTDVALID)) {
    201 	    test_log("test %s : %s failed to detect invalid document\n",
    202 		     id, filename);
    203 	    nb_errors++;
    204 	    ret = 0;
    205 	}
    206 	xmlFreeDoc(doc);
    207     }
    208     xmlFreeParserCtxt(ctxt);
    209     return(ret);
    210 }
    211 
    212 static int
    213 xmlconfTestValid(const char *id, const char *filename, int options) {
    214     xmlDocPtr doc;
    215     xmlParserCtxtPtr ctxt;
    216     int ret = 1;
    217 
    218     ctxt = xmlNewParserCtxt();
    219     if (ctxt == NULL) {
    220         test_log("test %s : %s out of memory\n",
    221 	         id, filename);
    222         return(0);
    223     }
    224     doc = xmlCtxtReadFile(ctxt, filename, NULL, options);
    225     if (doc == NULL) {
    226         test_log("test %s : %s failed to parse a valid document\n",
    227 	         id, filename);
    228         nb_errors++;
    229 	ret = 0;
    230     } else {
    231     /* validity should be reported both in the context and in the document */
    232         if ((ctxt->valid == 0) || ((doc->properties & XML_DOC_DTDVALID) == 0)) {
    233 	    test_log("test %s : %s failed to validate a valid document\n",
    234 		     id, filename);
    235 	    nb_errors++;
    236 	    ret = 0;
    237 	}
    238 	xmlFreeDoc(doc);
    239     }
    240     xmlFreeParserCtxt(ctxt);
    241     return(ret);
    242 }
    243 
    244 static int
    245 xmlconfTestNotNSWF(const char *id, const char *filename, int options) {
    246     xmlDocPtr doc;
    247     int ret = 1;
    248 
    249     /*
    250      * In case of Namespace errors, libxml2 will still parse the document
    251      * but log a Namesapce error.
    252      */
    253     doc = xmlReadFile(filename, NULL, options);
    254     if (doc == NULL) {
    255         test_log("test %s : %s failed to parse the XML\n",
    256 	         id, filename);
    257         nb_errors++;
    258 	ret = 0;
    259     } else {
    260 	if ((xmlLastError.code == XML_ERR_OK) ||
    261 	    (xmlLastError.domain != XML_FROM_NAMESPACE)) {
    262 	    test_log("test %s : %s failed to detect namespace error\n",
    263 		     id, filename);
    264 	    nb_errors++;
    265 	    ret = 0;
    266 	}
    267 	xmlFreeDoc(doc);
    268     }
    269     return(ret);
    270 }
    271 
    272 static int
    273 xmlconfTestNotWF(const char *id, const char *filename, int options) {
    274     xmlDocPtr doc;
    275     int ret = 1;
    276 
    277     doc = xmlReadFile(filename, NULL, options);
    278     if (doc != NULL) {
    279         test_log("test %s : %s failed to detect not well formedness\n",
    280 	         id, filename);
    281         nb_errors++;
    282 	xmlFreeDoc(doc);
    283 	ret = 0;
    284     }
    285     return(ret);
    286 }
    287 
    288 static int
    289 xmlconfTestItem(xmlDocPtr doc, xmlNodePtr cur) {
    290     int ret = -1;
    291     xmlChar *type = NULL;
    292     xmlChar *filename = NULL;
    293     xmlChar *uri = NULL;
    294     xmlChar *base = NULL;
    295     xmlChar *id = NULL;
    296     xmlChar *rec = NULL;
    297     xmlChar *version = NULL;
    298     xmlChar *entities = NULL;
    299     xmlChar *edition = NULL;
    300     int options = 0;
    301     int nstest = 0;
    302     int mem, final;
    303     int i;
    304 
    305     testErrorsSize = 0; testErrors[0] = 0;
    306     nbError = 0;
    307     nbFatal = 0;
    308     id = xmlGetProp(cur, BAD_CAST "ID");
    309     if (id == NULL) {
    310         test_log("test missing ID, line %ld\n", xmlGetLineNo(cur));
    311 	goto error;
    312     }
    313     for (i = 0;skipped_tests[i] != NULL;i++) {
    314         if (!strcmp(skipped_tests[i], (char *) id)) {
    315 	    test_log("Skipping test %s from skipped list\n", (char *) id);
    316 	    ret = 0;
    317 	    nb_skipped++;
    318 	    goto error;
    319 	}
    320     }
    321     type = xmlGetProp(cur, BAD_CAST "TYPE");
    322     if (type == NULL) {
    323         test_log("test %s missing TYPE\n", (char *) id);
    324 	goto error;
    325     }
    326     uri = xmlGetProp(cur, BAD_CAST "URI");
    327     if (uri == NULL) {
    328         test_log("test %s missing URI\n", (char *) id);
    329 	goto error;
    330     }
    331     base = xmlNodeGetBase(doc, cur);
    332     filename = composeDir(base, uri);
    333     if (!checkTestFile((char *) filename)) {
    334         test_log("test %s missing file %s \n", id,
    335 	         (filename ? (char *)filename : "NULL"));
    336 	goto error;
    337     }
    338 
    339     version = xmlGetProp(cur, BAD_CAST "VERSION");
    340 
    341     entities = xmlGetProp(cur, BAD_CAST "ENTITIES");
    342     if (!xmlStrEqual(entities, BAD_CAST "none")) {
    343         options |= XML_PARSE_DTDLOAD;
    344         options |= XML_PARSE_NOENT;
    345     }
    346     rec = xmlGetProp(cur, BAD_CAST "RECOMMENDATION");
    347     if ((rec == NULL) ||
    348         (xmlStrEqual(rec, BAD_CAST "XML1.0")) ||
    349 	(xmlStrEqual(rec, BAD_CAST "XML1.0-errata2e")) ||
    350 	(xmlStrEqual(rec, BAD_CAST "XML1.0-errata3e")) ||
    351 	(xmlStrEqual(rec, BAD_CAST "XML1.0-errata4e"))) {
    352 	if ((version != NULL) && (!xmlStrEqual(version, BAD_CAST "1.0"))) {
    353 	    test_log("Skipping test %s for %s\n", (char *) id,
    354 	             (char *) version);
    355 	    ret = 0;
    356 	    nb_skipped++;
    357 	    goto error;
    358 	}
    359 	ret = 1;
    360     } else if ((xmlStrEqual(rec, BAD_CAST "NS1.0")) ||
    361 	       (xmlStrEqual(rec, BAD_CAST "NS1.0-errata1e"))) {
    362 	ret = 1;
    363 	nstest = 1;
    364     } else {
    365         test_log("Skipping test %s for REC %s\n", (char *) id, (char *) rec);
    366 	ret = 0;
    367 	nb_skipped++;
    368 	goto error;
    369     }
    370     edition = xmlGetProp(cur, BAD_CAST "EDITION");
    371     if ((edition != NULL) && (xmlStrchr(edition, '5') == NULL)) {
    372         /* test limited to all versions before 5th */
    373 	options |= XML_PARSE_OLD10;
    374     }
    375 
    376     /*
    377      * Reset errors and check memory usage before the test
    378      */
    379     xmlResetLastError();
    380     testErrorsSize = 0; testErrors[0] = 0;
    381     mem = xmlMemUsed();
    382 
    383     if (xmlStrEqual(type, BAD_CAST "not-wf")) {
    384         if (nstest == 0)
    385 	    xmlconfTestNotWF((char *) id, (char *) filename, options);
    386         else
    387 	    xmlconfTestNotNSWF((char *) id, (char *) filename, options);
    388     } else if (xmlStrEqual(type, BAD_CAST "valid")) {
    389         options |= XML_PARSE_DTDVALID;
    390 	xmlconfTestValid((char *) id, (char *) filename, options);
    391     } else if (xmlStrEqual(type, BAD_CAST "invalid")) {
    392         options |= XML_PARSE_DTDVALID;
    393 	xmlconfTestInvalid((char *) id, (char *) filename, options);
    394     } else if (xmlStrEqual(type, BAD_CAST "error")) {
    395         test_log("Skipping error test %s \n", (char *) id);
    396 	ret = 0;
    397 	nb_skipped++;
    398 	goto error;
    399     } else {
    400         test_log("test %s unknown TYPE value %s\n", (char *) id, (char *)type);
    401 	ret = -1;
    402 	goto error;
    403     }
    404 
    405     /*
    406      * Reset errors and check memory usage after the test
    407      */
    408     xmlResetLastError();
    409     final = xmlMemUsed();
    410     if (final > mem) {
    411         test_log("test %s : %s leaked %d bytes\n",
    412 	         id, filename, final - mem);
    413         nb_leaks++;
    414 	xmlMemDisplayLast(logfile, final - mem);
    415     }
    416     nb_tests++;
    417 
    418 error:
    419     if (type != NULL)
    420         xmlFree(type);
    421     if (entities != NULL)
    422         xmlFree(entities);
    423     if (edition != NULL)
    424         xmlFree(edition);
    425     if (version != NULL)
    426         xmlFree(version);
    427     if (filename != NULL)
    428         xmlFree(filename);
    429     if (uri != NULL)
    430         xmlFree(uri);
    431     if (base != NULL)
    432         xmlFree(base);
    433     if (id != NULL)
    434         xmlFree(id);
    435     if (rec != NULL)
    436         xmlFree(rec);
    437     return(ret);
    438 }
    439 
    440 static int
    441 xmlconfTestCases(xmlDocPtr doc, xmlNodePtr cur, int level) {
    442     xmlChar *profile;
    443     int ret = 0;
    444     int tests = 0;
    445     int output = 0;
    446 
    447     if (level == 1) {
    448 	profile = xmlGetProp(cur, BAD_CAST "PROFILE");
    449 	if (profile != NULL) {
    450 	    output = 1;
    451 	    level++;
    452 	    printf("Test cases: %s\n", (char *) profile);
    453 	    xmlFree(profile);
    454 	}
    455     }
    456     cur = cur->children;
    457     while (cur != NULL) {
    458         /* look only at elements we ignore everything else */
    459         if (cur->type == XML_ELEMENT_NODE) {
    460 	    if (xmlStrEqual(cur->name, BAD_CAST "TESTCASES")) {
    461 	        ret += xmlconfTestCases(doc, cur, level);
    462 	    } else if (xmlStrEqual(cur->name, BAD_CAST "TEST")) {
    463 	        if (xmlconfTestItem(doc, cur) >= 0)
    464 		    ret++;
    465 		tests++;
    466 	    } else {
    467 	        fprintf(stderr, "Unhandled element %s\n", (char *)cur->name);
    468 	    }
    469 	}
    470         cur = cur->next;
    471     }
    472     if (output == 1) {
    473 	if (tests > 0)
    474 	    printf("Test cases: %d tests\n", tests);
    475     }
    476     return(ret);
    477 }
    478 
    479 static int
    480 xmlconfTestSuite(xmlDocPtr doc, xmlNodePtr cur) {
    481     xmlChar *profile;
    482     int ret = 0;
    483 
    484     profile = xmlGetProp(cur, BAD_CAST "PROFILE");
    485     if (profile != NULL) {
    486         printf("Test suite: %s\n", (char *) profile);
    487 	xmlFree(profile);
    488     } else
    489         printf("Test suite\n");
    490     cur = cur->children;
    491     while (cur != NULL) {
    492         /* look only at elements we ignore everything else */
    493         if (cur->type == XML_ELEMENT_NODE) {
    494 	    if (xmlStrEqual(cur->name, BAD_CAST "TESTCASES")) {
    495 	        ret += xmlconfTestCases(doc, cur, 1);
    496 	    } else {
    497 	        fprintf(stderr, "Unhandled element %s\n", (char *)cur->name);
    498 	    }
    499 	}
    500         cur = cur->next;
    501     }
    502     return(ret);
    503 }
    504 
    505 static void
    506 xmlconfInfo(void) {
    507     fprintf(stderr, "  you need to fetch and extract the\n");
    508     fprintf(stderr, "  latest XML Conformance Test Suites\n");
    509     fprintf(stderr, "  http://www.w3.org/XML/Test/xmlts20080827.tar.gz\n");
    510     fprintf(stderr, "  see http://www.w3.org/XML/Test/ for informations\n");
    511 }
    512 
    513 static int
    514 xmlconfTest(void) {
    515     const char *confxml = "xmlconf/xmlconf.xml";
    516     xmlDocPtr doc;
    517     xmlNodePtr cur;
    518     int ret = 0;
    519 
    520     if (!checkTestFile(confxml)) {
    521         fprintf(stderr, "%s is missing \n", confxml);
    522 	xmlconfInfo();
    523 	return(-1);
    524     }
    525     doc = xmlReadFile(confxml, NULL, XML_PARSE_NOENT);
    526     if (doc == NULL) {
    527         fprintf(stderr, "%s is corrupted \n", confxml);
    528 	xmlconfInfo();
    529 	return(-1);
    530     }
    531 
    532     cur = xmlDocGetRootElement(doc);
    533     if ((cur == NULL) || (!xmlStrEqual(cur->name, BAD_CAST "TESTSUITE"))) {
    534         fprintf(stderr, "Unexpected format %s\n", confxml);
    535 	xmlconfInfo();
    536 	ret = -1;
    537     } else {
    538         ret = xmlconfTestSuite(doc, cur);
    539     }
    540     xmlFreeDoc(doc);
    541     return(ret);
    542 }
    543 
    544 /************************************************************************
    545  *									*
    546  *		The driver for the tests				*
    547  *									*
    548  ************************************************************************/
    549 
    550 int
    551 main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
    552     int ret = 0;
    553     int old_errors, old_tests, old_leaks;
    554 
    555     logfile = fopen(LOGFILE, "w");
    556     if (logfile == NULL) {
    557         fprintf(stderr,
    558 	        "Could not open the log file, running in verbose mode\n");
    559 	verbose = 1;
    560     }
    561     initializeLibxml2();
    562 
    563     if ((argc >= 2) && (!strcmp(argv[1], "-v")))
    564         verbose = 1;
    565 
    566 
    567     old_errors = nb_errors;
    568     old_tests = nb_tests;
    569     old_leaks = nb_leaks;
    570     xmlconfTest();
    571     if ((nb_errors == old_errors) && (nb_leaks == old_leaks))
    572 	printf("Ran %d tests, no errors\n", nb_tests - old_tests);
    573     else
    574 	printf("Ran %d tests, %d errors, %d leaks\n",
    575 	       nb_tests - old_tests,
    576 	       nb_errors - old_errors,
    577 	       nb_leaks - old_leaks);
    578     if ((nb_errors == 0) && (nb_leaks == 0)) {
    579         ret = 0;
    580 	printf("Total %d tests, no errors\n",
    581 	       nb_tests);
    582     } else {
    583 	ret = 1;
    584 	printf("Total %d tests, %d errors, %d leaks\n",
    585 	       nb_tests, nb_errors, nb_leaks);
    586 	printf("See %s for detailed output\n", LOGFILE);
    587 	if ((nb_leaks == 0) && (nb_errors == NB_EXPECTED_ERRORS)) {
    588 	    printf("%d errors were expected\n", nb_errors);
    589 	    ret = 0;
    590 	}
    591     }
    592     xmlXPathFreeContext(ctxtXPath);
    593     xmlCleanupParser();
    594     xmlMemoryDump();
    595 
    596     if (logfile != NULL)
    597         fclose(logfile);
    598     return(ret);
    599 }
    600 
    601 #else /* ! LIBXML_XPATH_ENABLED */
    602 #include <stdio.h>
    603 int
    604 main(int argc, char **argv) {
    605     fprintf(stderr, "%s need XPath support\n", argv[0]);
    606 }
    607 #endif
    608