diff options
Diffstat (limited to 'xstc/xstc.py')
| -rwxr-xr-x | xstc/xstc.py | 542 |
1 files changed, 542 insertions, 0 deletions
diff --git a/xstc/xstc.py b/xstc/xstc.py new file mode 100755 index 00000000..538a92c6 --- /dev/null +++ b/xstc/xstc.py @@ -0,0 +1,542 @@ +# +# This is the MS subset of the W3C test suite for XML Schemas. +# This file is generated from the MS W3c test suite description file. +# + +import sys, os +import exceptions, optparse +import libxml2 + +opa = optparse.OptionParser() + +opa.add_option("-b", "--base", action="store", type="string", dest="baseDir", + default="", + help="""The base directory; i.e. the parent folder of the + "nisttest", "suntest" and "msxsdtest" directories.""") + +opa.add_option("-o", "--out", action="store", type="string", dest="logFile", + default="test.log", + help="The filepath of the log file to be created") + +opa.add_option("--no-log", action="store_true", dest="disableLog", + default=False, + help="The filepath of the log file to be created") + +opa.add_option("--no-test-out", action="store_true", dest="disableTestStdOut", + default=False, + help="The filepath of the log file to be created") + +opa.add_option("-s", "--silent", action="store_true", dest="silent", default=False, + help="Disables display of all tests") + +opa.add_option("-v", "--verbose", action="store_true", dest="verbose", + default=False, + help="Displays all tests (only if --silent is not set)") + +opa.add_option("-x", "--max", type="int", dest="maxTestCount", + default="-1", + help="The maximum number of tests to be run") + +opa.add_option("-t", "--test", type="string", dest="singleTest", + default=None, + help="Runs the specified test only") + +opa.add_option("--rieo", "--report-internal-errors-only", action="store_true", + dest="reportInternalErrOnly", default=False, + help="Display erroneous tests of type 'internal' only") + +opa.add_option("--rmleo", "--report-mem-leak-errors-only", action="store_true", + dest="reportMemLeakErrOnly", default=False, + help="Display erroneous tests of type 'memory leak' only") + +opa.add_option("-c", "--combines", type="string", dest="combines", + default=None, + help="Combines to be run (all if omitted)") + +opa.add_option("--rc", "--report-combines", action="store_true", + dest="reportCombines", default=False, + help="Display combine reports") + +opa.add_option("--rec", "--report-err-combines", action="store_true", + dest="reportErrCombines", default=False, + help="Display erroneous combine reports only") + +opa.add_option("--debug", action="store_true", + dest="debugEnabled", default=False, + help="Displays debug messages") + +opa.add_option("--info", action="store_true", + dest="info", default=False, + help="Displays info on the suite only. Does not run any test.") + +(options, args) = opa.parse_args() + +if options.combines is not None: + options.combines = options.combines.split() + +################################################ +# The vars below are not intended to be changed. +# + +msgSchemaNotValidButShould = "The schema should be valid." +msgSchemaValidButShouldNot = "The schema should be invalid." +msgInstanceNotValidButShould = "The instance should be valid." +msgInstanceValidButShouldNot = "The instance should be invalid." +testFolderNIST = "nisttest" +testFolderMS = "msxsdtest" +testFolderSUN = "suntest" + +################### +# Helper functions. +# + +def handleError(test, msg): + test.addLibLog("'%s' LIB: %s" % (test.name, msg)) + if msg.find("Unimplemented") > -1: + test.failUnimplemented() + elif msg.find("Internal") > -1: + test.failInternal() + + +################## +# Test case class. +# + +class MSTestCase: + + def __init__(self, name, descr, tFolder, sFolder, sFile, sVal, iExists, iFolder, iFile, iVal): + global testFolderNIST, testFolderSUN, testFolderMS + # + # Init. + # + self.name = name + self.descr = descr + self.test_Folder = tFolder + self.schema_Folder = sFolder + self.schema_File = sFile + self.schema_Val = sVal + self.instance_Exists = iExists + self.instance_Folder = iFolder + self.instance_File = iFile + self.instance_Val = iVal + self.failed = False + self.log = [] + self.libLog = [] + self.phase = "" + self.initialMemUsed = 0 + self.memLeak = 0 + self.excepted = False + self.bad = False + self.unimplemented = False + self.internalErr = False + # + # Compute combine name of this test. + # + if self.test_Folder == testFolderMS or self.test_Folder == testFolderSUN: + # + # Use the last given directory for the combine name. + # + dirs = self.schema_Folder.split("/") + self.combineName = dirs[len(dirs) -1] + elif self.test_Folder == testFolderNIST: + # + # NIST files are named in the following form: + # "NISTSchema-short-pattern-1.xsd" + # + tokens = self.schema_File.split("-") + self.combineName = tokens[1] + else: + self.combineName = "unkown" + raise Exception("Could not compute the combine name of a test.") + # + # Init the log. + # + self.log.append("'%s' descr: %s\n" % (self.name, self.descr)) + self.log.append("'%s' exp schema valid: %d\n" % (self.name, self.schema_Val)) + if (self.instance_Exists): + self.log.append("'%s' exp instance valid: %d\n" % (self.name, self.schema_Val)) + + def addLibLog(self, msg): + """This one is intended to be used by the error handler + function""" + self.libLog.append(msg) + + def fail(self, msg): + self.failed = True + self.log.append("'%s' ( FAILED: %s\n" % (self.name, msg)) + + def failInternal(self): + self.failed = True + self.internalErr = True + self.log.append("'%s' * INTERNAL\n" % self.name) + + def failUnimplemented(self): + self.failed = True + self.unimplemented = True + self.log.append("'%s' ? UNIMPLEMENTED\n" % self.name) + + def failCritical(self, msg): + self.failed = True + self.bad = True + self.log.append("'%s' ! BAD: %s\n" % (self.name, msg)) + + def failExcept(self, e): + self.failed = True + self.excepted = True + self.log.append("'%s' # EXCEPTION: %s\n" % (self.name, e.__str__())) + + def setUp(self): + # + # Set up Libxml2. + # + self.initialMemUsed = libxml2.debugMemory(1) + libxml2.initParser() + libxml2.lineNumbersDefault(1) + libxml2.registerErrorHandler(handleError, self) + + def tearDown(self): + libxml2.schemaCleanupTypes() + libxml2.cleanupParser() + self.memLeak = libxml2.debugMemory(1) - self.initialMemUsed + + def isIOError(self, file, docType): + err = None + try: + err = libxml2.lastError() + except: + # Suppress exceptions. + pass + if (err is None): + return False + if err.domain() == libxml2.XML_FROM_IO: + self.failCritical("failed to access the %s resource '%s'\n" % (docType, file)) + + def debugMsg(self, msg): + global options + if options.debugEnabled: + sys.stdout.write("'%s' DEBUG: %s\n" % (self.name, msg)) + + def finalize(self): + """Adds additional info to the log.""" + # + # Add libxml2 messages. + # + self.log.extend(self.libLog) + # + # Add memory leaks. + # + if self.memLeak != 0: + self.log.append("%s + memory leak: %d bytes\n" % (self.name, self.memLeak)) + + def processSchema(self, filePath): + global msgSchemaNotValidButShould, msgSchemaValidButShouldNot + schema = None + + # + # Parse the schema. + # + self.debugMsg("loading schema: %s" % filePath) + schema_ParserCtxt = libxml2.schemaNewParserCtxt(filePath) + try: + try: + schema = schema_ParserCtxt.schemaParse() + except: + pass + finally: + self.debugMsg("after loading schema") + del schema_ParserCtxt + if schema is None: + self.debugMsg("schema is None") + self.debugMsg("checking for IO errors...") + if self.isIOError(file, "schema"): + return None + self.debugMsg("checking schema result") + if (schema is None and self.schema_Val) or (schema is not None and self.schema_Val == 0): + self.debugMsg("schema result is BAD") + if (schema == None): + self.fail(msgSchemaNotValidButShould) + else: + self.fail(msgSchemaValidButShouldNot) + else: + self.debugMsg("schema result is OK") + self.debugMsg("after checking schema result") + + def processInstance(self, filePath, schema): + global msgInstanceNotValidButShould, msgInstanceValidButShouldNot + + instance = None + self.debugMsg("loading instance: %s" % file) + instance_parserCtxt = libxml2.newParserCtxt() + if (instance_parserCtxt is None): + # 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(file, 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() + 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): + file = "%s/%s/%s/%s" % (options.baseDir, self.test_Folder, self.instance_Folder, self.instance_File) + processInstance(filePath, schema) + finally: + if schema is not None: + del schema + + except Exception, 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) |