Annotation of embedaddon/libxml2/regressions.py, revision 1.1
1.1 ! misho 1: #!/usr/bin/python -u
! 2: import glob, os, string, sys, thread, time
! 3: # import difflib
! 4: import libxml2
! 5:
! 6: ###
! 7: #
! 8: # This is a "Work in Progress" attempt at a python script to run the
! 9: # various regression tests. The rationale for this is that it should be
! 10: # possible to run this on most major platforms, including those (such as
! 11: # Windows) which don't support gnu Make.
! 12: #
! 13: # The script is driven by a parameter file which defines the various tests
! 14: # to be run, together with the unique settings for each of these tests. A
! 15: # script for Linux is included (regressions.xml), with comments indicating
! 16: # the significance of the various parameters. To run the tests under Windows,
! 17: # edit regressions.xml and remove the comment around the default parameter
! 18: # "<execpath>" (i.e. make it point to the location of the binary executables).
! 19: #
! 20: # Note that this current version requires the Python bindings for libxml2 to
! 21: # have been previously installed and accessible
! 22: #
! 23: # See Copyright for the status of this software.
! 24: # William Brack (wbrack@mmm.com.hk)
! 25: #
! 26: ###
! 27: defaultParams = {} # will be used as a dictionary to hold the parsed params
! 28:
! 29: # This routine is used for comparing the expected stdout / stdin with the results.
! 30: # The expected data has already been read in; the result is a file descriptor.
! 31: # Within the two sets of data, lines may begin with a path string. If so, the
! 32: # code "relativises" it by removing the path component. The first argument is a
! 33: # list already read in by a separate thread; the second is a file descriptor.
! 34: # The two 'base' arguments are to let me "relativise" the results files, allowing
! 35: # the script to be run from any directory.
! 36: def compFiles(res, expected, base1, base2):
! 37: l1 = len(base1)
! 38: exp = expected.readlines()
! 39: expected.close()
! 40: # the "relativisation" is done here
! 41: for i in range(len(res)):
! 42: j = string.find(res[i],base1)
! 43: if (j == 0) or ((j == 2) and (res[i][0:2] == './')):
! 44: col = string.find(res[i],':')
! 45: if col > 0:
! 46: start = string.rfind(res[i][:col], '/')
! 47: if start > 0:
! 48: res[i] = res[i][start+1:]
! 49:
! 50: for i in range(len(exp)):
! 51: j = string.find(exp[i],base2)
! 52: if (j == 0) or ((j == 2) and (exp[i][0:2] == './')):
! 53: col = string.find(exp[i],':')
! 54: if col > 0:
! 55: start = string.rfind(exp[i][:col], '/')
! 56: if start > 0:
! 57: exp[i] = exp[i][start+1:]
! 58:
! 59: ret = 0
! 60: # ideally we would like to use difflib functions here to do a
! 61: # nice comparison of the two sets. Unfortunately, during testing
! 62: # (using python 2.3.3 and 2.3.4) the following code went into
! 63: # a dead loop under windows. I'll pursue this later.
! 64: # diff = difflib.ndiff(res, exp)
! 65: # diff = list(diff)
! 66: # for line in diff:
! 67: # if line[:2] != ' ':
! 68: # print string.strip(line)
! 69: # ret = -1
! 70:
! 71: # the following simple compare is fine for when the two data sets
! 72: # (actual result vs. expected result) are equal, which should be true for
! 73: # us. Unfortunately, if the test fails it's not nice at all.
! 74: rl = len(res)
! 75: el = len(exp)
! 76: if el != rl:
! 77: print 'Length of expected is %d, result is %d' % (el, rl)
! 78: ret = -1
! 79: for i in range(min(el, rl)):
! 80: if string.strip(res[i]) != string.strip(exp[i]):
! 81: print '+:%s-:%s' % (res[i], exp[i])
! 82: ret = -1
! 83: if el > rl:
! 84: for i in range(rl, el):
! 85: print '-:%s' % exp[i]
! 86: ret = -1
! 87: elif rl > el:
! 88: for i in range (el, rl):
! 89: print '+:%s' % res[i]
! 90: ret = -1
! 91: return ret
! 92:
! 93: # Separate threads to handle stdout and stderr are created to run this function
! 94: def readPfile(file, list, flag):
! 95: data = file.readlines() # no call by reference, so I cheat
! 96: for l in data:
! 97: list.append(l)
! 98: file.close()
! 99: flag.append('ok')
! 100:
! 101: # This routine runs the test program (e.g. xmllint)
! 102: def runOneTest(testDescription, filename, inbase, errbase):
! 103: if 'execpath' in testDescription:
! 104: dir = testDescription['execpath'] + '/'
! 105: else:
! 106: dir = ''
! 107: cmd = os.path.abspath(dir + testDescription['testprog'])
! 108: if 'flag' in testDescription:
! 109: for f in string.split(testDescription['flag']):
! 110: cmd += ' ' + f
! 111: if 'stdin' not in testDescription:
! 112: cmd += ' ' + inbase + filename
! 113: if 'extarg' in testDescription:
! 114: cmd += ' ' + testDescription['extarg']
! 115:
! 116: noResult = 0
! 117: expout = None
! 118: if 'resext' in testDescription:
! 119: if testDescription['resext'] == 'None':
! 120: noResult = 1
! 121: else:
! 122: ext = '.' + testDescription['resext']
! 123: else:
! 124: ext = ''
! 125: if not noResult:
! 126: try:
! 127: fname = errbase + filename + ext
! 128: expout = open(fname, 'rt')
! 129: except:
! 130: print "Can't open result file %s - bypassing test" % fname
! 131: return
! 132:
! 133: noErrors = 0
! 134: if 'reserrext' in testDescription:
! 135: if testDescription['reserrext'] == 'None':
! 136: noErrors = 1
! 137: else:
! 138: if len(testDescription['reserrext'])>0:
! 139: ext = '.' + testDescription['reserrext']
! 140: else:
! 141: ext = ''
! 142: else:
! 143: ext = ''
! 144: if not noErrors:
! 145: try:
! 146: fname = errbase + filename + ext
! 147: experr = open(fname, 'rt')
! 148: except:
! 149: experr = None
! 150: else:
! 151: experr = None
! 152:
! 153: pin, pout, perr = os.popen3(cmd)
! 154: if 'stdin' in testDescription:
! 155: infile = open(inbase + filename, 'rt')
! 156: pin.writelines(infile.readlines())
! 157: infile.close()
! 158: pin.close()
! 159:
! 160: # popen is great fun, but can lead to the old "deadly embrace", because
! 161: # synchronizing the writing (by the task being run) of stdout and stderr
! 162: # with respect to the reading (by this task) is basically impossible. I
! 163: # tried several ways to cheat, but the only way I have found which works
! 164: # is to do a *very* elementary multi-threading approach. We can only hope
! 165: # that Python threads are implemented on the target system (it's okay for
! 166: # Linux and Windows)
! 167:
! 168: th1Flag = [] # flags to show when threads finish
! 169: th2Flag = []
! 170: outfile = [] # lists to contain the pipe data
! 171: errfile = []
! 172: th1 = thread.start_new_thread(readPfile, (pout, outfile, th1Flag))
! 173: th2 = thread.start_new_thread(readPfile, (perr, errfile, th2Flag))
! 174: while (len(th1Flag)==0) or (len(th2Flag)==0):
! 175: time.sleep(0.001)
! 176: if not noResult:
! 177: ret = compFiles(outfile, expout, inbase, 'test/')
! 178: if ret != 0:
! 179: print 'trouble with %s' % cmd
! 180: else:
! 181: if len(outfile) != 0:
! 182: for l in outfile:
! 183: print l
! 184: print 'trouble with %s' % cmd
! 185: if experr != None:
! 186: ret = compFiles(errfile, experr, inbase, 'test/')
! 187: if ret != 0:
! 188: print 'trouble with %s' % cmd
! 189: else:
! 190: if not noErrors:
! 191: if len(errfile) != 0:
! 192: for l in errfile:
! 193: print l
! 194: print 'trouble with %s' % cmd
! 195:
! 196: if 'stdin' not in testDescription:
! 197: pin.close()
! 198:
! 199: # This routine is called by the parameter decoding routine whenever the end of a
! 200: # 'test' section is encountered. Depending upon file globbing, a large number of
! 201: # individual tests may be run.
! 202: def runTest(description):
! 203: testDescription = defaultParams.copy() # set defaults
! 204: testDescription.update(description) # override with current ent
! 205: if 'testname' in testDescription:
! 206: print "## %s" % testDescription['testname']
! 207: if not 'file' in testDescription:
! 208: print "No file specified - can't run this test!"
! 209: return
! 210: # Set up the source and results directory paths from the decoded params
! 211: dir = ''
! 212: if 'srcdir' in testDescription:
! 213: dir += testDescription['srcdir'] + '/'
! 214: if 'srcsub' in testDescription:
! 215: dir += testDescription['srcsub'] + '/'
! 216:
! 217: rdir = ''
! 218: if 'resdir' in testDescription:
! 219: rdir += testDescription['resdir'] + '/'
! 220: if 'ressub' in testDescription:
! 221: rdir += testDescription['ressub'] + '/'
! 222:
! 223: testFiles = glob.glob(os.path.abspath(dir + testDescription['file']))
! 224: if testFiles == []:
! 225: print "No files result from '%s'" % testDescription['file']
! 226: return
! 227:
! 228: # Some test programs just don't work (yet). For now we exclude them.
! 229: count = 0
! 230: excl = []
! 231: if 'exclfile' in testDescription:
! 232: for f in string.split(testDescription['exclfile']):
! 233: glb = glob.glob(dir + f)
! 234: for g in glb:
! 235: excl.append(os.path.abspath(g))
! 236:
! 237: # Run the specified test program
! 238: for f in testFiles:
! 239: if not os.path.isdir(f):
! 240: if f not in excl:
! 241: count = count + 1
! 242: runOneTest(testDescription, os.path.basename(f), dir, rdir)
! 243:
! 244: #
! 245: # The following classes are used with the xmlreader interface to interpret the
! 246: # parameter file. Once a test section has been identified, runTest is called
! 247: # with a dictionary containing the parsed results of the interpretation.
! 248: #
! 249:
! 250: class testDefaults:
! 251: curText = '' # accumulates text content of parameter
! 252:
! 253: def addToDict(self, key):
! 254: txt = string.strip(self.curText)
! 255: # if txt == '':
! 256: # return
! 257: if key not in defaultParams:
! 258: defaultParams[key] = txt
! 259: else:
! 260: defaultParams[key] += ' ' + txt
! 261:
! 262: def processNode(self, reader, curClass):
! 263: if reader.Depth() == 2:
! 264: if reader.NodeType() == 1:
! 265: self.curText = '' # clear the working variable
! 266: elif reader.NodeType() == 15:
! 267: if (reader.Name() != '#text') and (reader.Name() != '#comment'):
! 268: self.addToDict(reader.Name())
! 269: elif reader.Depth() == 3:
! 270: if reader.Name() == '#text':
! 271: self.curText += reader.Value()
! 272:
! 273: elif reader.NodeType() == 15: # end of element
! 274: print "Defaults have been set to:"
! 275: for k in defaultParams.keys():
! 276: print " %s : '%s'" % (k, defaultParams[k])
! 277: curClass = rootClass()
! 278: return curClass
! 279:
! 280:
! 281: class testClass:
! 282: def __init__(self):
! 283: self.testParams = {} # start with an empty set of params
! 284: self.curText = '' # and empty text
! 285:
! 286: def addToDict(self, key):
! 287: data = string.strip(self.curText)
! 288: if key not in self.testParams:
! 289: self.testParams[key] = data
! 290: else:
! 291: if self.testParams[key] != '':
! 292: data = ' ' + data
! 293: self.testParams[key] += data
! 294:
! 295: def processNode(self, reader, curClass):
! 296: if reader.Depth() == 2:
! 297: if reader.NodeType() == 1:
! 298: self.curText = '' # clear the working variable
! 299: if reader.Name() not in self.testParams:
! 300: self.testParams[reader.Name()] = ''
! 301: elif reader.NodeType() == 15:
! 302: if (reader.Name() != '#text') and (reader.Name() != '#comment'):
! 303: self.addToDict(reader.Name())
! 304: elif reader.Depth() == 3:
! 305: if reader.Name() == '#text':
! 306: self.curText += reader.Value()
! 307:
! 308: elif reader.NodeType() == 15: # end of element
! 309: runTest(self.testParams)
! 310: curClass = rootClass()
! 311: return curClass
! 312:
! 313:
! 314: class rootClass:
! 315: def processNode(self, reader, curClass):
! 316: if reader.Depth() == 0:
! 317: return curClass
! 318: if reader.Depth() != 1:
! 319: print "Unexpected junk: Level %d, type %d, name %s" % (
! 320: reader.Depth(), reader.NodeType(), reader.Name())
! 321: return curClass
! 322: if reader.Name() == 'test':
! 323: curClass = testClass()
! 324: curClass.testParams = {}
! 325: elif reader.Name() == 'defaults':
! 326: curClass = testDefaults()
! 327: return curClass
! 328:
! 329: def streamFile(filename):
! 330: try:
! 331: reader = libxml2.newTextReaderFilename(filename)
! 332: except:
! 333: print "unable to open %s" % (filename)
! 334: return
! 335:
! 336: curClass = rootClass()
! 337: ret = reader.Read()
! 338: while ret == 1:
! 339: curClass = curClass.processNode(reader, curClass)
! 340: ret = reader.Read()
! 341:
! 342: if ret != 0:
! 343: print "%s : failed to parse" % (filename)
! 344:
! 345: # OK, we're finished with all the routines. Now for the main program:-
! 346: if len(sys.argv) != 2:
! 347: print "Usage: maketest {filename}"
! 348: sys.exit(-1)
! 349:
! 350: streamFile(sys.argv[1])
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to regressions.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