test: comparison tests/run-tests.py

equal deleted inserted replaced

-:337e1ceae82e
+:0928d50a0abe
 import tempfile
 import time
 import re
 import threading
 import killdaemons as killmod
+import cPickle as pickle
 processlock = threading.Lock()
 closefds = os.name == 'posix'
 def Popen4(cmd, wd, timeout):
 parser.add_option("--shell", type="string",
 help="shell to use (default: $%s or %s)" % defaults['shell'])
 parser.add_option("-t", "--timeout", type="int",
 help="kill errant tests after TIMEOUT seconds"
 " (default: $%s or %d)" % defaults['timeout'])
+parser.add_option("--time", action="store_true",
+help="time how long each test takes")
 parser.add_option("--tmpdir", type="string",
 help="run tests in the given temporary directory"
 " (implies --keep-tmpdir)")
 parser.add_option("-v", "--verbose", action="store_true",
 help="output verbose messages")
 if options.debug:
 if options.timeout != defaults['timeout']:
 sys.stderr.write(
 'warning: --timeout option ignored with --debug\n')
 options.timeout = 0
+if options.time:
+sys.stderr.write(
+'warning: --time option ignored with --debug\n')
+options.time = False
 if options.py3k_warnings:
 if sys.version_info[:2] < (2, 6) or sys.version_info[:2] >= (3, 0):
 parser.error('--py3k-warnings can only be used on Python 2.6+')
 if options.blacklist:
 options.blacklist = parselistfiles(options.blacklist, 'blacklist')
 rc = os.path.join(TESTDIR, '.coveragerc')
 vlog('# Installing coverage rc to %s' % rc)
 os.environ['COVERAGE_PROCESS_START'] = rc
 fn = os.path.join(INST, '..', '.coverage')
 os.environ['COVERAGE_FILE'] = fn
+def outputtimes(options):
+vlog('# Producing time report')
+times.sort(key=lambda t: (t[1], t[0]), reverse=True)
+cols = '%7.3f   %s'
+print '\n%-7s   %s' % ('Time', 'Test')
+for test, timetaken in times:
+print cols % (timetaken, test)
 def outputcoverage(options):
 vlog('# Producing coverage report')
 os.chdir(PYTHONDIR)
 '''tristate output:
 None -> skipped
 True -> passed
 False -> failed'''
-global results, resultslock, iolock
+global results, iolock
 testpath = os.path.join(TESTDIR, test)
-def result(l, e):
-resultslock.acquire()
-results[l].append(e)
-resultslock.release()
 def skip(msg):
 if not options.verbose:
-result('s', (test, msg))
+results['s'].append((test, msg))
 else:
 iolock.acquire()
 print "\nSkipping %s: %s" % (testpath, msg)
 iolock.release()
 return None
 if answer.lower() in "y yes".split():
 if test.endswith(".t"):
 rename(testpath + ".err", testpath)
 else:
 rename(testpath + ".err", testpath + ".out")
-result('p', test)
+success(test)
 return
-result('f', (test, msg))
+results['f'].append((test, msg))
 def success():
-result('p', test)
+results['p'].append(test)
 def ignore(msg):
-result('i', (test, msg))
+results['i'].append((test, msg))
 if (os.path.basename(test).startswith("test-") and '~' not in test and
 ('.' not in test or test.endswith('.py') or
 test.endswith('.bat') or test.endswith('.t'))):
 if not os.path.exists(test):
 for c in testtmp), '$TESTTMP'))
 else:
 replacements.append((re.escape(testtmp), '$TESTTMP'))
 os.mkdir(testtmp)
+if options.time:
+starttime = time.time()
 ret, out = runner(testpath, testtmp, options, replacements)
+if options.time:
+endtime = time.time()
+times.append((test, endtime - starttime))
 vlog("# Ret was:", ret)
 mark = '.'
 skipped = (ret == SKIPPED_STATUS)
 childopts = ['--child=%d' % wfd, '--port=%d' % (options.port + j * 3)]
 childtmp = os.path.join(HGTMP, 'child%d' % j)
 childopts += ['--tmpdir', childtmp]
 cmdline = [PYTHON, sys.argv[0]] + opts + childopts + job
 vlog(' '.join(cmdline))
-fps[os.spawnvp(os.P_NOWAIT, cmdline[0], cmdline)] = os.fdopen(rfd, 'r')
+fps[os.spawnvp(os.P_NOWAIT, cmdline[0], cmdline)] = os.fdopen(rfd, 'rb')
 os.close(wfd)
 signal.signal(signal.SIGINT, signal.SIG_IGN)
 failures = 0
-tested, skipped, failed = 0, 0, 0
+passed, skipped, failed = 0, 0, 0
 skips = []
 fails = []
 while fps:
 pid, status = os.wait()
 fp = fps.pop(pid)
-l = fp.read().splitlines()
 try:
-test, skip, fail = map(int, l[:3])
+childresults = pickle.load(fp)
-except ValueError:
+except pickle.UnpicklingError:
-test, skip, fail = 0, 0, 0
+pass
-split = -fail or len(l)
+else:
-for s in l[3:split]:
+passed += len(childresults['p'])
-skips.append(s.split(" ", 1))
+skipped += len(childresults['s'])
-for s in l[split:]:
+failed += len(childresults['f'])
-fails.append(s.split(" ", 1))
+skips.extend(childresults['s'])
-tested += test
+fails.extend(childresults['f'])
-skipped += skip
+if options.time:
-failed += fail
+childtimes = pickle.load(fp)
+times.extend(childtimes)
 vlog('pid %d exited, status %d' % (pid, status))
 failures |= status
 print
 skipped += len(blacklisted)
 if not options.noskips:
 for s in fails:
 print "Failed %s: %s" % (s[0], s[1])
 _checkhglib("Tested")
 print "# Ran %d tests, %d skipped, %d failed." % (
-tested, skipped, failed)
+passed + failed, skipped, failed)
+if options.time:
+outputtimes(options)
 if options.anycoverage:
 outputcoverage(options)
 sys.exit(failures != 0)
 results = dict(p=[], f=[], s=[], i=[])
-resultslock = threading.Lock()
+times = []
 iolock = threading.Lock()
-def runqueue(options, tests, results):
+def runqueue(options, tests):
 for test in tests:
 ret = runone(options, test)
 if options.first and ret is not None and not ret:
 break
 tests.pop(0)
 if not tests:
 print "running all tests"
 tests = orig
-runqueue(options, tests, results)
+runqueue(options, tests)
 failed = len(results['f'])
 tested = len(results['p']) + failed
 skipped = len(results['s'])
 ignored = len(results['i'])
 if options.child:
-fp = os.fdopen(options.child, 'w')
+fp = os.fdopen(options.child, 'wb')
-fp.write('%d\n%d\n%d\n' % (tested, skipped, failed))
+pickle.dump(results, fp, pickle.HIGHEST_PROTOCOL)
-for s in results['s']:
+if options.time:
-fp.write("%s %s\n" % s)
+pickle.dump(times, fp, pickle.HIGHEST_PROTOCOL)
-for s in results['f']:
-fp.write("%s %s\n" % s)
 fp.close()
 else:
 print
 for s in results['s']:
 print "Skipped %s: %s" % s
 for s in results['f']:
 print "Failed %s: %s" % s
 _checkhglib("Tested")
 print "# Ran %d tests, %d skipped, %d failed." % (
 tested, skipped + ignored, failed)
+if options.time:
+outputtimes(options)
 if options.anycoverage:
 outputcoverage(options)
 except KeyboardInterrupt:
 failed = True

changeset 1162	0928d50a0abe
parent 1161	ce884838a955
child 1163	d5d13134793a