1: #!/usr/bin/python
2: import sys
3: import time
4: import os
5: import string
6: import StringIO
7: sys.path.insert(0, "python")
8: import libxml2
9:
10: # Memory debug specific
11: libxml2.debugMemory(1)
12: debug = 0
13: verbose = 0
14: quiet = 1
15:
16: #
17: # the testsuite description
18: #
19: CONF=os.path.join(os.path.dirname(__file__), "test/relaxng/OASIS/spectest.xml")
20: LOG="check-relaxng-test-suite.log"
21: RES="relaxng-test-results.xml"
22:
23: log = open(LOG, "w")
24: nb_schemas_tests = 0
25: nb_schemas_success = 0
26: nb_schemas_failed = 0
27: nb_instances_tests = 0
28: nb_instances_success = 0
29: nb_instances_failed = 0
30:
31: libxml2.lineNumbersDefault(1)
32: #
33: # Error and warnng callbacks
34: #
35: def callback(ctx, str):
36: global log
37: log.write("%s%s" % (ctx, str))
38:
39: libxml2.registerErrorHandler(callback, "")
40:
41: #
42: # Resolver callback
43: #
44: resources = {}
45: def resolver(URL, ID, ctxt):
46: global resources
47:
48: if string.find(URL, '#') != -1:
49: URL = URL[0:string.find(URL, '#')]
50: if resources.has_key(URL):
51: return(StringIO.StringIO(resources[URL]))
52: log.write("Resolver failure: asked %s\n" % (URL))
53: log.write("resources: %s\n" % (resources))
54: return None
55:
56: #
57: # Load the previous results
58: #
59: #results = {}
60: #previous = {}
61: #
62: #try:
63: # res = libxml2.parseFile(RES)
64: #except:
65: # log.write("Could not parse %s" % (RES))
66:
67: #
68: # handle a valid instance
69: #
70: def handle_valid(node, schema):
71: global log
72: global nb_instances_success
73: global nb_instances_failed
74:
75: instance = ""
76: child = node.children
77: while child != None:
78: if child.type != 'text':
79: instance = instance + child.serialize()
80: child = child.next
81:
82: try:
83: doc = libxml2.parseDoc(instance)
84: except:
85: doc = None
86:
87: if doc == None:
88: log.write("\nFailed to parse correct instance:\n-----\n")
89: log.write(instance)
90: log.write("\n-----\n")
91: nb_instances_failed = nb_instances_failed + 1
92: return
93:
94: try:
95: ctxt = schema.relaxNGNewValidCtxt()
96: ret = doc.relaxNGValidateDoc(ctxt)
97: except:
98: ret = -1
99: if ret != 0:
100: log.write("\nFailed to validate correct instance:\n-----\n")
101: log.write(instance)
102: log.write("\n-----\n")
103: nb_instances_failed = nb_instances_failed + 1
104: else:
105: nb_instances_success = nb_instances_success + 1
106: doc.freeDoc()
107:
108: #
109: # handle an invalid instance
110: #
111: def handle_invalid(node, schema):
112: global log
113: global nb_instances_success
114: global nb_instances_failed
115:
116: instance = ""
117: child = node.children
118: while child != None:
119: if child.type != 'text':
120: instance = instance + child.serialize()
121: child = child.next
122:
123: try:
124: doc = libxml2.parseDoc(instance)
125: except:
126: doc = None
127:
128: if doc == None:
129: log.write("\nStrange: failed to parse incorrect instance:\n-----\n")
130: log.write(instance)
131: log.write("\n-----\n")
132: return
133:
134: try:
135: ctxt = schema.relaxNGNewValidCtxt()
136: ret = doc.relaxNGValidateDoc(ctxt)
137: except:
138: ret = -1
139: if ret == 0:
140: log.write("\nFailed to detect validation problem in instance:\n-----\n")
141: log.write(instance)
142: log.write("\n-----\n")
143: nb_instances_failed = nb_instances_failed + 1
144: else:
145: nb_instances_success = nb_instances_success + 1
146: doc.freeDoc()
147:
148: #
149: # handle an incorrect test
150: #
151: def handle_correct(node):
152: global log
153: global nb_schemas_success
154: global nb_schemas_failed
155:
156: schema = ""
157: child = node.children
158: while child != None:
159: if child.type != 'text':
160: schema = schema + child.serialize()
161: child = child.next
162:
163: try:
164: rngp = libxml2.relaxNGNewMemParserCtxt(schema, len(schema))
165: rngs = rngp.relaxNGParse()
166: except:
167: rngs = None
168: if rngs == None:
169: log.write("\nFailed to compile correct schema:\n-----\n")
170: log.write(schema)
171: log.write("\n-----\n")
172: nb_schemas_failed = nb_schemas_failed + 1
173: else:
174: nb_schemas_success = nb_schemas_success + 1
175: return rngs
176:
177: def handle_incorrect(node):
178: global log
179: global nb_schemas_success
180: global nb_schemas_failed
181:
182: schema = ""
183: child = node.children
184: while child != None:
185: if child.type != 'text':
186: schema = schema + child.serialize()
187: child = child.next
188:
189: try:
190: rngp = libxml2.relaxNGNewMemParserCtxt(schema, len(schema))
191: rngs = rngp.relaxNGParse()
192: except:
193: rngs = None
194: if rngs != None:
195: log.write("\nFailed to detect schema error in:\n-----\n")
196: log.write(schema)
197: log.write("\n-----\n")
198: nb_schemas_failed = nb_schemas_failed + 1
199: else:
200: # log.write("\nSuccess detecting schema error in:\n-----\n")
201: # log.write(schema)
202: # log.write("\n-----\n")
203: nb_schemas_success = nb_schemas_success + 1
204: return None
205:
206: #
207: # resource handling: keep a dictionary of URL->string mappings
208: #
209: def handle_resource(node, dir):
210: global resources
211:
212: try:
213: name = node.prop('name')
214: except:
215: name = None
216:
217: if name == None or name == '':
218: log.write("resource has no name")
219: return;
220:
221: if dir != None:
222: # name = libxml2.buildURI(name, dir)
223: name = dir + '/' + name
224:
225: res = ""
226: child = node.children
227: while child != None:
228: if child.type != 'text':
229: res = res + child.serialize()
230: child = child.next
231: resources[name] = res
232:
233: #
234: # dir handling: pseudo directory resources
235: #
236: def handle_dir(node, dir):
237: try:
238: name = node.prop('name')
239: except:
240: name = None
241:
242: if name == None or name == '':
243: log.write("resource has no name")
244: return;
245:
246: if dir != None:
247: # name = libxml2.buildURI(name, dir)
248: name = dir + '/' + name
249:
250: dirs = node.xpathEval('dir')
251: for dir in dirs:
252: handle_dir(dir, name)
253: res = node.xpathEval('resource')
254: for r in res:
255: handle_resource(r, name)
256:
257: #
258: # handle a testCase element
259: #
260: def handle_testCase(node):
261: global nb_schemas_tests
262: global nb_instances_tests
263: global resources
264:
265: sections = node.xpathEval('string(section)')
266: log.write("\n ======== test %d line %d section %s ==========\n" % (
267:
268: nb_schemas_tests, node.lineNo(), sections))
269: resources = {}
270: if debug:
271: print "test %d line %d" % (nb_schemas_tests, node.lineNo())
272:
273: dirs = node.xpathEval('dir')
274: for dir in dirs:
275: handle_dir(dir, None)
276: res = node.xpathEval('resource')
277: for r in res:
278: handle_resource(r, None)
279:
280: tsts = node.xpathEval('incorrect')
281: if tsts != []:
282: if len(tsts) != 1:
283: print "warning test line %d has more than one <incorrect> example" %(node.lineNo())
284: schema = handle_incorrect(tsts[0])
285: else:
286: tsts = node.xpathEval('correct')
287: if tsts != []:
288: if len(tsts) != 1:
289: print "warning test line %d has more than one <correct> example"% (node.lineNo())
290: schema = handle_correct(tsts[0])
291: else:
292: print "warning <testCase> line %d has no <correct> nor <incorrect> child" % (node.lineNo())
293:
294: nb_schemas_tests = nb_schemas_tests + 1;
295:
296: valids = node.xpathEval('valid')
297: invalids = node.xpathEval('invalid')
298: nb_instances_tests = nb_instances_tests + len(valids) + len(invalids)
299: if schema != None:
300: for valid in valids:
301: handle_valid(valid, schema)
302: for invalid in invalids:
303: handle_invalid(invalid, schema)
304:
305:
306: #
307: # handle a testSuite element
308: #
309: def handle_testSuite(node, level = 0):
310: global nb_schemas_tests, nb_schemas_success, nb_schemas_failed
311: global nb_instances_tests, nb_instances_success, nb_instances_failed
312: global quiet
313: if level >= 1:
314: old_schemas_tests = nb_schemas_tests
315: old_schemas_success = nb_schemas_success
316: old_schemas_failed = nb_schemas_failed
317: old_instances_tests = nb_instances_tests
318: old_instances_success = nb_instances_success
319: old_instances_failed = nb_instances_failed
320:
321: docs = node.xpathEval('documentation')
322: authors = node.xpathEval('author')
323: if docs != []:
324: msg = ""
325: for doc in docs:
326: msg = msg + doc.content + " "
327: if authors != []:
328: msg = msg + "written by "
329: for author in authors:
330: msg = msg + author.content + " "
331: if quiet == 0:
332: print msg
333: sections = node.xpathEval('section')
334: if sections != [] and level <= 0:
335: msg = ""
336: for section in sections:
337: msg = msg + section.content + " "
338: if quiet == 0:
339: print "Tests for section %s" % (msg)
340: for test in node.xpathEval('testCase'):
341: handle_testCase(test)
342: for test in node.xpathEval('testSuite'):
343: handle_testSuite(test, level + 1)
344:
345:
346: if verbose and level >= 1 and sections != []:
347: msg = ""
348: for section in sections:
349: msg = msg + section.content + " "
350: print "Result of tests for section %s" % (msg)
351: if nb_schemas_tests != old_schemas_tests:
352: print "found %d test schemas: %d success %d failures" % (
353: nb_schemas_tests - old_schemas_tests,
354: nb_schemas_success - old_schemas_success,
355: nb_schemas_failed - old_schemas_failed)
356: if nb_instances_tests != old_instances_tests:
357: print "found %d test instances: %d success %d failures" % (
358: nb_instances_tests - old_instances_tests,
359: nb_instances_success - old_instances_success,
360: nb_instances_failed - old_instances_failed)
361: #
362: # Parse the conf file
363: #
364: libxml2.substituteEntitiesDefault(1);
365: testsuite = libxml2.parseFile(CONF)
366: libxml2.setEntityLoader(resolver)
367: root = testsuite.getRootElement()
368: if root.name != 'testSuite':
369: print "%s doesn't start with a testSuite element, aborting" % (CONF)
370: sys.exit(1)
371: if quiet == 0:
372: print "Running Relax NG testsuite"
373: handle_testSuite(root)
374:
375: if quiet == 0:
376: print "\nTOTAL:\n"
377: if quiet == 0 or nb_schemas_failed != 0:
378: print "found %d test schemas: %d success %d failures" % (
379: nb_schemas_tests, nb_schemas_success, nb_schemas_failed)
380: if quiet == 0 or nb_instances_failed != 0:
381: print "found %d test instances: %d success %d failures" % (
382: nb_instances_tests, nb_instances_success, nb_instances_failed)
383:
384: testsuite.freeDoc()
385:
386: # Memory debug specific
387: libxml2.relaxNGCleanupTypes()
388: libxml2.cleanupParser()
389: if libxml2.debugMemory(1) == 0:
390: if quiet == 0:
391: print "OK"
392: else:
393: print "Memory leak %d bytes" % (libxml2.debugMemory(1))
394: libxml2.dumpMemory()
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to check-relaxng-test-suite.py CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2