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
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to runsuite.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2