📄 xstc.py
字号:
# TODO: Is this one necessary, or will an exception
# be already raised?
raise Exception("Could not create the instance parser context.")
try:
try:
instance = instance_parserCtxt.ctxtReadFile(filePath, None, libxml2.XML_PARSE_NOWARNING)
except:
# Suppress exceptions.
pass
finally:
del instance_parserCtxt
self.debugMsg("after loading instance")
if instance is None:
self.debugMsg("instance is None")
self.failCritical("Failed to parse the instance for unknown reasons.")
return
else:
try:
#
# Validate the instance.
#
validation_Ctxt = schema.schemaNewValidCtxt()
#validation_Ctxt = libxml2.schemaNewValidCtxt(None)
if (validation_Ctxt is None):
self.failCritical("Could not create the validation context.")
return
try:
self.debugMsg("validating instance")
instance_Err = validation_Ctxt.schemaValidateDoc(instance)
self.debugMsg("after instance validation")
self.debugMsg("instance-err: %d" % instance_Err)
if (instance_Err != 0 and self.instance_Val == 1) or (instance_Err == 0 and self.instance_Val == 0):
self.debugMsg("instance result is BAD")
if (instance_Err != 0):
self.fail(msgInstanceNotValidButShould)
else:
self.fail(msgInstanceValidButShouldNot)
else:
self.debugMsg("instance result is OK")
finally:
del validation_Ctxt
finally:
instance.freeDoc()
def run(self):
"""Runs a test."""
global options
# os.path.join(options.baseDir, self.test_Folder, self.schema_Folder, self.schema_File)
filePath = "%s/%s/%s/%s" % (options.baseDir, self.test_Folder, self.schema_Folder, self.schema_File)
schema = None
try:
schema = self.processSchema(filePath)
try:
if self.instance_Exists and (schema is not None) and (not self.failed):
filePath = "%s/%s/%s/%s" % (options.baseDir, self.test_Folder, self.instance_Folder, self.instance_File)
self.processInstance(filePath, schema)
finally:
if schema is not None:
del schema
except (Exception, libxml2.parserError, libxml2.treeError), e:
self.failExcept(e)
####################
# Test runner class.
#
class MSTestRunner:
CNT_TOTAL = 0
CNT_RAN = 1
CNT_SUCCEEDED = 2
CNT_FAILED = 3
CNT_UNIMPLEMENTED = 4
CNT_INTERNAL = 5
CNT_BAD = 6
CNT_EXCEPTED = 7
CNT_MEMLEAK = 8
def __init__(self):
self.logFile = None
self.counters = self.createCounters()
self.testList = []
self.combinesRan = {}
def createCounters(self):
counters = {self.CNT_TOTAL:0, self.CNT_RAN:0, self.CNT_SUCCEEDED:0,
self.CNT_FAILED:0, self.CNT_UNIMPLEMENTED:0, self.CNT_INTERNAL:0, self.CNT_BAD:0,
self.CNT_EXCEPTED:0, self.CNT_MEMLEAK:0}
return counters
def addTest(self, test):
self.testList.append(test)
def updateCounters(self, test, counters):
if test.memLeak != 0:
counters[self.CNT_MEMLEAK] += 1
if not test.failed:
counters[self.CNT_SUCCEEDED] +=1
if test.failed:
counters[self.CNT_FAILED] += 1
if test.bad:
counters[self.CNT_BAD] += 1
if test.unimplemented:
counters[self.CNT_UNIMPLEMENTED] += 1
if test.internalErr:
counters[self.CNT_INTERNAL] += 1
if test.excepted:
counters[self.CNT_EXCEPTED] += 1
return counters
def displayResults(self, out, all, combName, counters):
out.write("\n")
if all:
if options.combines is not None:
out.write("combine(s): %s\n" % str(options.combines))
elif combName is not None:
out.write("combine : %s\n" % combName)
out.write(" total : %d\n" % counters[self.CNT_TOTAL])
if all or options.combines is not None:
out.write(" ran : %d\n" % counters[self.CNT_RAN])
# out.write(" succeeded : %d\n" % counters[self.CNT_SUCCEEDED])
if counters[self.CNT_FAILED] > 0:
out.write(" failed : %d\n" % counters[self.CNT_FAILED])
out.write(" -> internal : %d\n" % counters[self.CNT_INTERNAL])
out.write(" -> unimpl. : %d\n" % counters[self.CNT_UNIMPLEMENTED])
out.write(" -> bad : %d\n" % counters[self.CNT_BAD])
out.write(" -> exceptions : %d\n" % counters[self.CNT_EXCEPTED])
if counters[self.CNT_MEMLEAK] > 0:
out.write(" memory leaks : %d\n" % counters[self.CNT_MEMLEAK])
def displayShortResults(self, out, all, combName, counters):
out.write("Ran %d of %d tests:" % (counters[self.CNT_RAN],
counters[self.CNT_TOTAL]))
# out.write(" succeeded : %d\n" % counters[self.CNT_SUCCEEDED])
if counters[self.CNT_FAILED] > 0 or counters[self.CNT_MEMLEAK] > 0:
out.write(" %d failed" % (counters[self.CNT_FAILED]))
if counters[self.CNT_INTERNAL] > 0:
out.write(" %d internal" % (counters[self.CNT_INTERNAL]))
if counters[self.CNT_UNIMPLEMENTED] > 0:
out.write(" %d unimplemented" % (counters[self.CNT_UNIMPLEMENTED]))
if counters[self.CNT_BAD] > 0:
out.write(" %d bad" % (counters[self.CNT_BAD]))
if counters[self.CNT_EXCEPTED] > 0:
out.write(" %d exception" % (counters[self.CNT_EXCEPTED]))
if counters[self.CNT_MEMLEAK] > 0:
out.write(" %d leaks" % (counters[self.CNT_MEMLEAK]))
out.write("\n")
else:
out.write(" all passed\n")
def reportCombine(self, combName):
global options
counters = self.createCounters()
#
# Compute evaluation counters.
#
for test in self.combinesRan[combName]:
counters[self.CNT_TOTAL] += 1
counters[self.CNT_RAN] += 1
counters = self.updateCounters(test, counters)
if options.reportErrCombines and (counters[self.CNT_FAILED] == 0) and (counters[self.CNT_MEMLEAK] == 0):
pass
else:
if not options.disableLog:
self.displayResults(self.logFile, False, combName, counters)
self.displayResults(sys.stdout, False, combName, counters)
def displayTestLog(self, test):
sys.stdout.writelines(test.log)
sys.stdout.write("~~~~~~~~~~\n")
def reportTest(self, test):
global options
error = test.failed or test.memLeak != 0
#
# Only erroneous tests will be written to the log,
# except @verbose is switched on.
#
if not options.disableLog and (options.verbose or error):
self.logFile.writelines(test.log)
self.logFile.write("~~~~~~~~~~\n")
#
# if not @silent, only erroneous tests will be
# written to stdout, except @verbose is switched on.
#
if not options.silent:
if options.reportInternalErrOnly and test.internalErr:
self.displayTestLog(test)
if options.reportMemLeakErrOnly and test.memLeak != 0:
self.displayTestLog(test)
if (options.verbose or error) and (not options.reportInternalErrOnly) and (not options.reportMemLeakErrOnly):
self.displayTestLog(test)
def addToCombines(self, test):
found = False
if self.combinesRan.has_key(test.combineName):
self.combinesRan[test.combineName].append(test)
else:
self.combinesRan[test.combineName] = [test]
def run(self):
global options
if options.info:
for test in self.testList:
self.addToCombines(test)
sys.stdout.write("Combines: %d\n" % len(self.combinesRan))
sys.stdout.write("%s\n" % self.combinesRan.keys())
return
if not options.disableLog:
self.logFile = open(options.logFile, "w")
try:
for test in self.testList:
self.counters[self.CNT_TOTAL] += 1
#
# Filter tests.
#
if options.singleTest is not None and options.singleTest != "":
if (test.name != options.singleTest):
continue
elif options.combines is not None:
if not options.combines.__contains__(test.combineName):
continue
if options.maxTestCount != -1 and self.counters[self.CNT_RAN] >= options.maxTestCount:
break
self.counters[self.CNT_RAN] += 1
#
# Run the thing, dammit.
#
try:
test.setUp()
try:
test.run()
finally:
test.tearDown()
finally:
#
# Evaluate.
#
test.finalize()
self.reportTest(test)
if options.reportCombines or options.reportErrCombines:
self.addToCombines(test)
self.counters = self.updateCounters(test, self.counters)
finally:
if options.reportCombines or options.reportErrCombines:
#
# Build a report for every single combine.
#
# TODO: How to sort a dict?
#
self.combinesRan.keys().sort(None)
for key in self.combinesRan.keys():
self.reportCombine(key)
#
# Display the final report.
#
if options.silent:
self.displayShortResults(sys.stdout, True, None, self.counters)
else:
sys.stdout.write("===========================\n")
self.displayResults(sys.stdout, True, None, self.counters)
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -