| #!/usr/bin/env python |
| # |
| # Copyright 2012 the V8 project authors. All rights reserved. |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions are |
| # met: |
| # |
| # * Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # * Redistributions in binary form must reproduce the above |
| # copyright notice, this list of conditions and the following |
| # disclaimer in the documentation and/or other materials provided |
| # with the distribution. |
| # * Neither the name of Google Inc. nor the names of its |
| # contributors may be used to endorse or promote products derived |
| # from this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| |
| import imp |
| import optparse |
| import os |
| from os.path import join, dirname, abspath, basename, isdir, exists |
| import platform |
| import re |
| import signal |
| import subprocess |
| import sys |
| import tempfile |
| import time |
| import threading |
| import utils |
| from Queue import Queue, Empty |
| |
| |
| VERBOSE = False |
| |
| |
| # --------------------------------------------- |
| # --- P r o g r e s s I n d i c a t o r s --- |
| # --------------------------------------------- |
| |
| |
| class ProgressIndicator(object): |
| |
| def __init__(self, cases): |
| self.cases = cases |
| self.queue = Queue(len(cases)) |
| for case in cases: |
| self.queue.put_nowait(case) |
| self.succeeded = 0 |
| self.remaining = len(cases) |
| self.total = len(cases) |
| self.failed = [ ] |
| self.crashed = 0 |
| self.terminate = False |
| self.lock = threading.Lock() |
| |
| def PrintFailureHeader(self, test): |
| if test.IsNegative(): |
| negative_marker = '[negative] ' |
| else: |
| negative_marker = '' |
| print "=== %(label)s %(negative)s===" % { |
| 'label': test.GetLabel(), |
| 'negative': negative_marker |
| } |
| print "Path: %s" % "/".join(test.path) |
| |
| def Run(self, tasks): |
| self.Starting() |
| threads = [] |
| # Spawn N-1 threads and then use this thread as the last one. |
| # That way -j1 avoids threading altogether which is a nice fallback |
| # in case of threading problems. |
| for i in xrange(tasks - 1): |
| thread = threading.Thread(target=self.RunSingle, args=[]) |
| threads.append(thread) |
| thread.start() |
| try: |
| self.RunSingle() |
| # Wait for the remaining threads |
| for thread in threads: |
| # Use a timeout so that signals (ctrl-c) will be processed. |
| thread.join(timeout=10000000) |
| except Exception, e: |
| # If there's an exception we schedule an interruption for any |
| # remaining threads. |
| self.terminate = True |
| # ...and then reraise the exception to bail out |
| raise |
| self.Done() |
| return not self.failed |
| |
| def RunSingle(self): |
| while not self.terminate: |
| try: |
| test = self.queue.get_nowait() |
| except Empty: |
| return |
| case = test.case |
| self.lock.acquire() |
| self.AboutToRun(case) |
| self.lock.release() |
| try: |
| start = time.time() |
| output = case.Run() |
| case.duration = (time.time() - start) |
| except BreakNowException: |
| self.terminate = True |
| except IOError, e: |
| assert self.terminate |
| return |
| if self.terminate: |
| return |
| self.lock.acquire() |
| if output.UnexpectedOutput(): |
| self.failed.append(output) |
| if output.HasCrashed(): |
| self.crashed += 1 |
| else: |
| self.succeeded += 1 |
| self.remaining -= 1 |
| self.HasRun(output) |
| self.lock.release() |
| |
| |
| def EscapeCommand(command): |
| parts = [] |
| for part in command: |
| if ' ' in part: |
| # Escape spaces and double quotes. We may need to escape more characters |
| # for this to work properly. |
| parts.append('"%s"' % part.replace('"', '\\"')) |
| else: |
| parts.append(part) |
| return " ".join(parts) |
| |
| |
| class SimpleProgressIndicator(ProgressIndicator): |
| |
| def Starting(self): |
| print 'Running %i tests' % len(self.cases) |
| |
| def Done(self): |
| print |
| for failed in self.failed: |
| self.PrintFailureHeader(failed.test) |
| if failed.output.stderr: |
| print "--- stderr ---" |
| print failed.output.stderr.strip() |
| if failed.output.stdout: |
| print "--- stdout ---" |
| print failed.output.stdout.strip() |
| print "Command: %s" % EscapeCommand(failed.command) |
| if failed.HasCrashed(): |
| print "--- CRASHED ---" |
| if failed.HasTimedOut(): |
| print "--- TIMEOUT ---" |
| if len(self.failed) == 0: |
| print "===" |
| print "=== All tests succeeded" |
| print "===" |
| else: |
| print |
| print "===" |
| print "=== %i tests failed" % len(self.failed) |
| if self.crashed > 0: |
| print "=== %i tests CRASHED" % self.crashed |
| print "===" |
| |
| |
| class VerboseProgressIndicator(SimpleProgressIndicator): |
| |
| def AboutToRun(self, case): |
| print 'Starting %s...' % case.GetLabel() |
| sys.stdout.flush() |
| |
| def HasRun(self, output): |
| if output.UnexpectedOutput(): |
| if output.HasCrashed(): |
| outcome = 'CRASH' |
| else: |
| outcome = 'FAIL' |
| else: |
| outcome = 'pass' |
| print 'Done running %s: %s' % (output.test.GetLabel(), outcome) |
| |
| |
| class DotsProgressIndicator(SimpleProgressIndicator): |
| |
| def AboutToRun(self, case): |
| pass |
| |
| def HasRun(self, output): |
| total = self.succeeded + len(self.failed) |
| if (total > 1) and (total % 50 == 1): |
| sys.stdout.write('\n') |
| if output.UnexpectedOutput(): |
| if output.HasCrashed(): |
| sys.stdout.write('C') |
| sys.stdout.flush() |
| elif output.HasTimedOut(): |
| sys.stdout.write('T') |
| sys.stdout.flush() |
| else: |
| sys.stdout.write('F') |
| sys.stdout.flush() |
| else: |
| sys.stdout.write('.') |
| sys.stdout.flush() |
| |
| |
| class CompactProgressIndicator(ProgressIndicator): |
| |
| def __init__(self, cases, templates): |
| super(CompactProgressIndicator, self).__init__(cases) |
| self.templates = templates |
| self.last_status_length = 0 |
| self.start_time = time.time() |
| |
| def Starting(self): |
| pass |
| |
| def Done(self): |
| self.PrintProgress('Done') |
| |
| def AboutToRun(self, case): |
| self.PrintProgress(case.GetLabel()) |
| |
| def HasRun(self, output): |
| if output.UnexpectedOutput(): |
| self.ClearLine(self.last_status_length) |
| self.PrintFailureHeader(output.test) |
| stdout = output.output.stdout.strip() |
| if len(stdout): |
| print self.templates['stdout'] % stdout |
| stderr = output.output.stderr.strip() |
| if len(stderr): |
| print self.templates['stderr'] % stderr |
| print "Command: %s" % EscapeCommand(output.command) |
| if output.HasCrashed(): |
| print "--- CRASHED ---" |
| if output.HasTimedOut(): |
| print "--- TIMEOUT ---" |
| |
| def Truncate(self, str, length): |
| if length and (len(str) > (length - 3)): |
| return str[:(length-3)] + "..." |
| else: |
| return str |
| |
| def PrintProgress(self, name): |
| self.ClearLine(self.last_status_length) |
| elapsed = time.time() - self.start_time |
| status = self.templates['status_line'] % { |
| 'passed': self.succeeded, |
| 'remaining': (((self.total - self.remaining) * 100) // self.total), |
| 'failed': len(self.failed), |
| 'test': name, |
| 'mins': int(elapsed) / 60, |
| 'secs': int(elapsed) % 60 |
| } |
| status = self.Truncate(status, 78) |
| self.last_status_length = len(status) |
| print status, |
| sys.stdout.flush() |
| |
| |
| class ColorProgressIndicator(CompactProgressIndicator): |
| |
| def __init__(self, cases): |
| templates = { |
| 'status_line': "[%(mins)02i:%(secs)02i|\033[34m%%%(remaining) 4d\033[0m|\033[32m+%(passed) 4d\033[0m|\033[31m-%(failed) 4d\033[0m]: %(test)s", |
| 'stdout': "\033[1m%s\033[0m", |
| 'stderr': "\033[31m%s\033[0m", |
| } |
| super(ColorProgressIndicator, self).__init__(cases, templates) |
| |
| def ClearLine(self, last_line_length): |
| print "\033[1K\r", |
| |
| |
| class MonochromeProgressIndicator(CompactProgressIndicator): |
| |
| def __init__(self, cases): |
| templates = { |
| 'status_line': "[%(mins)02i:%(secs)02i|%%%(remaining) 4d|+%(passed) 4d|-%(failed) 4d]: %(test)s", |
| 'stdout': '%s', |
| 'stderr': '%s', |
| } |
| super(MonochromeProgressIndicator, self).__init__(cases, templates) |
| |
| def ClearLine(self, last_line_length): |
| print ("\r" + (" " * last_line_length) + "\r"), |
| |
| |
| PROGRESS_INDICATORS = { |
| 'verbose': VerboseProgressIndicator, |
| 'dots': DotsProgressIndicator, |
| 'color': ColorProgressIndicator, |
| 'mono': MonochromeProgressIndicator |
| } |
| |
| |
| # ------------------------- |
| # --- F r a m e w o r k --- |
| # ------------------------- |
| |
| class BreakNowException(Exception): |
| def __init__(self, value): |
| self.value = value |
| def __str__(self): |
| return repr(self.value) |
| |
| |
| class CommandOutput(object): |
| |
| def __init__(self, exit_code, timed_out, stdout, stderr): |
| self.exit_code = exit_code |
| self.timed_out = timed_out |
| self.stdout = stdout |
| self.stderr = stderr |
| self.failed = None |
| |
| |
| class TestCase(object): |
| |
| def __init__(self, context, path, mode): |
| self.path = path |
| self.context = context |
| self.duration = None |
| self.mode = mode |
| |
| def IsNegative(self): |
| return False |
| |
| def TestsIsolates(self): |
| return False |
| |
| def CompareTime(self, other): |
| return cmp(other.duration, self.duration) |
| |
| def DidFail(self, output): |
| if output.failed is None: |
| output.failed = self.IsFailureOutput(output) |
| return output.failed |
| |
| def IsFailureOutput(self, output): |
| return output.exit_code != 0 |
| |
| def GetSource(self): |
| return "(no source available)" |
| |
| def RunCommand(self, command): |
| full_command = self.context.processor(command) |
| output = Execute(full_command, |
| self.context, |
| self.context.GetTimeout(self, self.mode)) |
| self.Cleanup() |
| return TestOutput(self, |
| full_command, |
| output, |
| self.context.store_unexpected_output) |
| |
| def BeforeRun(self): |
| pass |
| |
| def AfterRun(self, result): |
| pass |
| |
| def GetCustomFlags(self, mode): |
| return None |
| |
| def Run(self): |
| self.BeforeRun() |
| result = None |
| try: |
| result = self.RunCommand(self.GetCommand()) |
| except: |
| self.terminate = True |
| raise BreakNowException("User pressed CTRL+C or IO went wrong") |
| finally: |
| self.AfterRun(result) |
| return result |
| |
| def Cleanup(self): |
| return |
| |
| |
| class TestOutput(object): |
| |
| def __init__(self, test, command, output, store_unexpected_output): |
| self.test = test |
| self.command = command |
| self.output = output |
| self.store_unexpected_output = store_unexpected_output |
| |
| def UnexpectedOutput(self): |
| if self.HasCrashed(): |
| outcome = CRASH |
| elif self.HasTimedOut(): |
| outcome = TIMEOUT |
| elif self.HasFailed(): |
| outcome = FAIL |
| else: |
| outcome = PASS |
| return not outcome in self.test.outcomes |
| |
| def HasPreciousOutput(self): |
| return self.UnexpectedOutput() and self.store_unexpected_output |
| |
| def HasCrashed(self): |
| if utils.IsWindows(): |
| return 0x80000000 & self.output.exit_code and not (0x3FFFFF00 & self.output.exit_code) |
| else: |
| # Timed out tests will have exit_code -signal.SIGTERM. |
| if self.output.timed_out: |
| return False |
| return self.output.exit_code < 0 and \ |
| self.output.exit_code != -signal.SIGABRT |
| |
| def HasTimedOut(self): |
| return self.output.timed_out |
| |
| def HasFailed(self): |
| execution_failed = self.test.DidFail(self.output) |
| if self.test.IsNegative(): |
| return not execution_failed |
| else: |
| return execution_failed |
| |
| |
| def KillProcessWithID(pid): |
| if utils.IsWindows(): |
| os.popen('taskkill /T /F /PID %d' % pid) |
| else: |
| os.kill(pid, signal.SIGTERM) |
| |
| |
| MAX_SLEEP_TIME = 0.1 |
| INITIAL_SLEEP_TIME = 0.0001 |
| SLEEP_TIME_FACTOR = 1.25 |
| |
| SEM_INVALID_VALUE = -1 |
| SEM_NOGPFAULTERRORBOX = 0x0002 # Microsoft Platform SDK WinBase.h |
| |
| def Win32SetErrorMode(mode): |
| prev_error_mode = SEM_INVALID_VALUE |
| try: |
| import ctypes |
| prev_error_mode = ctypes.windll.kernel32.SetErrorMode(mode) |
| except ImportError: |
| pass |
| return prev_error_mode |
| |
| def RunProcess(context, timeout, args, **rest): |
| if context.verbose: print "#", " ".join(args) |
| popen_args = args |
| prev_error_mode = SEM_INVALID_VALUE |
| if utils.IsWindows(): |
| popen_args = subprocess.list2cmdline(args) |
| if context.suppress_dialogs: |
| # Try to change the error mode to avoid dialogs on fatal errors. Don't |
| # touch any existing error mode flags by merging the existing error mode. |
| # See http://blogs.msdn.com/oldnewthing/archive/2004/07/27/198410.aspx. |
| error_mode = SEM_NOGPFAULTERRORBOX |
| prev_error_mode = Win32SetErrorMode(error_mode) |
| Win32SetErrorMode(error_mode | prev_error_mode) |
| process = subprocess.Popen( |
| shell = utils.IsWindows(), |
| args = popen_args, |
| **rest |
| ) |
| if utils.IsWindows() and context.suppress_dialogs and prev_error_mode != SEM_INVALID_VALUE: |
| Win32SetErrorMode(prev_error_mode) |
| # Compute the end time - if the process crosses this limit we |
| # consider it timed out. |
| if timeout is None: end_time = None |
| else: end_time = time.time() + timeout |
| timed_out = False |
| # Repeatedly check the exit code from the process in a |
| # loop and keep track of whether or not it times out. |
| exit_code = None |
| sleep_time = INITIAL_SLEEP_TIME |
| while exit_code is None: |
| if (not end_time is None) and (time.time() >= end_time): |
| # Kill the process and wait for it to exit. |
| KillProcessWithID(process.pid) |
| exit_code = process.wait() |
| timed_out = True |
| else: |
| exit_code = process.poll() |
| time.sleep(sleep_time) |
| sleep_time = sleep_time * SLEEP_TIME_FACTOR |
| if sleep_time > MAX_SLEEP_TIME: |
| sleep_time = MAX_SLEEP_TIME |
| return (process, exit_code, timed_out) |
| |
| |
| def PrintError(str): |
| sys.stderr.write(str) |
| sys.stderr.write('\n') |
| |
| |
| def CheckedUnlink(name): |
| # On Windows, when run with -jN in parallel processes, |
| # OS often fails to unlink the temp file. Not sure why. |
| # Need to retry. |
| # Idea from https://bugs.webkit.org/attachment.cgi?id=75982&action=prettypatch |
| retry_count = 0 |
| while retry_count < 30: |
| try: |
| os.unlink(name) |
| return |
| except OSError, e: |
| retry_count += 1 |
| time.sleep(retry_count * 0.1) |
| PrintError("os.unlink() " + str(e)) |
| |
| def Execute(args, context, timeout=None): |
| (fd_out, outname) = tempfile.mkstemp() |
| (fd_err, errname) = tempfile.mkstemp() |
| (process, exit_code, timed_out) = RunProcess( |
| context, |
| timeout, |
| args = args, |
| stdout = fd_out, |
| stderr = fd_err, |
| ) |
| os.close(fd_out) |
| os.close(fd_err) |
| output = file(outname).read() |
| errors = file(errname).read() |
| CheckedUnlink(outname) |
| CheckedUnlink(errname) |
| return CommandOutput(exit_code, timed_out, output, errors) |
| |
| |
| def ExecuteNoCapture(args, context, timeout=None): |
| (process, exit_code, timed_out) = RunProcess( |
| context, |
| timeout, |
| args = args, |
| ) |
| return CommandOutput(exit_code, False, "", "") |
| |
| |
| def CarCdr(path): |
| if len(path) == 0: |
| return (None, [ ]) |
| else: |
| return (path[0], path[1:]) |
| |
| |
| # Use this to run several variants of the tests, e.g.: |
| # VARIANT_FLAGS = [[], ['--always_compact', '--noflush_code']] |
| VARIANT_FLAGS = [[], |
| ['--stress-opt', '--always-opt'], |
| ['--nocrankshaft']] |
| |
| |
| class TestConfiguration(object): |
| |
| def __init__(self, context, root): |
| self.context = context |
| self.root = root |
| |
| def Contains(self, path, file): |
| if len(path) > len(file): |
| return False |
| for i in xrange(len(path)): |
| if not path[i].match(file[i]): |
| return False |
| return True |
| |
| def GetTestStatus(self, sections, defs): |
| pass |
| |
| def VariantFlags(self): |
| return VARIANT_FLAGS |
| |
| |
| |
| |
| class TestSuite(object): |
| |
| def __init__(self, name): |
| self.name = name |
| |
| def GetName(self): |
| return self.name |
| |
| |
| class TestRepository(TestSuite): |
| |
| def __init__(self, path): |
| normalized_path = abspath(path) |
| super(TestRepository, self).__init__(basename(normalized_path)) |
| self.path = normalized_path |
| self.is_loaded = False |
| self.config = None |
| |
| def GetConfiguration(self, context): |
| if self.is_loaded: |
| return self.config |
| self.is_loaded = True |
| file = None |
| try: |
| (file, pathname, description) = imp.find_module('testcfg', [ self.path ]) |
| module = imp.load_module('testcfg', file, pathname, description) |
| self.config = module.GetConfiguration(context, self.path) |
| finally: |
| if file: |
| file.close() |
| return self.config |
| |
| def GetBuildRequirements(self, path, context): |
| return self.GetConfiguration(context).GetBuildRequirements() |
| |
| def DownloadData(self, context): |
| config = self.GetConfiguration(context) |
| if 'DownloadData' in dir(config): |
| config.DownloadData() |
| |
| def AddTestsToList(self, result, current_path, path, context, mode): |
| config = self.GetConfiguration(context) |
| for v in config.VariantFlags(): |
| tests = config.ListTests(current_path, path, mode, v) |
| for t in tests: t.variant_flags = v |
| result += tests |
| |
| def GetTestStatus(self, context, sections, defs): |
| self.GetConfiguration(context).GetTestStatus(sections, defs) |
| |
| |
| class LiteralTestSuite(TestSuite): |
| |
| def __init__(self, tests): |
| super(LiteralTestSuite, self).__init__('root') |
| self.tests = tests |
| |
| def GetBuildRequirements(self, path, context): |
| (name, rest) = CarCdr(path) |
| result = [ ] |
| for test in self.tests: |
| if not name or name.match(test.GetName()): |
| result += test.GetBuildRequirements(rest, context) |
| return result |
| |
| def DownloadData(self, path, context): |
| (name, rest) = CarCdr(path) |
| for test in self.tests: |
| if not name or name.match(test.GetName()): |
| test.DownloadData(context) |
| |
| def ListTests(self, current_path, path, context, mode, variant_flags): |
| (name, rest) = CarCdr(path) |
| result = [ ] |
| for test in self.tests: |
| test_name = test.GetName() |
| if not name or name.match(test_name): |
| full_path = current_path + [test_name] |
| test.AddTestsToList(result, full_path, path, context, mode) |
| return result |
| |
| def GetTestStatus(self, context, sections, defs): |
| for test in self.tests: |
| test.GetTestStatus(context, sections, defs) |
| |
| |
| SUFFIX = { |
| 'debug' : '_g', |
| 'release' : '' } |
| FLAGS = { |
| 'debug' : ['--nobreak-on-abort', '--nodead-code-elimination', |
| '--nofold-constants', '--enable-slow-asserts', |
| '--debug-code', '--verify-heap'], |
| 'release' : ['--nobreak-on-abort', '--nodead-code-elimination', |
| '--nofold-constants']} |
| TIMEOUT_SCALEFACTOR = { |
| 'debug' : 4, |
| 'release' : 1 } |
| |
| |
| class Context(object): |
| |
| def __init__(self, workspace, buildspace, verbose, vm, timeout, processor, suppress_dialogs, store_unexpected_output): |
| self.workspace = workspace |
| self.buildspace = buildspace |
| self.verbose = verbose |
| self.vm_root = vm |
| self.timeout = timeout |
| self.processor = processor |
| self.suppress_dialogs = suppress_dialogs |
| self.store_unexpected_output = store_unexpected_output |
| |
| def GetVm(self, mode): |
| name = self.vm_root + SUFFIX[mode] |
| if utils.IsWindows() and not name.endswith('.exe'): |
| name = name + '.exe' |
| return name |
| |
| def GetVmCommand(self, testcase, mode): |
| return [self.GetVm(mode)] + self.GetVmFlags(testcase, mode) |
| |
| def GetVmFlags(self, testcase, mode): |
| flags = testcase.GetCustomFlags(mode) |
| if flags is None: |
| flags = FLAGS[mode] |
| return testcase.variant_flags + flags |
| |
| def GetTimeout(self, testcase, mode): |
| result = self.timeout * TIMEOUT_SCALEFACTOR[mode] |
| if '--stress-opt' in self.GetVmFlags(testcase, mode): |
| return result * 4 |
| else: |
| return result |
| |
| def RunTestCases(cases_to_run, progress, tasks): |
| progress = PROGRESS_INDICATORS[progress](cases_to_run) |
| result = 0 |
| try: |
| result = progress.Run(tasks) |
| except Exception, e: |
| print "\n", e |
| return result |
| |
| |
| def BuildRequirements(context, requirements, mode, scons_flags): |
| command_line = (['scons', '-Y', context.workspace, 'mode=' + ",".join(mode)] |
| + requirements |
| + scons_flags) |
| output = ExecuteNoCapture(command_line, context) |
| return output.exit_code == 0 |
| |
| |
| # ------------------------------------------- |
| # --- T e s t C o n f i g u r a t i o n --- |
| # ------------------------------------------- |
| |
| |
| SKIP = 'skip' |
| FAIL = 'fail' |
| PASS = 'pass' |
| OKAY = 'okay' |
| TIMEOUT = 'timeout' |
| CRASH = 'crash' |
| SLOW = 'slow' |
| |
| |
| class Expression(object): |
| pass |
| |
| |
| class Constant(Expression): |
| |
| def __init__(self, value): |
| self.value = value |
| |
| def Evaluate(self, env, defs): |
| return self.value |
| |
| |
| class Variable(Expression): |
| |
| def __init__(self, name): |
| self.name = name |
| |
| def GetOutcomes(self, env, defs): |
| if self.name in env: return ListSet([env[self.name]]) |
| else: return Nothing() |
| |
| def Evaluate(self, env, defs): |
| return env[self.name] |
| |
| |
| class Outcome(Expression): |
| |
| def __init__(self, name): |
| self.name = name |
| |
| def GetOutcomes(self, env, defs): |
| if self.name in defs: |
| return defs[self.name].GetOutcomes(env, defs) |
| else: |
| return ListSet([self.name]) |
| |
| |
| class Set(object): |
| pass |
| |
| |
| class ListSet(Set): |
| |
| def __init__(self, elms): |
| self.elms = elms |
| |
| def __str__(self): |
| return "ListSet%s" % str(self.elms) |
| |
| def Intersect(self, that): |
| if not isinstance(that, ListSet): |
| return that.Intersect(self) |
| return ListSet([ x for x in self.elms if x in that.elms ]) |
| |
| def Union(self, that): |
| if not isinstance(that, ListSet): |
| return that.Union(self) |
| return ListSet(self.elms + [ x for x in that.elms if x not in self.elms ]) |
| |
| def IsEmpty(self): |
| return len(self.elms) == 0 |
| |
| |
| class Everything(Set): |
| |
| def Intersect(self, that): |
| return that |
| |
| def Union(self, that): |
| return self |
| |
| def IsEmpty(self): |
| return False |
| |
| |
| class Nothing(Set): |
| |
| def Intersect(self, that): |
| return self |
| |
| def Union(self, that): |
| return that |
| |
| def IsEmpty(self): |
| return True |
| |
| |
| class Operation(Expression): |
| |
| def __init__(self, left, op, right): |
| self.left = left |
| self.op = op |
| self.right = right |
| |
| def Evaluate(self, env, defs): |
| if self.op == '||' or self.op == ',': |
| return self.left.Evaluate(env, defs) or self.right.Evaluate(env, defs) |
| elif self.op == 'if': |
| return False |
| elif self.op == '==': |
| inter = self.left.GetOutcomes(env, defs).Intersect(self.right.GetOutcomes(env, defs)) |
| return not inter.IsEmpty() |
| elif self.op == '!=': |
| inter = self.left.GetOutcomes(env, defs).Intersect(self.right.GetOutcomes(env, defs)) |
| return inter.IsEmpty() |
| else: |
| assert self.op == '&&' |
| return self.left.Evaluate(env, defs) and self.right.Evaluate(env, defs) |
| |
| def GetOutcomes(self, env, defs): |
| if self.op == '||' or self.op == ',': |
| return self.left.GetOutcomes(env, defs).Union(self.right.GetOutcomes(env, defs)) |
| elif self.op == 'if': |
| if self.right.Evaluate(env, defs): return self.left.GetOutcomes(env, defs) |
| else: return Nothing() |
| else: |
| assert self.op == '&&' |
| return self.left.GetOutcomes(env, defs).Intersect(self.right.GetOutcomes(env, defs)) |
| |
| |
| def IsAlpha(str): |
| for char in str: |
| if not (char.isalpha() or char.isdigit() or char == '_'): |
| return False |
| return True |
| |
| |
| class Tokenizer(object): |
| """A simple string tokenizer that chops expressions into variables, |
| parens and operators""" |
| |
| def __init__(self, expr): |
| self.index = 0 |
| self.expr = expr |
| self.length = len(expr) |
| self.tokens = None |
| |
| def Current(self, length = 1): |
| if not self.HasMore(length): return "" |
| return self.expr[self.index:self.index+length] |
| |
| def HasMore(self, length = 1): |
| return self.index < self.length + (length - 1) |
| |
| def Advance(self, count = 1): |
| self.index = self.index + count |
| |
| def AddToken(self, token): |
| self.tokens.append(token) |
| |
| def SkipSpaces(self): |
| while self.HasMore() and self.Current().isspace(): |
| self.Advance() |
| |
| def Tokenize(self): |
| self.tokens = [ ] |
| while self.HasMore(): |
| self.SkipSpaces() |
| if not self.HasMore(): |
| return None |
| if self.Current() == '(': |
| self.AddToken('(') |
| self.Advance() |
| elif self.Current() == ')': |
| self.AddToken(')') |
| self.Advance() |
| elif self.Current() == '$': |
| self.AddToken('$') |
| self.Advance() |
| elif self.Current() == ',': |
| self.AddToken(',') |
| self.Advance() |
| elif IsAlpha(self.Current()): |
| buf = "" |
| while self.HasMore() and IsAlpha(self.Current()): |
| buf += self.Current() |
| self.Advance() |
| self.AddToken(buf) |
| elif self.Current(2) == '&&': |
| self.AddToken('&&') |
| self.Advance(2) |
| elif self.Current(2) == '||': |
| self.AddToken('||') |
| self.Advance(2) |
| elif self.Current(2) == '==': |
| self.AddToken('==') |
| self.Advance(2) |
| elif self.Current(2) == '!=': |
| self.AddToken('!=') |
| self.Advance(2) |
| else: |
| return None |
| return self.tokens |
| |
| |
| class Scanner(object): |
| """A simple scanner that can serve out tokens from a given list""" |
| |
| def __init__(self, tokens): |
| self.tokens = tokens |
| self.length = len(tokens) |
| self.index = 0 |
| |
| def HasMore(self): |
| return self.index < self.length |
| |
| def Current(self): |
| return self.tokens[self.index] |
| |
| def Advance(self): |
| self.index = self.index + 1 |
| |
| |
| def ParseAtomicExpression(scan): |
| if scan.Current() == "true": |
| scan.Advance() |
| return Constant(True) |
| elif scan.Current() == "false": |
| scan.Advance() |
| return Constant(False) |
| elif IsAlpha(scan.Current()): |
| name = scan.Current() |
| scan.Advance() |
| return Outcome(name.lower()) |
| elif scan.Current() == '$': |
| scan.Advance() |
| if not IsAlpha(scan.Current()): |
| return None |
| name = scan.Current() |
| scan.Advance() |
| return Variable(name.lower()) |
| elif scan.Current() == '(': |
| scan.Advance() |
| result = ParseLogicalExpression(scan) |
| if (not result) or (scan.Current() != ')'): |
| return None |
| scan.Advance() |
| return result |
| else: |
| return None |
| |
| |
| BINARIES = ['==', '!='] |
| def ParseOperatorExpression(scan): |
| left = ParseAtomicExpression(scan) |
| if not left: return None |
| while scan.HasMore() and (scan.Current() in BINARIES): |
| op = scan.Current() |
| scan.Advance() |
| right = ParseOperatorExpression(scan) |
| if not right: |
| return None |
| left = Operation(left, op, right) |
| return left |
| |
| |
| def ParseConditionalExpression(scan): |
| left = ParseOperatorExpression(scan) |
| if not left: return None |
| while scan.HasMore() and (scan.Current() == 'if'): |
| scan.Advance() |
| right = ParseOperatorExpression(scan) |
| if not right: |
| return None |
| left = Operation(left, 'if', right) |
| return left |
| |
| |
| LOGICALS = ["&&", "||", ","] |
| def ParseLogicalExpression(scan): |
| left = ParseConditionalExpression(scan) |
| if not left: return None |
| while scan.HasMore() and (scan.Current() in LOGICALS): |
| op = scan.Current() |
| scan.Advance() |
| right = ParseConditionalExpression(scan) |
| if not right: |
| return None |
| left = Operation(left, op, right) |
| return left |
| |
| |
| def ParseCondition(expr): |
| """Parses a logical expression into an Expression object""" |
| tokens = Tokenizer(expr).Tokenize() |
| if not tokens: |
| print "Malformed expression: '%s'" % expr |
| return None |
| scan = Scanner(tokens) |
| ast = ParseLogicalExpression(scan) |
| if not ast: |
| print "Malformed expression: '%s'" % expr |
| return None |
| if scan.HasMore(): |
| print "Malformed expression: '%s'" % expr |
| return None |
| return ast |
| |
| |
| class ClassifiedTest(object): |
| |
| def __init__(self, case, outcomes): |
| self.case = case |
| self.outcomes = outcomes |
| |
| def TestsIsolates(self): |
| return self.case.TestsIsolates() |
| |
| |
| class Configuration(object): |
| """The parsed contents of a configuration file""" |
| |
| def __init__(self, sections, defs): |
| self.sections = sections |
| self.defs = defs |
| |
| def ClassifyTests(self, cases, env): |
| sections = [s for s in self.sections if s.condition.Evaluate(env, self.defs)] |
| all_rules = reduce(list.__add__, [s.rules for s in sections], []) |
| unused_rules = set(all_rules) |
| result = [ ] |
| all_outcomes = set([]) |
| for case in cases: |
| matches = [ r for r in all_rules if r.Contains(case.path) ] |
| outcomes = set([]) |
| for rule in matches: |
| outcomes = outcomes.union(rule.GetOutcomes(env, self.defs)) |
| unused_rules.discard(rule) |
| if not outcomes: |
| outcomes = [PASS] |
| case.outcomes = outcomes |
| all_outcomes = all_outcomes.union(outcomes) |
| result.append(ClassifiedTest(case, outcomes)) |
| return (result, list(unused_rules), all_outcomes) |
| |
| |
| class Section(object): |
| """A section of the configuration file. Sections are enabled or |
| disabled prior to running the tests, based on their conditions""" |
| |
| def __init__(self, condition): |
| self.condition = condition |
| self.rules = [ ] |
| |
| def AddRule(self, rule): |
| self.rules.append(rule) |
| |
| |
| class Rule(object): |
| """A single rule that specifies the expected outcome for a single |
| test.""" |
| |
| def __init__(self, raw_path, path, value): |
| self.raw_path = raw_path |
| self.path = path |
| self.value = value |
| |
| def GetOutcomes(self, env, defs): |
| set = self.value.GetOutcomes(env, defs) |
| assert isinstance(set, ListSet) |
| return set.elms |
| |
| def Contains(self, path): |
| if len(self.path) > len(path): |
| return False |
| for i in xrange(len(self.path)): |
| if not self.path[i].match(path[i]): |
| return False |
| return True |
| |
| |
| HEADER_PATTERN = re.compile(r'\[([^]]+)\]') |
| RULE_PATTERN = re.compile(r'\s*([^: ]*)\s*:(.*)') |
| DEF_PATTERN = re.compile(r'^def\s*(\w+)\s*=(.*)$') |
| PREFIX_PATTERN = re.compile(r'^\s*prefix\s+([\w\_\.\-\/]+)$') |
| |
| |
| def ReadConfigurationInto(path, sections, defs): |
| current_section = Section(Constant(True)) |
| sections.append(current_section) |
| prefix = [] |
| for line in utils.ReadLinesFrom(path): |
| header_match = HEADER_PATTERN.match(line) |
| if header_match: |
| condition_str = header_match.group(1).strip() |
| condition = ParseCondition(condition_str) |
| new_section = Section(condition) |
| sections.append(new_section) |
| current_section = new_section |
| continue |
| rule_match = RULE_PATTERN.match(line) |
| if rule_match: |
| path = prefix + SplitPath(rule_match.group(1).strip()) |
| value_str = rule_match.group(2).strip() |
| value = ParseCondition(value_str) |
| if not value: |
| return False |
| current_section.AddRule(Rule(rule_match.group(1), path, value)) |
| continue |
| def_match = DEF_PATTERN.match(line) |
| if def_match: |
| name = def_match.group(1).lower() |
| value = ParseCondition(def_match.group(2).strip()) |
| if not value: |
| return False |
| defs[name] = value |
| continue |
| prefix_match = PREFIX_PATTERN.match(line) |
| if prefix_match: |
| prefix = SplitPath(prefix_match.group(1).strip()) |
| continue |
| print "Malformed line: '%s'." % line |
| return False |
| return True |
| |
| |
| # --------------- |
| # --- M a i n --- |
| # --------------- |
| |
| |
| ARCH_GUESS = utils.GuessArchitecture() |
| TIMEOUT_DEFAULT = 60; |
| |
| |
| def BuildOptions(): |
| result = optparse.OptionParser() |
| result.add_option("-m", "--mode", help="The test modes in which to run (comma-separated)", |
| default='release') |
| result.add_option("-v", "--verbose", help="Verbose output", |
| default=False, action="store_true") |
| result.add_option("-S", dest="scons_flags", help="Flag to pass through to scons", |
| default=[], action="append") |
| result.add_option("-p", "--progress", |
| help="The style of progress indicator (verbose, dots, color, mono)", |
| choices=PROGRESS_INDICATORS.keys(), default="mono") |
| result.add_option("--no-build", help="Don't build requirements", |
| default=False, action="store_true") |
| result.add_option("--build-only", help="Only build requirements, don't run the tests", |
| default=False, action="store_true") |
| result.add_option("--build-system", help="Build system in use (scons or gyp)", |
| default='scons') |
| result.add_option("--report", help="Print a summary of the tests to be run", |
| default=False, action="store_true") |
| result.add_option("--download-data", help="Download missing test suite data", |
| default=False, action="store_true") |
| result.add_option("-s", "--suite", help="A test suite", |
| default=[], action="append") |
| result.add_option("-t", "--timeout", help="Timeout in seconds", |
| default=-1, type="int") |
| result.add_option("--arch", help='The architecture to run tests for', |
| default='none') |
| result.add_option("--snapshot", help="Run the tests with snapshot turned on", |
| default=False, action="store_true") |
| result.add_option("--simulator", help="Run tests with architecture simulator", |
| default='none') |
| result.add_option("--special-command", default=None) |
| result.add_option("--valgrind", help="Run tests through valgrind", |
| default=False, action="store_true") |
| result.add_option("--cat", help="Print the source of the tests", |
| default=False, action="store_true") |
| result.add_option("--warn-unused", help="Report unused rules", |
| default=False, action="store_true") |
| result.add_option("-j", help="The number of parallel tasks to run", |
| default=1, type="int") |
| result.add_option("--time", help="Print timing information after running", |
| default=False, action="store_true") |
| result.add_option("--suppress-dialogs", help="Suppress Windows dialogs for crashing tests", |
| dest="suppress_dialogs", default=True, action="store_true") |
| result.add_option("--no-suppress-dialogs", help="Display Windows dialogs for crashing tests", |
| dest="suppress_dialogs", action="store_false") |
| result.add_option("--mips-arch-variant", help="mips architecture variant: mips32r1/mips32r2", default="mips32r2"); |
| result.add_option("--shell", help="Path to V8 shell", default="d8") |
| result.add_option("--isolates", help="Whether to test isolates", default=False, action="store_true") |
| result.add_option("--store-unexpected-output", |
| help="Store the temporary JS files from tests that fails", |
| dest="store_unexpected_output", default=True, action="store_true") |
| result.add_option("--no-store-unexpected-output", |
| help="Deletes the temporary JS files from tests that fails", |
| dest="store_unexpected_output", action="store_false") |
| result.add_option("--stress-only", |
| help="Only run tests with --always-opt --stress-opt", |
| default=False, action="store_true") |
| result.add_option("--nostress", |
| help="Don't run crankshaft --always-opt --stress-op test", |
| default=False, action="store_true") |
| result.add_option("--shard-count", |
| help="Split testsuites into this number of shards", |
| default=1, type="int") |
| result.add_option("--shard-run", |
| help="Run this shard from the split up tests.", |
| default=1, type="int") |
| result.add_option("--noprof", help="Disable profiling support", |
| default=False) |
| return result |
| |
| |
| def ProcessOptions(options): |
| global VERBOSE |
| VERBOSE = options.verbose |
| options.mode = options.mode.split(',') |
| for mode in options.mode: |
| if not mode in ['debug', 'release']: |
| print "Unknown mode %s" % mode |
| return False |
| if options.simulator != 'none': |
| # Simulator argument was set. Make sure arch and simulator agree. |
| if options.simulator != options.arch: |
| if options.arch == 'none': |
| options.arch = options.simulator |
| else: |
| print "Architecture %s does not match sim %s" %(options.arch, options.simulator) |
| return False |
| # Ensure that the simulator argument is handed down to scons. |
| options.scons_flags.append("simulator=" + options.simulator) |
| else: |
| # If options.arch is not set by the command line and no simulator setting |
| # was found, set the arch to the guess. |
| if options.arch == 'none': |
| options.arch = ARCH_GUESS |
| options.scons_flags.append("arch=" + options.arch) |
| # Simulators are slow, therefore allow a longer default timeout. |
| if options.timeout == -1: |
| if options.arch in ['android', 'arm', 'mipsel']: |
| options.timeout = 2 * TIMEOUT_DEFAULT; |
| else: |
| options.timeout = TIMEOUT_DEFAULT; |
| if options.snapshot: |
| options.scons_flags.append("snapshot=on") |
| global VARIANT_FLAGS |
| if options.mips_arch_variant: |
| options.scons_flags.append("mips_arch_variant=" + options.mips_arch_variant) |
| |
| if options.stress_only: |
| VARIANT_FLAGS = [['--stress-opt', '--always-opt']] |
| if options.nostress: |
| VARIANT_FLAGS = [[],['--nocrankshaft']] |
| if options.shell.endswith("d8"): |
| if options.special_command: |
| options.special_command += " --test" |
| else: |
| options.special_command = "@ --test" |
| if options.noprof: |
| options.scons_flags.append("prof=off") |
| options.scons_flags.append("profilingsupport=off") |
| if options.build_system == 'gyp': |
| if options.build_only: |
| print "--build-only not supported for gyp, please build manually." |
| options.build_only = False |
| return True |
| |
| |
| def DoSkip(case): |
| return (SKIP in case.outcomes) or (SLOW in case.outcomes) |
| |
| |
| REPORT_TEMPLATE = """\ |
| Total: %(total)i tests |
| * %(skipped)4d tests will be skipped |
| * %(timeout)4d tests are expected to timeout sometimes |
| * %(nocrash)4d tests are expected to be flaky but not crash |
| * %(pass)4d tests are expected to pass |
| * %(fail_ok)4d tests are expected to fail that we won't fix |
| * %(fail)4d tests are expected to fail that we should fix\ |
| """ |
| |
| def PrintReport(cases): |
| def IsFlaky(o): |
| return (PASS in o) and (FAIL in o) and (not CRASH in o) and (not OKAY in o) |
| def IsFailOk(o): |
| return (len(o) == 2) and (FAIL in o) and (OKAY in o) |
| unskipped = [c for c in cases if not DoSkip(c)] |
| print REPORT_TEMPLATE % { |
| 'total': len(cases), |
| 'skipped': len(cases) - len(unskipped), |
| 'timeout': len([t for t in unskipped if TIMEOUT in t.outcomes]), |
| 'nocrash': len([t for t in unskipped if IsFlaky(t.outcomes)]), |
| 'pass': len([t for t in unskipped if list(t.outcomes) == [PASS]]), |
| 'fail_ok': len([t for t in unskipped if IsFailOk(t.outcomes)]), |
| 'fail': len([t for t in unskipped if list(t.outcomes) == [FAIL]]) |
| } |
| |
| |
| class Pattern(object): |
| |
| def __init__(self, pattern): |
| self.pattern = pattern |
| self.compiled = None |
| |
| def match(self, str): |
| if not self.compiled: |
| pattern = "^" + self.pattern.replace('*', '.*') + "$" |
| self.compiled = re.compile(pattern) |
| return self.compiled.match(str) |
| |
| def __str__(self): |
| return self.pattern |
| |
| |
| def SplitPath(s): |
| stripped = [ c.strip() for c in s.split('/') ] |
| return [ Pattern(s) for s in stripped if len(s) > 0 ] |
| |
| |
| def GetSpecialCommandProcessor(value): |
| if (not value) or (value.find('@') == -1): |
| def ExpandCommand(args): |
| return args |
| return ExpandCommand |
| else: |
| pos = value.find('@') |
| import urllib |
| import shlex |
| prefix = shlex.split(urllib.unquote(value[:pos])) |
| suffix = shlex.split(urllib.unquote(value[pos+1:])) |
| def ExpandCommand(args): |
| return prefix + args + suffix |
| return ExpandCommand |
| |
| |
| BUILT_IN_TESTS = ['mjsunit', 'cctest', 'message', 'preparser'] |
| |
| |
| def GetSuites(test_root): |
| def IsSuite(path): |
| return isdir(path) and exists(join(path, 'testcfg.py')) |
| return [ f for f in os.listdir(test_root) if IsSuite(join(test_root, f)) ] |
| |
| |
| def FormatTime(d): |
| millis = round(d * 1000) % 1000 |
| return time.strftime("%M:%S.", time.gmtime(d)) + ("%03i" % millis) |
| |
| def ShardTests(tests, options): |
| if options.shard_count < 2: |
| return tests |
| if options.shard_run < 1 or options.shard_run > options.shard_count: |
| print "shard-run not a valid number, should be in [1:shard-count]" |
| print "defaulting back to running all tests" |
| return tests |
| count = 0 |
| shard = [] |
| for test in tests: |
| if count % options.shard_count == options.shard_run - 1: |
| shard.append(test) |
| count += 1 |
| return shard |
| |
| def Main(): |
| parser = BuildOptions() |
| (options, args) = parser.parse_args() |
| if not ProcessOptions(options): |
| parser.print_help() |
| return 1 |
| |
| workspace = abspath(join(dirname(sys.argv[0]), '..')) |
| suites = GetSuites(join(workspace, 'test')) |
| repositories = [TestRepository(join(workspace, 'test', name)) for name in suites] |
| repositories += [TestRepository(a) for a in options.suite] |
| |
| root = LiteralTestSuite(repositories) |
| if len(args) == 0: |
| paths = [SplitPath(t) for t in BUILT_IN_TESTS] |
| else: |
| paths = [ ] |
| for arg in args: |
| path = SplitPath(arg) |
| paths.append(path) |
| |
| # Check for --valgrind option. If enabled, we overwrite the special |
| # command flag with a command that uses the run-valgrind.py script. |
| if options.valgrind: |
| run_valgrind = join(workspace, "tools", "run-valgrind.py") |
| options.special_command = "python -u " + run_valgrind + " @" |
| |
| if options.build_system == 'gyp': |
| SUFFIX['debug'] = '' |
| |
| shell = abspath(options.shell) |
| buildspace = dirname(shell) |
| |
| context = Context(workspace, buildspace, VERBOSE, |
| shell, |
| options.timeout, |
| GetSpecialCommandProcessor(options.special_command), |
| options.suppress_dialogs, |
| options.store_unexpected_output) |
| # First build the required targets |
| if not options.no_build: |
| reqs = [ ] |
| for path in paths: |
| reqs += root.GetBuildRequirements(path, context) |
| reqs = list(set(reqs)) |
| if len(reqs) > 0: |
| if options.j != 1: |
| options.scons_flags += ['-j', str(options.j)] |
| if not BuildRequirements(context, reqs, options.mode, options.scons_flags): |
| return 1 |
| |
| # Just return if we are only building the targets for running the tests. |
| if options.build_only: |
| return 0 |
| |
| # Get status for tests |
| sections = [ ] |
| defs = { } |
| root.GetTestStatus(context, sections, defs) |
| config = Configuration(sections, defs) |
| |
| # Download missing test suite data if requested. |
| if options.download_data: |
| for path in paths: |
| root.DownloadData(path, context) |
| |
| # List the tests |
| all_cases = [ ] |
| all_unused = [ ] |
| unclassified_tests = [ ] |
| globally_unused_rules = None |
| for path in paths: |
| for mode in options.mode: |
| env = { |
| 'mode': mode, |
| 'system': utils.GuessOS(), |
| 'arch': options.arch, |
| 'simulator': options.simulator, |
| 'isolates': options.isolates |
| } |
| test_list = root.ListTests([], path, context, mode, []) |
| unclassified_tests += test_list |
| (cases, unused_rules, all_outcomes) = config.ClassifyTests(test_list, env) |
| if globally_unused_rules is None: |
| globally_unused_rules = set(unused_rules) |
| else: |
| globally_unused_rules = globally_unused_rules.intersection(unused_rules) |
| all_cases += ShardTests(cases, options) |
| all_unused.append(unused_rules) |
| |
| if options.cat: |
| visited = set() |
| for test in unclassified_tests: |
| key = tuple(test.path) |
| if key in visited: |
| continue |
| visited.add(key) |
| print "--- begin source: %s ---" % test.GetLabel() |
| source = test.GetSource().strip() |
| print source |
| print "--- end source: %s ---" % test.GetLabel() |
| return 0 |
| |
| if options.warn_unused: |
| for rule in globally_unused_rules: |
| print "Rule for '%s' was not used." % '/'.join([str(s) for s in rule.path]) |
| |
| if not options.isolates: |
| all_cases = [c for c in all_cases if not c.TestsIsolates()] |
| |
| if options.report: |
| PrintReport(all_cases) |
| |
| result = None |
| cases_to_run = [ c for c in all_cases if not DoSkip(c) ] |
| if len(cases_to_run) == 0: |
| print "No tests to run." |
| return 0 |
| else: |
| try: |
| start = time.time() |
| if RunTestCases(cases_to_run, options.progress, options.j): |
| result = 0 |
| else: |
| result = 1 |
| duration = time.time() - start |
| except KeyboardInterrupt: |
| print "Interrupted" |
| return 1 |
| |
| if options.time: |
| # Write the times to stderr to make it easy to separate from the |
| # test output. |
| print |
| sys.stderr.write("--- Total time: %s ---\n" % FormatTime(duration)) |
| timed_tests = [ t.case for t in cases_to_run if not t.case.duration is None ] |
| timed_tests.sort(lambda a, b: a.CompareTime(b)) |
| index = 1 |
| for entry in timed_tests[:20]: |
| t = FormatTime(entry.duration) |
| sys.stderr.write("%4i (%s) %s\n" % (index, t, entry.GetLabel())) |
| index += 1 |
| |
| return result |
| |
| |
| if __name__ == '__main__': |
| sys.exit(Main()) |