release/src/router/libxml2/runxmlconf.c

   1 /*
   2  * runsuite.c: C program to run libxml2 againts published testsuites
   3  *
   4  * See Copyright for the status of this software.
   5  *
   6  * daniel@veillard.com
   7  */
   8
   9 #include "libxml.h"
  10 #include <stdio.h>
  11
  12 #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