← Back to branch summary

~ubuntu-branches/ubuntu/wily/opencollada/wily-proposed

« back to all changes in this revision

Viewing changes to Externals/LibXML/check-relaxng-test-suite.py

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2015-05-14 17:23:27 UTC
  • Revision ID: package-import@ubuntu.com-20150514172327-f862u8envms01fra
Tags: upstream-0.1.0~20140703.ddf8f47+dfsg1
Import upstream version 0.1.0~20140703.ddf8f47+dfsg1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Externals/LibXML/check-relaxng-test-suite.py
 
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()