third_party/libxml/src/xstc/xstc.py - Issue 1977213002: Roll libxml to 8effcb578e0590cc01bbcab0f9dccefc6bdbcdbd

Side by Side Diff: third_party/libxml/src/xstc/xstc.py

Issue 1977213002: Roll libxml to 8effcb578e0590cc01bbcab0f9dccefc6bdbcdbd (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Update README.chromium. Created 4 years, 7 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
1 #!/usr/bin/env python

2

3 #

4 # This is the MS subset of the W3C test suite for XML Schemas.

5 # This file is generated from the MS W3c test suite description file.

6 #

7

8 import sys, os

9 import exceptions, optparse

10 import libxml2

11

12 opa = optparse.OptionParser()

13

14 opa.add_option("-b", "--base", action="store", type="string", dest="baseDir",

15 default="",

16 help="""The base directory; i.e. the parent folder of the

17 "nisttest", "suntest" and "msxsdtest" directories.""" )

18

19 opa.add_option("-o", "--out", action="store", type="string", dest="logFile",

20 default="test.log",

21 help="The filepath of the log file to be created")

22

23 opa.add_option("--log", action="store_true", dest="enableLog",

24 default=False,

25 help="Create the log file")

26

27 opa.add_option("--no-test-out", action="store_true", dest="disableTestStdOut",

28 default=False,

29 help="Don't output test results")

30

31 opa.add_option("-s", "--silent", action="store_true", dest="silent", default=Fal se,

32 help="Disables display of all tests")

33

34 opa.add_option("-v", "--verbose", action="store_true", dest="verbose",

35 default=False,

36 help="Displays all tests (only if --silent is not set )")

37

38 opa.add_option("-x", "--max", type="int", dest="maxTestCount",

39 default="-1",

40 help="The maximum number of tests to be run")

41

42 opa.add_option("-t", "--test", type="string", dest="singleTest",

43 default=None,

44 help="Runs the specified test only")

45

46 opa.add_option("--tsw", "--test-starts-with", type="string", dest="testStartsWit h",

47 default=None,

48 help="Runs the specified test(s), starting with the g iven string")

49

50 opa.add_option("--rieo", "--report-internal-errors-only", action="store_true",

51 dest="reportInternalErrOnly", default=False,

52 help="Display erroneous tests of type 'internal' only ")

53

54 opa.add_option("--rueo", "--report-unimplemented-errors-only", action="store_tru e",

55 dest="reportUnimplErrOnly", default=False,

56 help="Display erroneous tests of type 'unimplemented' only")

57

58 opa.add_option("--rmleo", "--report-mem-leak-errors-only", action="store_true",

59 dest="reportMemLeakErrOnly", default=False,

60 help="Display erroneous tests of type 'memory leak' o nly")

61

62 opa.add_option("-c", "--combines", type="string", dest="combines",

63 default=None,

64 help="Combines to be run (all if omitted)")

65

66 opa.add_option("--csw", "--csw", type="string", dest="combineStartsWith",

67 default=None,

68 help="Combines to be run (all if omitted)")

69

70 opa.add_option("--rc", "--report-combines", action="store_true",

71 dest="reportCombines", default=False,

72 help="Display combine reports")

73

74 opa.add_option("--rec", "--report-err-combines", action="store_true",

75 dest="reportErrCombines", default=False,

76 help="Display erroneous combine reports only")

77

78 opa.add_option("--debug", action="store_true",

79 dest="debugEnabled", default=False,

80 help="Displays debug messages")

81

82 opa.add_option("--info", action="store_true",

83 dest="info", default=False,

84 help="Displays info on the suite only. Does not run a ny test.")

85 opa.add_option("--sax", action="store_true",

86 dest="validationSAX", default=False,

87 help="Use SAX2-driven validation.")

88 opa.add_option("--tn", action="store_true",

89 dest="displayTestName", default=False,

90 help="Display the test name in every case.")

91

92 (options, args) = opa.parse_args()

93

94 if options.combines is not None:

95 options.combines = options.combines.split()

96

97 ################################################

98 # The vars below are not intended to be changed.

99 #

100

101 msgSchemaNotValidButShould = "The schema should be valid."

102 msgSchemaValidButShouldNot = "The schema should be invalid."

103 msgInstanceNotValidButShould = "The instance should be valid."

104 msgInstanceValidButShouldNot = "The instance should be invalid."

105 vendorNIST = "NIST"

106 vendorNIST_2 = "NIST-2"

107 vendorSUN = "SUN"

108 vendorMS = "MS"

109

110 ###################

111 # Helper functions.

112 #

113 vendor = None

114

115 def handleError(test, msg):

116 global options

117 if not options.silent:

118 test.addLibLog("'%s' LIB: %s" % (test.name, msg))

119 if msg.find("Unimplemented") > -1:

120 test.failUnimplemented()

121 elif msg.find("Internal") > -1:

122 test.failInternal()

123

124

125 def fixFileNames(fileName):

126 if (fileName is None) or (fileName == ""):

127 return ""

128 dirs = fileName.split("/")

129 if dirs[1] != "Tests":

130 fileName = os.path.join(".", "Tests")

131 for dir in dirs[1:]:

132 fileName = os.path.join(fileName, dir)

133 return fileName

134

135 class XSTCTestGroup:

136 def __init__(self, name, schemaFileName, descr):

137 global vendor, vendorNIST_2

138 self.name = name

139 self.descr = descr

140 self.mainSchema = True

141 self.schemaFileName = fixFileNames(schemaFileName)

142 self.schemaParsed = False

143 self.schemaTried = False

144

145 def setSchema(self, schemaFileName, parsed):

146 if not self.mainSchema:

147 return

148 self.mainSchema = False

149 self.schemaParsed = parsed

150 self.schemaTried = True

151

152 class XSTCTestCase:

153

154 # <!-- groupName, Name, Accepted, File, Val, Descr

155 def __init__(self, isSchema, groupName, name, accepted, file, val, descr ):

156 global options

157 #

158 # Constructor.

159 #

160 self.testRunner = None

161 self.isSchema = isSchema

162 self.groupName = groupName

163 self.name = name

164 self.accepted = accepted

165 self.fileName = fixFileNames(file)

166 self.val = val

167 self.descr = descr

168 self.failed = False

169 self.combineName = None

170

171 self.log = []

172 self.libLog = []

173 self.initialMemUsed = 0

174 self.memLeak = 0

175 self.excepted = False

176 self.bad = False

177 self.unimplemented = False

178 self.internalErr = False

179 self.noSchemaErr = False

180 self.failed = False

181 #

182 # Init the log.

183 #

184 if not options.silent:

185 if self.descr is not None:

186 self.log.append("'%s' descr: %s\n" % (self.nam e, self.descr))

187 self.log.append("'%s' exp validity: %d\n" % (self.name , self.val))

188

189 def initTest(self, runner):

190 global vendorNIST, vendorSUN, vendorMS, vendorNIST_2, options, v endor

191 #

192 # Get the test-group.

193 #

194 self.runner = runner

195 self.group = runner.getGroup(self.groupName)

196 if vendor == vendorMS or vendor == vendorSUN:

197 #

198 # Use the last given directory for the combine name.

199 #

200 dirs = self.fileName.split("/")

201 self.combineName = dirs[len(dirs) -2]

202 elif vendor == vendorNIST:

203 #

204 # NIST files are named in the following form:

205 # "NISTSchema-short-pattern-1.xsd"

206 #

207 tokens = self.name.split("-")

208 self.combineName = tokens[1]

209 elif vendor == vendorNIST_2:

210 #

211 # Group-names have the form: "atomic-normalizedString-le ngth-1"

212 #

213 tokens = self.groupName.split("-")

214 self.combineName = "%s-%s" % (tokens[0], tokens[1])

215 else:

216 self.combineName = "unkown"

217 raise Exception("Could not compute the combine name of a test.")

218 if (not options.silent) and (self.group.descr is not None):

219 self.log.append("'%s' group-descr: %s\n" % (self.name, self.group.descr))

220

221

222 def addLibLog(self, msg):

223 """This one is intended to be used by the error handler

224 function"""

225 global options

226 if not options.silent:

227 self.libLog.append(msg)

228

229 def fail(self, msg):

230 global options

231 self.failed = True

232 if not options.silent:

233 self.log.append("'%s' ( FAILED: %s\n" % (self.name, msg) )

234

235 def failNoSchema(self):

236 global options

237 self.failed = True

238 self.noSchemaErr = True

239 if not options.silent:

240 self.log.append("'%s' X NO-SCHEMA\n" % (self.name))

241

242 def failInternal(self):

243 global options

244 self.failed = True

245 self.internalErr = True

246 if not options.silent:

247 self.log.append("'%s' * INTERNAL\n" % self.name)

248

249 def failUnimplemented(self):

250 global options

251 self.failed = True

252 self.unimplemented = True

253 if not options.silent:

254 self.log.append("'%s' ? UNIMPLEMENTED\n" % self.name)

255

256 def failCritical(self, msg):

257 global options

258 self.failed = True

259 self.bad = True

260 if not options.silent:

261 self.log.append("'%s' ! BAD: %s\n" % (self.name, msg))

262

263 def failExcept(self, e):

264 global options

265 self.failed = True

266 self.excepted = True

267 if not options.silent:

268 self.log.append("'%s' # EXCEPTION: %s\n" % (self.name, e .__str__()))

269

270 def setUp(self):

271 #

272 # Set up Libxml2.

273 #

274 self.initialMemUsed = libxml2.debugMemory(1)

275 libxml2.initParser()

276 libxml2.lineNumbersDefault(1)

277 libxml2.registerErrorHandler(handleError, self)

278

279 def tearDown(self):

280 libxml2.schemaCleanupTypes()

281 libxml2.cleanupParser()

282 self.memLeak = libxml2.debugMemory(1) - self.initialMemUsed

283

284 def isIOError(self, file, docType):

285 err = None

286 try:

287 err = libxml2.lastError()

288 except:

289 # Suppress exceptions.

290 pass

291 if (err is None):

292 return False

293 if err.domain() == libxml2.XML_FROM_IO:

294 self.failCritical("failed to access the %s resource '%s' \n" % (docType, file))

295

296 def debugMsg(self, msg):

297 global options

298 if options.debugEnabled:

299 sys.stdout.write("'%s' DEBUG: %s\n" % (self.name, msg) )

300

301 def finalize(self):

302 global options

303 """Adds additional info to the log."""

304 #

305 # Add libxml2 messages.

306 #

307 if not options.silent:

308 self.log.extend(self.libLog)

309 #

310 # Add memory leaks.

311 #

312 if self.memLeak != 0:

313 self.log.append("%s + memory leak: %d bytes\n" % (self.name, self.memLeak))

314

315 def run(self):

316 """Runs a test."""

317 global options

318

319 ##filePath = os.path.join(options.baseDir, self.fileName)

320 # filePath = "%s/%s/%s/%s" % (options.baseDir, self.test_Folder, self.schema_Folder, self.schema_File)

321 if options.displayTestName:

322 sys.stdout.write("'%s'\n" % self.name)

323 try:

324 self.validate()

325 except (Exception, libxml2.parserError, libxml2.treeError), e:

326 self.failExcept(e)

327

328 def parseSchema(fileName):

329 schema = None

330 ctxt = libxml2.schemaNewParserCtxt(fileName)

331 try:

332 try:

333 schema = ctxt.schemaParse()

334 except:

335 pass

336 finally:

337 del ctxt

338 return schema

339

340

341 class XSTCSchemaTest(XSTCTestCase):

342

343 def __init__(self, groupName, name, accepted, file, val, descr):

344 XSTCTestCase.__init__(self, 1, groupName, name, accepted, file, val, descr)

345

346 def validate(self):

347 global msgSchemaNotValidButShould, msgSchemaValidButShouldNot

348 schema = None

349 filePath = self.fileName

350 # os.path.join(options.baseDir, self.fileName)

351 valid = 0

352 try:

353 #

354 # Parse the schema.

355 #

356 self.debugMsg("loading schema: %s" % filePath)

357 schema = parseSchema(filePath)

358 self.debugMsg("after loading schema")

359 if schema is None:

360 self.debugMsg("schema is None")

361 self.debugMsg("checking for IO errors...")

362 if self.isIOError(file, "schema"):

363 return

364 self.debugMsg("checking schema result")

365 if (schema is None and self.val) or (schema is not None and self.val == 0):

366 self.debugMsg("schema result is BAD")

367 if (schema == None):

368 self.fail(msgSchemaNotValidButShould)

369 else:

370 self.fail(msgSchemaValidButShouldNot)

371 else:

372 self.debugMsg("schema result is OK")

373 finally:

374 self.group.setSchema(self.fileName, schema is not None)

375 del schema

376

377 class XSTCInstanceTest(XSTCTestCase):

378

379 def __init__(self, groupName, name, accepted, file, val, descr):

380 XSTCTestCase.__init__(self, 0, groupName, name, accepted, file, val, descr)

381

382 def validate(self):

383 instance = None

384 schema = None

385 filePath = self.fileName

386 # os.path.join(options.baseDir, self.fileName)

387

388 if not self.group.schemaParsed and self.group.schemaTried:

389 self.failNoSchema()

390 return

391

392 self.debugMsg("loading instance: %s" % filePath)

393 parserCtxt = libxml2.newParserCtxt()

394 if (parserCtxt is None):

395 # TODO: Is this one necessary, or will an exception

396 # be already raised?

397 raise Exception("Could not create the instance parser co ntext.")

398 if not options.validationSAX:

399 try:

400 try:

401 instance = parserCtxt.ctxtReadFile(fileP ath, None, libxml2.XML_PARSE_NOWARNING)

402 except:

403 # Suppress exceptions.

404 pass

405 finally:

406 del parserCtxt

407 self.debugMsg("after loading instance")

408 if instance is None:

409 self.debugMsg("instance is None")

410 self.failCritical("Failed to parse the instance for unknown reasons.")

411 return

412 try:

413 #

414 # Validate the instance.

415 #

416 self.debugMsg("loading schema: %s" % self.group.schemaFi leName)

417 schema = parseSchema(self.group.schemaFileName)

418 try:

419 validationCtxt = schema.schemaNewValidCtxt()

420 #validationCtxt = libxml2.schemaNewValidCtxt(Non e)

421 if (validationCtxt is None):

422 self.failCritical("Could not create the validation context.")

423 return

424 try:

425 self.debugMsg("validating instance")

426 if options.validationSAX:

427 instance_Err = validationCtxt.sc hemaValidateFile(filePath, 0)

428 else:

429 instance_Err = validationCtxt.sc hemaValidateDoc(instance)

430 self.debugMsg("after instance validation ")

431 self.debugMsg("instance-err: %d" % insta nce_Err)

432 if (instance_Err != 0 and self.val == 1) or (instance_Err == 0 and self.val == 0):

433 self.debugMsg("instance result i s BAD")

434 if (instance_Err != 0):

435 self.fail(msgInstanceNot ValidButShould)

436 else:

437 self.fail(msgInstanceVal idButShouldNot)

438

439 else:

440 self.debugMsg("i nstance result is OK")

441 finally:

442 del validationCtxt

443 finally:

444 del schema

445 finally:

446 if instance is not None:

447 instance.freeDoc()

448

449

450 ####################

451 # Test runner class.

452 #

453

454 class XSTCTestRunner:

455

456 CNT_TOTAL = 0

457 CNT_RAN = 1

458 CNT_SUCCEEDED = 2

459 CNT_FAILED = 3

460 CNT_UNIMPLEMENTED = 4

461 CNT_INTERNAL = 5

462 CNT_BAD = 6

463 CNT_EXCEPTED = 7

464 CNT_MEMLEAK = 8

465 CNT_NOSCHEMA = 9

466 CNT_NOTACCEPTED = 10

467 CNT_SCHEMA_TEST = 11

468

469 def __init__(self):

470 self.logFile = None

471 self.counters = self.createCounters()

472 self.testList = []

473 self.combinesRan = {}

474 self.groups = {}

475 self.curGroup = None

476

477 def createCounters(self):

478 counters = {self.CNT_TOTAL:0, self.CNT_RAN:0, self.CNT_SUCCEEDED :0,

479 self.CNT_FAILED:0, self.CNT_UNIMPLEMENTED:0, self.CNT_INTERNAL:0 , self.CNT_BAD:0,

480 self.CNT_EXCEPTED:0, self.CNT_MEMLEAK:0, self.CNT_NOSCHEMA:0, se lf.CNT_NOTACCEPTED:0,

481 self.CNT_SCHEMA_TEST:0}

482

483 return counters

484

485 def addTest(self, test):

486 self.testList.append(test)

487 test.initTest(self)

488

489 def getGroup(self, groupName):

490 return self.groups[groupName]

491

492 def addGroup(self, group):

493 self.groups[group.name] = group

494

495 def updateCounters(self, test, counters):

496 if test.memLeak != 0:

497 counters[self.CNT_MEMLEAK] += 1

498 if not test.failed:

499 counters[self.CNT_SUCCEEDED] +=1

500 if test.failed:

501 counters[self.CNT_FAILED] += 1

502 if test.bad:

503 counters[self.CNT_BAD] += 1

504 if test.unimplemented:

505 counters[self.CNT_UNIMPLEMENTED] += 1

506 if test.internalErr:

507 counters[self.CNT_INTERNAL] += 1

508 if test.noSchemaErr:

509 counters[self.CNT_NOSCHEMA] += 1

510 if test.excepted:

511 counters[self.CNT_EXCEPTED] += 1

512 if not test.accepted:

513 counters[self.CNT_NOTACCEPTED] += 1

514 if test.isSchema:

515 counters[self.CNT_SCHEMA_TEST] += 1

516 return counters

517

518 def displayResults(self, out, all, combName, counters):

519 out.write("\n")

520 if all:

521 if options.combines is not None:

522 out.write("combine(s): %s\n" % str(options.combi nes))

523 elif combName is not None:

524 out.write("combine : %s\n" % combName)

525 out.write(" total : %d\n" % counters[self.CNT_TOTAL])

526 if all or options.combines is not None:

527 out.write(" ran : %d\n" % counters[self.CNT _RAN])

528 out.write(" (schemata) : %d\n" % counters[self.CNT _SCHEMA_TEST])

529 # out.write(" succeeded : %d\n" % counters[self.CNT_SUC CEEDED])

530 out.write(" not accepted : %d\n" % counters[self.CNT_NOTACCE PTED])

531 if counters[self.CNT_FAILED] > 0:

532 out.write(" failed : %d\n" % counter s[self.CNT_FAILED])

533 out.write(" -> internal : %d\n" % counter s[self.CNT_INTERNAL])

534 out.write(" -> unimpl. : %d\n" % counter s[self.CNT_UNIMPLEMENTED])

535 out.write(" -> skip-invalid-schema : %d\n" % counter s[self.CNT_NOSCHEMA])

536 out.write(" -> bad : %d\n" % counter s[self.CNT_BAD])

537 out.write(" -> exceptions : %d\n" % counter s[self.CNT_EXCEPTED])

538 out.write(" memory leaks : %d\n" % counter s[self.CNT_MEMLEAK])

539

540 def displayShortResults(self, out, all, combName, counters):

541 out.write("Ran %d of %d tests (%d schemata):" % (counters[self.C NT_RAN],

542 counters[self.CNT_TOTAL], counters[self.CNT_SC HEMA_TEST]))

543 # out.write(" succeeded : %d\n" % counters[self.CNT_SUC CEEDED])

544 if counters[self.CNT_NOTACCEPTED] > 0:

545 out.write(" %d not accepted" % (counters[self.CNT_NOTACC EPTED]))

546 if counters[self.CNT_FAILED] > 0 or counters[self.CNT_MEMLEAK] > 0:

547 if counters[self.CNT_FAILED] > 0:

548 out.write(" %d failed" % (counters[self.CNT_FAIL ED]))

549 out.write(" (")

550 if counters[self.CNT_INTERNAL] > 0:

551 out.write(" %d internal" % (counters[sel f.CNT_INTERNAL]))

552 if counters[self.CNT_UNIMPLEMENTED] > 0:

553 out.write(" %d unimplemented" % (counter s[self.CNT_UNIMPLEMENTED]))

554 if counters[self.CNT_NOSCHEMA] > 0:

555 out.write(" %d skip-invalid-schema" % (c ounters[self.CNT_NOSCHEMA]))

556 if counters[self.CNT_BAD] > 0:

557 out.write(" %d bad" % (counters[self.CNT _BAD]))

558 if counters[self.CNT_EXCEPTED] > 0:

559 out.write(" %d exception" % (counters[se lf.CNT_EXCEPTED]))

560 out.write(" )")

561 if counters[self.CNT_MEMLEAK] > 0:

562 out.write(" %d leaks" % (counters[self.CNT_MEMLE AK]))

563 out.write("\n")

564 else:

565 out.write(" all passed\n")

566

567 def reportCombine(self, combName):

568 global options

569

570 counters = self.createCounters()

571 #

572 # Compute evaluation counters.

573 #

574 for test in self.combinesRan[combName]:

575 counters[self.CNT_TOTAL] += 1

576 counters[self.CNT_RAN] += 1

577 counters = self.updateCounters(test, counters)

578 if options.reportErrCombines and (counters[self.CNT_FAILED] == 0 ) and (counters[self.CNT_MEMLEAK] == 0):

579 pass

580 else:

581 if options.enableLog:

582 self.displayResults(self.logFile, False, combNam e, counters)

583 self.displayResults(sys.stdout, False, combName, counter s)

584

585 def displayTestLog(self, test):

586 sys.stdout.writelines(test.log)

587 sys.stdout.write("~~~~~~~~~~\n")

588

589 def reportTest(self, test):

590 global options

591

592 error = test.failed or test.memLeak != 0

593 #

594 # Only erroneous tests will be written to the log,

595 # except @verbose is switched on.

596 #

597 if options.enableLog and (options.verbose or error):

598 self.logFile.writelines(test.log)

599 self.logFile.write("~~~~~~~~~~\n")

600 #

601 # if not @silent, only erroneous tests will be

602 # written to stdout, except @verbose is switched on.

603 #

604 if not options.silent:

605 if options.reportInternalErrOnly and test.internalErr:

606 self.displayTestLog(test)

607 if options.reportMemLeakErrOnly and test.memLeak != 0:

608 self.displayTestLog(test)

609 if options.reportUnimplErrOnly and test.unimplemented:

610 self.displayTestLog(test)

611 if (options.verbose or error) and (not options.reportInt ernalErrOnly) and (not options.reportMemLeakErrOnly) and (not options.reportUnim plErrOnly):

612 self.displayTestLog(test)

613

614

615 def addToCombines(self, test):

616 found = False

617 if self.combinesRan.has_key(test.combineName):

618 self.combinesRan[test.combineName].append(test)

619 else:

620 self.combinesRan[test.combineName] = [test]

621

622 def run(self):

623

624 global options

625

626 if options.info:

627 for test in self.testList:

628 self.addToCombines(test)

629 sys.stdout.write("Combines: %d\n" % len(self.combinesRan ))

630 sys.stdout.write("%s\n" % self.combinesRan.keys())

631 return

632

633 if options.enableLog:

634 self.logFile = open(options.logFile, "w")

635 try:

636 for test in self.testList:

637 self.counters[self.CNT_TOTAL] += 1

638 #

639 # Filter tests.

640 #

641 if options.singleTest is not None and options.si ngleTest != "":

642 if (test.name != options.singleTest):

643 continue

644 elif options.combines is not None:

645 if not options.combines.__contains__(tes t.combineName):

646 continue

647 elif options.testStartsWith is not None:

648 if not test.name.startswith(options.test StartsWith):

649 continue

650 elif options.combineStartsWith is not None:

651 if not test.combineName.startswith(optio ns.combineStartsWith):

652 continue

653

654 if options.maxTestCount != -1 and self.counters[ self.CNT_RAN] >= options.maxTestCount:

655 break

656 self.counters[self.CNT_RAN] += 1

657 #

658 # Run the thing, dammit.

659 #

660 try:

661 test.setUp()

662 try:

663 test.run()

664 finally:

665 test.tearDown()

666 finally:

667 #

668 # Evaluate.

669 #

670 test.finalize()

671 self.reportTest(test)

672 if options.reportCombines or options.rep ortErrCombines:

673 self.addToCombines(test)

674 self.counters = self.updateCounters(test , self.counters)

675 finally:

676 if options.reportCombines or options.reportErrCombines:

677 #

678 # Build a report for every single combine.

679 #

680 # TODO: How to sort a dict?

681 #

682 self.combinesRan.keys().sort(None)

683 for key in self.combinesRan.keys():

684 self.reportCombine(key)

685

686 #

687 # Display the final report.

688 #

689 if options.silent:

690 self.displayShortResults(sys.stdout, True, None, self.counters)

691 else:

692 sys.stdout.write("===========================\n" )

693 self.displayResults(sys.stdout, True, None, self .counters)

OLD	NEW

« third_party/libxml/src/COPYING ('K') | « third_party/libxml/src/xstc/Makefile.in ('k') | third_party/libxml/src/xstc/xstc-to-python.xsl » ('j') | no next file with comments »