diff options
Diffstat (limited to 'V8Binding/v8/tools/test.py')
| -rwxr-xr-x | V8Binding/v8/tools/test.py | 1355 |
1 files changed, 0 insertions, 1355 deletions
diff --git a/V8Binding/v8/tools/test.py b/V8Binding/v8/tools/test.py deleted file mode 100755 index 3a60c59..0000000 --- a/V8Binding/v8/tools/test.py +++ /dev/null @@ -1,1355 +0,0 @@ -#!/usr/bin/env python -# -# Copyright 2008 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 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. We may need to escape more characters for this - # to work properly. - parts.append('"%s"' % part) - 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', - 'clear': lambda last_line_length: ("\r" + (" " * last_line_length) + "\r"), - 'max_length': 78 - } - 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 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 - - -class TestCase(object): - - def __init__(self, context, path): - self.path = path - self.context = context - self.failed = None - self.duration = None - - def IsNegative(self): - return False - - def CompareTime(self, other): - return cmp(other.duration, self.duration) - - def DidFail(self, output): - if self.failed is None: - self.failed = self.IsFailureOutput(output) - return self.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.timeout) - self.Cleanup() - return TestOutput(self, full_command, output) - - def Run(self): - return self.RunCommand(self.GetCommand()) - - def Cleanup(self): - return - - -class TestOutput(object): - - def __init__(self, test, command, output): - self.test = test - self.command = command - self.output = 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 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): - try: - os.unlink(name) - except OSError, e: - 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:]) - - -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 - - -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 ListTests(self, current_path, path, context, mode): - return self.GetConfiguration(context).ListTests(current_path, path, mode) - - 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 ListTests(self, current_path, path, context, mode): - (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] - result += test.ListTests(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': ''} - - -class Context(object): - - def __init__(self, workspace, buildspace, verbose, vm, timeout, processor, suppress_dialogs): - self.workspace = workspace - self.buildspace = buildspace - self.verbose = verbose - self.vm_root = vm - self.timeout = timeout - self.processor = processor - self.suppress_dialogs = suppress_dialogs - - def GetVm(self, mode): - name = self.vm_root + SUFFIX[mode] - if utils.IsWindows() and not name.endswith('.exe'): - name = name + '.exe' - return name - -def RunTestCases(all_cases, progress, tasks): - def DoSkip(case): - return SKIP in c.outcomes or SLOW in c.outcomes - cases_to_run = [ c for c in all_cases if not DoSkip(c) ] - progress = PROGRESS_INDICATORS[progress](cases_to_run) - return progress.Run(tasks) - - -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() - - -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() - 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) - 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 - - -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() - - -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("--report", help="Print a summary of the tests to be run", - 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=60, type="int") - result.add_option("--arch", help='The architecture to run tests for', - default='none') - 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("--shell", help="Path to V8 shell", default="shell"); - 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) - return True - - -REPORT_TEMPLATE = """\ -Total: %(total)i tests - * %(skipped)4d tests will be skipped - * %(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 SKIP in c.outcomes] - print REPORT_TEMPLATE % { - 'total': len(cases), - 'skipped': len(cases) - len(unskipped), - '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 - prefix = urllib.unquote(value[:pos]).split() - suffix = urllib.unquote(value[pos+1:]).split() - def ExpandCommand(args): - return prefix + args + suffix - return ExpandCommand - - -BUILT_IN_TESTS = ['mjsunit', 'cctest', 'message'] - - -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 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 + " @" - - shell = abspath(options.shell) - buildspace = dirname(shell) - context = Context(workspace, buildspace, VERBOSE, - shell, - options.timeout, - GetSpecialCommandProcessor(options.special_command), - options.suppress_dialogs) - # 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) - - # List the tests - all_cases = [ ] - all_unused = [ ] - unclassified_tests = [ ] - globally_unused_rules = None - for path in paths: - for mode in options.mode: - if not exists(context.GetVm(mode)): - print "Can't find shell executable: '%s'" % context.GetVm(mode) - continue - env = { - 'mode': mode, - 'system': utils.GuessOS(), - 'arch': options.arch, - 'simulator': options.simulator - } - 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 += cases - 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 options.report: - PrintReport(all_cases) - - result = None - if len(all_cases) == 0: - print "No tests to run." - return 0 - else: - try: - start = time.time() - if RunTestCases(all_cases, 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 all_cases 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()) |