[tools] Correctly identify and report test crashes and infra failures
We define a TestFailedError exception and raise it when we can reliably detect that a test has crashed. All other exceptions are treated as infra failures and are captured by the try-catch clause in MainWrapper function. This also fixes all tests in run_perf_test.py, run_tests_test.py and makes sure that both are run on any changes in tools directory. R=machenbach@chromium.org Bug: chromium:899028 Change-Id: I283bc87b31c814be476bebe9fdda414975494183 Reviewed-on: https://chromium-review.googlesource.com/c/1303293 Commit-Queue: Sergiy Byelozyorov <sergiyb@chromium.org> Reviewed-by: Michael Achenbach <machenbach@chromium.org> Cr-Commit-Position: refs/heads/master@{#57134}
This commit is contained in:
Sergiy Byelozyorov
Commit Bot
parent
6d9c30cd94
commit
af120db4af
23
.vpython
23
.vpython
@ -43,3 +43,26 @@ wheel: <
|
||||
platform: "win_amd64"
|
||||
>
|
||||
>
|
||||
|
||||
# Used by:
|
||||
# tools/unittests/run_perf_test.py
|
||||
wheel: <
|
||||
name: "infra/python/wheels/coverage/${vpython_platform}"
|
||||
version: "version:4.3.4"
|
||||
>
|
||||
wheel: <
|
||||
name: "infra/python/wheels/six-py2_py3"
|
||||
version: "version:1.10.0"
|
||||
>
|
||||
wheel: <
|
||||
name: "infra/python/wheels/pbr-py2_py3"
|
||||
version: "version:3.0.0"
|
||||
>
|
||||
wheel: <
|
||||
name: "infra/python/wheels/funcsigs-py2_py3"
|
||||
version: "version:1.0.2"
|
||||
>
|
||||
wheel: <
|
||||
name: "infra/python/wheels/mock-py2_py3"
|
||||
version: "version:2.0.0"
|
||||
>
|
||||
|
||||
@ -73,10 +73,10 @@ def _V8PresubmitChecks(input_api, output_api):
|
||||
import sys
|
||||
sys.path.append(input_api.os_path.join(
|
||||
input_api.PresubmitLocalPath(), 'tools'))
|
||||
from presubmit import CppLintProcessor
|
||||
from presubmit import TorqueFormatProcessor
|
||||
from presubmit import SourceProcessor
|
||||
from presubmit import StatusFilesProcessor
|
||||
from v8_presubmit import CppLintProcessor
|
||||
from v8_presubmit import TorqueFormatProcessor
|
||||
from v8_presubmit import SourceProcessor
|
||||
from v8_presubmit import StatusFilesProcessor
|
||||
|
||||
def FilterFile(affected_file):
|
||||
return input_api.FilterSourceFile(
|
||||
|
||||
@ -138,6 +138,11 @@ def GeometricMean(values):
|
||||
return str(math.exp(sum(map(math.log, values)) / len(values)))
|
||||
|
||||
|
||||
class TestFailedError(Exception):
|
||||
"""Error raised when a test has failed due to a non-infra issue."""
|
||||
pass
|
||||
|
||||
|
||||
class Results(object):
|
||||
"""Place holder for result traces."""
|
||||
def __init__(self, traces=None, errors=None):
|
||||
@ -692,7 +697,7 @@ class DesktopPlatform(Platform):
|
||||
output = cmd.execute()
|
||||
except OSError: # pragma: no cover
|
||||
logging.exception(title % "OSError")
|
||||
return ""
|
||||
raise
|
||||
|
||||
logging.info(title % "Stdout" + "\n%s", output.stdout)
|
||||
if output.stderr: # pragma: no cover
|
||||
@ -700,6 +705,10 @@ class DesktopPlatform(Platform):
|
||||
logging.info(title % "Stderr" + "\n%s", output.stderr)
|
||||
if output.timed_out:
|
||||
logging.warning(">>> Test timed out after %ss.", runnable.timeout)
|
||||
raise TestFailedError()
|
||||
if output.exit_code != 0:
|
||||
logging.warning(">>> Test crashed.")
|
||||
raise TestFailedError()
|
||||
if '--prof' in self.extra_flags:
|
||||
os_prefix = {"linux": "linux", "macos": "mac"}.get(utils.GuessOS())
|
||||
if os_prefix:
|
||||
@ -781,12 +790,13 @@ class AndroidPlatform(Platform): # pragma: no cover
|
||||
logging.info(title % "Stdout" + "\n%s", stdout)
|
||||
except android.CommandFailedException as e:
|
||||
logging.info(title % "Stdout" + "\n%s", e.output)
|
||||
raise
|
||||
logging.warning('>>> Test crashed.')
|
||||
raise TestFailedError()
|
||||
except android.TimeoutException as e:
|
||||
if e.output is not None:
|
||||
logging.info(title % "Stdout" + "\n%s", e.output)
|
||||
logging.warning(">>> Test timed out after %ss.", runnable.timeout)
|
||||
stdout = ""
|
||||
raise TestFailedError()
|
||||
if runnable.process_size:
|
||||
return stdout + "MaxMemory: Unsupported"
|
||||
return stdout
|
||||
@ -1027,6 +1037,8 @@ def Main(args):
|
||||
|
||||
results = Results()
|
||||
results_secondary = Results()
|
||||
# We use list here to allow modification in nested function below.
|
||||
have_failed_tests = [False]
|
||||
with CustomMachineConfiguration(governor = options.cpu_governor,
|
||||
disable_aslr = options.noaslr) as conf:
|
||||
for path in args:
|
||||
@ -1065,7 +1077,10 @@ def Main(args):
|
||||
for i in xrange(0, max(1, total_runs)):
|
||||
# TODO(machenbach): Allow timeout per arch like with run_count per
|
||||
# arch.
|
||||
yield platform.Run(runnable, i)
|
||||
try:
|
||||
yield platform.Run(runnable, i)
|
||||
except TestFailedError:
|
||||
have_failed_tests[0] = True
|
||||
|
||||
# Let runnable iterate over all runs and handle output.
|
||||
result, result_secondary = runnable.Run(
|
||||
@ -1084,7 +1099,7 @@ def Main(args):
|
||||
else: # pragma: no cover
|
||||
print results_secondary
|
||||
|
||||
if results.errors:
|
||||
if results.errors or have_failed_tests[0]:
|
||||
return 1
|
||||
|
||||
return 0
|
||||
|
||||
@ -5,5 +5,6 @@
|
||||
def CheckChangeOnCommit(input_api, output_api):
|
||||
# TODO(machenbach): Run all unittests.
|
||||
tests = input_api.canned_checks.GetUnitTestsInDirectory(
|
||||
input_api, output_api, '.', whitelist=['run_tests_test.py$'])
|
||||
input_api, output_api, '.',
|
||||
whitelist=['run_tests_test.py$', 'run_perf_test.py$'])
|
||||
return input_api.RunTests(tests)
|
||||
|
||||
@ -85,7 +85,7 @@ V8_GENERIC_JSON = {
|
||||
"units": "ms",
|
||||
}
|
||||
|
||||
Output = namedtuple("Output", "stdout, stderr, timed_out")
|
||||
Output = namedtuple("Output", "stdout, stderr, timed_out, exit_code")
|
||||
|
||||
class PerfTest(unittest.TestCase):
|
||||
@classmethod
|
||||
@ -113,6 +113,7 @@ class PerfTest(unittest.TestCase):
|
||||
os.makedirs(TEST_WORKSPACE)
|
||||
|
||||
def tearDown(self):
|
||||
patch.stopall()
|
||||
if path.exists(TEST_WORKSPACE):
|
||||
shutil.rmtree(TEST_WORKSPACE)
|
||||
|
||||
@ -125,7 +126,8 @@ class PerfTest(unittest.TestCase):
|
||||
# Fake output for each test run.
|
||||
test_outputs = [Output(stdout=arg,
|
||||
stderr=None,
|
||||
timed_out=kwargs.get("timed_out", False))
|
||||
timed_out=kwargs.get("timed_out", False),
|
||||
exit_code=kwargs.get("exit_code", 0))
|
||||
for arg in args[1]]
|
||||
def create_cmd(*args, **kwargs):
|
||||
cmd = MagicMock()
|
||||
@ -134,7 +136,9 @@ class PerfTest(unittest.TestCase):
|
||||
cmd.execute = MagicMock(side_effect=execute)
|
||||
return cmd
|
||||
|
||||
command.Command = MagicMock(side_effect=create_cmd)
|
||||
patch.object(
|
||||
run_perf.command, 'PosixCommand',
|
||||
MagicMock(side_effect=create_cmd)).start()
|
||||
|
||||
# Check that d8 is called from the correct cwd for each test run.
|
||||
dirs = [path.join(TEST_WORKSPACE, arg) for arg in args[0]]
|
||||
@ -402,6 +406,18 @@ class PerfTest(unittest.TestCase):
|
||||
self._VerifyErrors(["Found non-numeric in test/Infra/Constant4"])
|
||||
self._VerifyMock(path.join("out", "x64.release", "cc"), "--flag", "")
|
||||
|
||||
def testOneRunCrashed(self):
|
||||
self._WriteTestInput(V8_JSON)
|
||||
self._MockCommand(
|
||||
["."], ["x\nRichards: 1.234\nDeltaBlue: 10657567\ny\n"], exit_code=1)
|
||||
self.assertEquals(1, self._CallMain())
|
||||
self._VerifyResults("test", "score", [
|
||||
{"name": "Richards", "results": [], "stddev": ""},
|
||||
{"name": "DeltaBlue", "results": [], "stddev": ""},
|
||||
])
|
||||
self._VerifyErrors([])
|
||||
self._VerifyMock(path.join("out", "x64.release", "d7"), "--flag", "run.js")
|
||||
|
||||
def testOneRunTimingOut(self):
|
||||
test_input = dict(V8_JSON)
|
||||
test_input["timeout"] = 70
|
||||
@ -412,10 +428,7 @@ class PerfTest(unittest.TestCase):
|
||||
{"name": "Richards", "results": [], "stddev": ""},
|
||||
{"name": "DeltaBlue", "results": [], "stddev": ""},
|
||||
])
|
||||
self._VerifyErrors([
|
||||
"Regexp \"^Richards: (.+)$\" didn't match for test test/Richards.",
|
||||
"Regexp \"^DeltaBlue: (.+)$\" didn't match for test test/DeltaBlue.",
|
||||
])
|
||||
self._VerifyErrors([])
|
||||
self._VerifyMock(
|
||||
path.join("out", "x64.release", "d7"), "--flag", "run.js", timeout=70)
|
||||
|
||||
|
||||
@ -103,8 +103,7 @@ def run_tests(basedir, *args, **kwargs):
|
||||
sys_args.append('--infra-staging')
|
||||
else:
|
||||
sys_args.append('--no-infra-staging')
|
||||
code = standard_runner.StandardTestRunner(
|
||||
basedir=basedir).execute(sys_args)
|
||||
code = standard_runner.StandardTestRunner(basedir=basedir).execute(sys_args)
|
||||
return Result(stdout.getvalue(), stderr.getvalue(), code)
|
||||
|
||||
|
||||
@ -247,7 +246,8 @@ class SystemTest(unittest.TestCase):
|
||||
self.assertIn('Done running sweet/strawberries: FAIL', result.stdout, result)
|
||||
self.assertEqual(1, result.returncode, result)
|
||||
|
||||
def check_cleaned_json_output(self, expected_results_name, actual_json):
|
||||
def check_cleaned_json_output(
|
||||
self, expected_results_name, actual_json, basedir):
|
||||
# Check relevant properties of the json output.
|
||||
with open(actual_json) as f:
|
||||
json_output = json.load(f)[0]
|
||||
@ -260,6 +260,7 @@ class SystemTest(unittest.TestCase):
|
||||
data['duration'] = 1
|
||||
data['command'] = ' '.join(
|
||||
['/usr/bin/python'] + data['command'].split()[1:])
|
||||
data['command'] = data['command'].replace(basedir + '/', '')
|
||||
for data in json_output['slowest_tests']:
|
||||
replace_variable_data(data)
|
||||
for data in json_output['results']:
|
||||
@ -310,7 +311,8 @@ class SystemTest(unittest.TestCase):
|
||||
# After recent changes we report all flags, including the file names.
|
||||
# This is redundant to the command. Needs investigation.
|
||||
self.maxDiff = None
|
||||
self.check_cleaned_json_output('expected_test_results1.json', json_path)
|
||||
self.check_cleaned_json_output(
|
||||
'expected_test_results1.json', json_path, basedir)
|
||||
|
||||
def testFlakeWithRerunAndJSONProc(self):
|
||||
self.testFlakeWithRerunAndJSON(infra_staging=True)
|
||||
@ -342,7 +344,8 @@ class SystemTest(unittest.TestCase):
|
||||
self.assertIn('All tests succeeded', result.stdout, result)
|
||||
self.assertEqual(0, result.returncode, result)
|
||||
self.maxDiff = None
|
||||
self.check_cleaned_json_output('expected_test_results2.json', json_path)
|
||||
self.check_cleaned_json_output(
|
||||
'expected_test_results2.json', json_path, basedir)
|
||||
|
||||
def testAutoDetect(self):
|
||||
"""Fake a build with several auto-detected options.
|
||||
|
||||
678
tools/v8_presubmit.py
Executable file
678
tools/v8_presubmit.py
Executable file
@ -0,0 +1,678 @@
|
||||
#!/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.
|
||||
|
||||
try:
|
||||
import hashlib
|
||||
md5er = hashlib.md5
|
||||
except ImportError, e:
|
||||
import md5
|
||||
md5er = md5.new
|
||||
|
||||
|
||||
import json
|
||||
import optparse
|
||||
import os
|
||||
from os.path import abspath, join, dirname, basename, exists
|
||||
import pickle
|
||||
import re
|
||||
import sys
|
||||
import subprocess
|
||||
import multiprocessing
|
||||
from subprocess import PIPE
|
||||
|
||||
from testrunner.local import statusfile
|
||||
from testrunner.local import testsuite
|
||||
from testrunner.local import utils
|
||||
|
||||
# Special LINT rules diverging from default and reason.
|
||||
# build/header_guard: Our guards have the form "V8_FOO_H_", not "SRC_FOO_H_".
|
||||
# We now run our own header guard check in PRESUBMIT.py.
|
||||
# build/include_what_you_use: Started giving false positives for variables
|
||||
# named "string" and "map" assuming that you needed to include STL headers.
|
||||
|
||||
LINT_RULES = """
|
||||
-build/header_guard
|
||||
-build/include_what_you_use
|
||||
-readability/fn_size
|
||||
-readability/multiline_comment
|
||||
-runtime/references
|
||||
-whitespace/comments
|
||||
""".split()
|
||||
|
||||
LINT_OUTPUT_PATTERN = re.compile(r'^.+[:(]\d+[:)]|^Done processing')
|
||||
FLAGS_LINE = re.compile("//\s*Flags:.*--([A-z0-9-])+_[A-z0-9].*\n")
|
||||
ASSERT_OPTIMIZED_PATTERN = re.compile("assertOptimized")
|
||||
FLAGS_ENABLE_OPT = re.compile("//\s*Flags:.*--opt[^-].*\n")
|
||||
ASSERT_UNOPTIMIZED_PATTERN = re.compile("assertUnoptimized")
|
||||
FLAGS_NO_ALWAYS_OPT = re.compile("//\s*Flags:.*--no-?always-opt.*\n")
|
||||
|
||||
TOOLS_PATH = dirname(abspath(__file__))
|
||||
|
||||
def CppLintWorker(command):
|
||||
try:
|
||||
process = subprocess.Popen(command, stderr=subprocess.PIPE)
|
||||
process.wait()
|
||||
out_lines = ""
|
||||
error_count = -1
|
||||
while True:
|
||||
out_line = process.stderr.readline()
|
||||
if out_line == '' and process.poll() != None:
|
||||
if error_count == -1:
|
||||
print "Failed to process %s" % command.pop()
|
||||
return 1
|
||||
break
|
||||
m = LINT_OUTPUT_PATTERN.match(out_line)
|
||||
if m:
|
||||
out_lines += out_line
|
||||
error_count += 1
|
||||
sys.stdout.write(out_lines)
|
||||
return error_count
|
||||
except KeyboardInterrupt:
|
||||
process.kill()
|
||||
except:
|
||||
print('Error running cpplint.py. Please make sure you have depot_tools' +
|
||||
' in your $PATH. Lint check skipped.')
|
||||
process.kill()
|
||||
|
||||
def TorqueLintWorker(command):
|
||||
try:
|
||||
process = subprocess.Popen(command, stderr=subprocess.PIPE)
|
||||
process.wait()
|
||||
out_lines = ""
|
||||
error_count = 0
|
||||
while True:
|
||||
out_line = process.stderr.readline()
|
||||
if out_line == '' and process.poll() != None:
|
||||
break
|
||||
out_lines += out_line
|
||||
error_count += 1
|
||||
sys.stdout.write(out_lines)
|
||||
if error_count != 0:
|
||||
sys.stdout.write("tip: use 'tools/torque/format-torque.py -i <filename>'\n");
|
||||
return error_count
|
||||
except KeyboardInterrupt:
|
||||
process.kill()
|
||||
except:
|
||||
print('Error running format-torque.py')
|
||||
process.kill()
|
||||
|
||||
class FileContentsCache(object):
|
||||
|
||||
def __init__(self, sums_file_name):
|
||||
self.sums = {}
|
||||
self.sums_file_name = sums_file_name
|
||||
|
||||
def Load(self):
|
||||
try:
|
||||
sums_file = None
|
||||
try:
|
||||
sums_file = open(self.sums_file_name, 'r')
|
||||
self.sums = pickle.load(sums_file)
|
||||
except:
|
||||
# Cannot parse pickle for any reason. Not much we can do about it.
|
||||
pass
|
||||
finally:
|
||||
if sums_file:
|
||||
sums_file.close()
|
||||
|
||||
def Save(self):
|
||||
try:
|
||||
sums_file = open(self.sums_file_name, 'w')
|
||||
pickle.dump(self.sums, sums_file)
|
||||
except:
|
||||
# Failed to write pickle. Try to clean-up behind us.
|
||||
if sums_file:
|
||||
sums_file.close()
|
||||
try:
|
||||
os.unlink(self.sums_file_name)
|
||||
except:
|
||||
pass
|
||||
finally:
|
||||
sums_file.close()
|
||||
|
||||
def FilterUnchangedFiles(self, files):
|
||||
changed_or_new = []
|
||||
for file in files:
|
||||
try:
|
||||
handle = open(file, "r")
|
||||
file_sum = md5er(handle.read()).digest()
|
||||
if not file in self.sums or self.sums[file] != file_sum:
|
||||
changed_or_new.append(file)
|
||||
self.sums[file] = file_sum
|
||||
finally:
|
||||
handle.close()
|
||||
return changed_or_new
|
||||
|
||||
def RemoveFile(self, file):
|
||||
if file in self.sums:
|
||||
self.sums.pop(file)
|
||||
|
||||
|
||||
class SourceFileProcessor(object):
|
||||
"""
|
||||
Utility class that can run through a directory structure, find all relevant
|
||||
files and invoke a custom check on the files.
|
||||
"""
|
||||
|
||||
def RunOnPath(self, path):
|
||||
"""Runs processor on all files under the given path."""
|
||||
|
||||
all_files = []
|
||||
for file in self.GetPathsToSearch():
|
||||
all_files += self.FindFilesIn(join(path, file))
|
||||
return self.ProcessFiles(all_files)
|
||||
|
||||
def RunOnFiles(self, files):
|
||||
"""Runs processor only on affected files."""
|
||||
|
||||
# Helper for getting directory pieces.
|
||||
dirs = lambda f: dirname(f).split(os.sep)
|
||||
|
||||
# Path offsets where to look (to be in sync with RunOnPath).
|
||||
# Normalize '.' to check for it with str.startswith.
|
||||
search_paths = [('' if p == '.' else p) for p in self.GetPathsToSearch()]
|
||||
|
||||
all_files = [
|
||||
f.AbsoluteLocalPath()
|
||||
for f in files
|
||||
if (not self.IgnoreFile(f.LocalPath()) and
|
||||
self.IsRelevant(f.LocalPath()) and
|
||||
all(not self.IgnoreDir(d) for d in dirs(f.LocalPath())) and
|
||||
any(map(f.LocalPath().startswith, search_paths)))
|
||||
]
|
||||
|
||||
return self.ProcessFiles(all_files)
|
||||
|
||||
def IgnoreDir(self, name):
|
||||
return (name.startswith('.') or
|
||||
name in ('buildtools', 'data', 'gmock', 'gtest', 'kraken',
|
||||
'octane', 'sunspider', 'traces-arm64'))
|
||||
|
||||
def IgnoreFile(self, name):
|
||||
return name.startswith('.')
|
||||
|
||||
def FindFilesIn(self, path):
|
||||
result = []
|
||||
for (root, dirs, files) in os.walk(path):
|
||||
for ignored in [x for x in dirs if self.IgnoreDir(x)]:
|
||||
dirs.remove(ignored)
|
||||
for file in files:
|
||||
if not self.IgnoreFile(file) and self.IsRelevant(file):
|
||||
result.append(join(root, file))
|
||||
return result
|
||||
|
||||
|
||||
class CppLintProcessor(SourceFileProcessor):
|
||||
"""
|
||||
Lint files to check that they follow the google code style.
|
||||
"""
|
||||
|
||||
def IsRelevant(self, name):
|
||||
return name.endswith('.cc') or name.endswith('.h')
|
||||
|
||||
def IgnoreDir(self, name):
|
||||
return (super(CppLintProcessor, self).IgnoreDir(name)
|
||||
or (name == 'third_party'))
|
||||
|
||||
IGNORE_LINT = ['export-template.h', 'flag-definitions.h']
|
||||
|
||||
def IgnoreFile(self, name):
|
||||
return (super(CppLintProcessor, self).IgnoreFile(name)
|
||||
or (name in CppLintProcessor.IGNORE_LINT))
|
||||
|
||||
def GetPathsToSearch(self):
|
||||
dirs = ['include', 'samples', 'src']
|
||||
test_dirs = ['cctest', 'common', 'fuzzer', 'inspector', 'unittests']
|
||||
return dirs + [join('test', dir) for dir in test_dirs]
|
||||
|
||||
def GetCpplintScript(self, prio_path):
|
||||
for path in [prio_path] + os.environ["PATH"].split(os.pathsep):
|
||||
path = path.strip('"')
|
||||
cpplint = os.path.join(path, "cpplint.py")
|
||||
if os.path.isfile(cpplint):
|
||||
return cpplint
|
||||
|
||||
return None
|
||||
|
||||
def ProcessFiles(self, files):
|
||||
good_files_cache = FileContentsCache('.cpplint-cache')
|
||||
good_files_cache.Load()
|
||||
files = good_files_cache.FilterUnchangedFiles(files)
|
||||
if len(files) == 0:
|
||||
print 'No changes in C/C++ files detected. Skipping cpplint check.'
|
||||
return True
|
||||
|
||||
filters = ",".join([n for n in LINT_RULES])
|
||||
cpplint = self.GetCpplintScript(TOOLS_PATH)
|
||||
if cpplint is None:
|
||||
print('Could not find cpplint.py. Make sure '
|
||||
'depot_tools is installed and in the path.')
|
||||
sys.exit(1)
|
||||
|
||||
command = [sys.executable, cpplint, '--filter', filters]
|
||||
|
||||
commands = [command + [file] for file in files]
|
||||
count = multiprocessing.cpu_count()
|
||||
pool = multiprocessing.Pool(count)
|
||||
try:
|
||||
results = pool.map_async(CppLintWorker, commands).get(999999)
|
||||
except KeyboardInterrupt:
|
||||
print "\nCaught KeyboardInterrupt, terminating workers."
|
||||
sys.exit(1)
|
||||
|
||||
for i in range(len(files)):
|
||||
if results[i] > 0:
|
||||
good_files_cache.RemoveFile(files[i])
|
||||
|
||||
total_errors = sum(results)
|
||||
print "Total C/C++ files found that require formatting: %d" % total_errors
|
||||
good_files_cache.Save()
|
||||
return total_errors == 0
|
||||
|
||||
class TorqueFormatProcessor(SourceFileProcessor):
|
||||
"""
|
||||
Check .tq files to verify they follow the Torque style guide.
|
||||
"""
|
||||
|
||||
def IsRelevant(self, name):
|
||||
return name.endswith('.tq')
|
||||
|
||||
def GetPathsToSearch(self):
|
||||
dirs = ['third-party', 'src']
|
||||
test_dirs = ['torque']
|
||||
return dirs + [join('test', dir) for dir in test_dirs]
|
||||
|
||||
def GetTorquelintScript(self):
|
||||
torque_tools = os.path.join(TOOLS_PATH, "torque")
|
||||
torque_path = os.path.join(torque_tools, "format-torque.py")
|
||||
|
||||
if os.path.isfile(torque_path):
|
||||
return torque_path
|
||||
|
||||
return None
|
||||
|
||||
def ProcessFiles(self, files):
|
||||
good_files_cache = FileContentsCache('.torquelint-cache')
|
||||
good_files_cache.Load()
|
||||
files = good_files_cache.FilterUnchangedFiles(files)
|
||||
if len(files) == 0:
|
||||
print 'No changes in Torque files detected. Skipping Torque lint check.'
|
||||
return True
|
||||
|
||||
torquelint = self.GetTorquelintScript()
|
||||
if torquelint is None:
|
||||
print('Could not find format-torque.')
|
||||
sys.exit(1)
|
||||
|
||||
command = [sys.executable, torquelint, '-l']
|
||||
|
||||
commands = [command + [file] for file in files]
|
||||
count = multiprocessing.cpu_count()
|
||||
pool = multiprocessing.Pool(count)
|
||||
try:
|
||||
results = pool.map_async(TorqueLintWorker, commands).get()
|
||||
except KeyboardInterrupt:
|
||||
print "\nCaught KeyboardInterrupt, terminating workers."
|
||||
sys.exit(1)
|
||||
|
||||
for i in range(len(files)):
|
||||
if results[i] > 0:
|
||||
good_files_cache.RemoveFile(files[i])
|
||||
|
||||
total_errors = sum(results)
|
||||
print "Total Torque files requiring formatting: %d" % total_errors
|
||||
good_files_cache.Save()
|
||||
return total_errors == 0
|
||||
|
||||
COPYRIGHT_HEADER_PATTERN = re.compile(
|
||||
r'Copyright [\d-]*20[0-1][0-9] the V8 project authors. All rights reserved.')
|
||||
|
||||
class SourceProcessor(SourceFileProcessor):
|
||||
"""
|
||||
Check that all files include a copyright notice and no trailing whitespaces.
|
||||
"""
|
||||
|
||||
RELEVANT_EXTENSIONS = ['.js', '.cc', '.h', '.py', '.c', '.status', '.tq', '.g4']
|
||||
|
||||
def __init__(self):
|
||||
self.runtime_function_call_pattern = self.CreateRuntimeFunctionCallMatcher()
|
||||
|
||||
def CreateRuntimeFunctionCallMatcher(self):
|
||||
runtime_h_path = join(dirname(TOOLS_PATH), 'src/runtime/runtime.h')
|
||||
pattern = re.compile(r'\s+F\(([^,]*),.*\)')
|
||||
runtime_functions = []
|
||||
with open(runtime_h_path) as f:
|
||||
for line in f.readlines():
|
||||
m = pattern.match(line)
|
||||
if m:
|
||||
runtime_functions.append(m.group(1))
|
||||
if len(runtime_functions) < 250:
|
||||
print ("Runtime functions list is suspiciously short. "
|
||||
"Consider updating the presubmit script.")
|
||||
sys.exit(1)
|
||||
str = '(\%\s+(' + '|'.join(runtime_functions) + '))[\s\(]'
|
||||
return re.compile(str)
|
||||
|
||||
# Overwriting the one in the parent class.
|
||||
def FindFilesIn(self, path):
|
||||
if os.path.exists(path+'/.git'):
|
||||
output = subprocess.Popen('git ls-files --full-name',
|
||||
stdout=PIPE, cwd=path, shell=True)
|
||||
result = []
|
||||
for file in output.stdout.read().split():
|
||||
for dir_part in os.path.dirname(file).replace(os.sep, '/').split('/'):
|
||||
if self.IgnoreDir(dir_part):
|
||||
break
|
||||
else:
|
||||
if (self.IsRelevant(file) and os.path.exists(file)
|
||||
and not self.IgnoreFile(file)):
|
||||
result.append(join(path, file))
|
||||
if output.wait() == 0:
|
||||
return result
|
||||
return super(SourceProcessor, self).FindFilesIn(path)
|
||||
|
||||
def IsRelevant(self, name):
|
||||
for ext in SourceProcessor.RELEVANT_EXTENSIONS:
|
||||
if name.endswith(ext):
|
||||
return True
|
||||
return False
|
||||
|
||||
def GetPathsToSearch(self):
|
||||
return ['.']
|
||||
|
||||
def IgnoreDir(self, name):
|
||||
return (super(SourceProcessor, self).IgnoreDir(name) or
|
||||
name in ('third_party', 'out', 'obj', 'DerivedSources'))
|
||||
|
||||
IGNORE_COPYRIGHTS = ['box2d.js',
|
||||
'cpplint.py',
|
||||
'check_injected_script_source.py',
|
||||
'copy.js',
|
||||
'corrections.js',
|
||||
'crypto.js',
|
||||
'daemon.py',
|
||||
'debugger-script.js',
|
||||
'earley-boyer.js',
|
||||
'fannkuch.js',
|
||||
'fasta.js',
|
||||
'generate_protocol_externs.py',
|
||||
'injected-script.cc',
|
||||
'injected-script.h',
|
||||
'injected-script-source.js',
|
||||
'java-script-call-frame.cc',
|
||||
'java-script-call-frame.h',
|
||||
'jsmin.py',
|
||||
'libraries.cc',
|
||||
'libraries-empty.cc',
|
||||
'lua_binarytrees.js',
|
||||
'meta-123.js',
|
||||
'memops.js',
|
||||
'poppler.js',
|
||||
'primes.js',
|
||||
'raytrace.js',
|
||||
'regexp-pcre.js',
|
||||
'resources-123.js',
|
||||
'rjsmin.py',
|
||||
'sqlite.js',
|
||||
'sqlite-change-heap.js',
|
||||
'sqlite-pointer-masking.js',
|
||||
'sqlite-safe-heap.js',
|
||||
'v8-debugger-script.h',
|
||||
'v8-function-call.cc',
|
||||
'v8-function-call.h',
|
||||
'v8-inspector-impl.cc',
|
||||
'v8-inspector-impl.h',
|
||||
'v8-runtime-agent-impl.cc',
|
||||
'v8-runtime-agent-impl.h',
|
||||
'gnuplot-4.6.3-emscripten.js',
|
||||
'zlib.js']
|
||||
IGNORE_TABS = IGNORE_COPYRIGHTS + ['unicode-test.js', 'html-comments.js']
|
||||
|
||||
IGNORE_COPYRIGHTS_DIRECTORY = "test/test262/local-tests"
|
||||
|
||||
def EndOfDeclaration(self, line):
|
||||
return line == "}" or line == "};"
|
||||
|
||||
def StartOfDeclaration(self, line):
|
||||
return line.find("//") == 0 or \
|
||||
line.find("/*") == 0 or \
|
||||
line.find(") {") != -1
|
||||
|
||||
def ProcessContents(self, name, contents):
|
||||
result = True
|
||||
base = basename(name)
|
||||
if not base in SourceProcessor.IGNORE_TABS:
|
||||
if '\t' in contents:
|
||||
print "%s contains tabs" % name
|
||||
result = False
|
||||
if not base in SourceProcessor.IGNORE_COPYRIGHTS and \
|
||||
not SourceProcessor.IGNORE_COPYRIGHTS_DIRECTORY in name:
|
||||
if not COPYRIGHT_HEADER_PATTERN.search(contents):
|
||||
print "%s is missing a correct copyright header." % name
|
||||
result = False
|
||||
if ' \n' in contents or contents.endswith(' '):
|
||||
line = 0
|
||||
lines = []
|
||||
parts = contents.split(' \n')
|
||||
if not contents.endswith(' '):
|
||||
parts.pop()
|
||||
for part in parts:
|
||||
line += part.count('\n') + 1
|
||||
lines.append(str(line))
|
||||
linenumbers = ', '.join(lines)
|
||||
if len(lines) > 1:
|
||||
print "%s has trailing whitespaces in lines %s." % (name, linenumbers)
|
||||
else:
|
||||
print "%s has trailing whitespaces in line %s." % (name, linenumbers)
|
||||
result = False
|
||||
if not contents.endswith('\n') or contents.endswith('\n\n'):
|
||||
print "%s does not end with a single new line." % name
|
||||
result = False
|
||||
# Sanitize flags for fuzzer.
|
||||
if "mjsunit" in name or "debugger" in name:
|
||||
match = FLAGS_LINE.search(contents)
|
||||
if match:
|
||||
print "%s Flags should use '-' (not '_')" % name
|
||||
result = False
|
||||
if not "mjsunit/mjsunit.js" in name:
|
||||
if ASSERT_OPTIMIZED_PATTERN.search(contents) and \
|
||||
not FLAGS_ENABLE_OPT.search(contents):
|
||||
print "%s Flag --opt should be set if " \
|
||||
"assertOptimized() is used" % name
|
||||
result = False
|
||||
if ASSERT_UNOPTIMIZED_PATTERN.search(contents) and \
|
||||
not FLAGS_NO_ALWAYS_OPT.search(contents):
|
||||
print "%s Flag --no-always-opt should be set if " \
|
||||
"assertUnoptimized() is used" % name
|
||||
result = False
|
||||
|
||||
match = self.runtime_function_call_pattern.search(contents)
|
||||
if match:
|
||||
print "%s has unexpected spaces in a runtime call '%s'" % (name, match.group(1))
|
||||
result = False
|
||||
return result
|
||||
|
||||
def ProcessFiles(self, files):
|
||||
success = True
|
||||
violations = 0
|
||||
for file in files:
|
||||
try:
|
||||
handle = open(file)
|
||||
contents = handle.read()
|
||||
if not self.ProcessContents(file, contents):
|
||||
success = False
|
||||
violations += 1
|
||||
finally:
|
||||
handle.close()
|
||||
print "Total violating files: %s" % violations
|
||||
return success
|
||||
|
||||
def _CheckStatusFileForDuplicateKeys(filepath):
|
||||
comma_space_bracket = re.compile(", *]")
|
||||
lines = []
|
||||
with open(filepath) as f:
|
||||
for line in f.readlines():
|
||||
# Skip all-comment lines.
|
||||
if line.lstrip().startswith("#"): continue
|
||||
# Strip away comments at the end of the line.
|
||||
comment_start = line.find("#")
|
||||
if comment_start != -1:
|
||||
line = line[:comment_start]
|
||||
line = line.strip()
|
||||
# Strip away trailing commas within the line.
|
||||
line = comma_space_bracket.sub("]", line)
|
||||
if len(line) > 0:
|
||||
lines.append(line)
|
||||
|
||||
# Strip away trailing commas at line ends. Ugh.
|
||||
for i in range(len(lines) - 1):
|
||||
if (lines[i].endswith(",") and len(lines[i + 1]) > 0 and
|
||||
lines[i + 1][0] in ("}", "]")):
|
||||
lines[i] = lines[i][:-1]
|
||||
|
||||
contents = "\n".join(lines)
|
||||
# JSON wants double-quotes.
|
||||
contents = contents.replace("'", '"')
|
||||
# Fill in keywords (like PASS, SKIP).
|
||||
for key in statusfile.KEYWORDS:
|
||||
contents = re.sub(r"\b%s\b" % key, "\"%s\"" % key, contents)
|
||||
|
||||
status = {"success": True}
|
||||
def check_pairs(pairs):
|
||||
keys = {}
|
||||
for key, value in pairs:
|
||||
if key in keys:
|
||||
print("%s: Error: duplicate key %s" % (filepath, key))
|
||||
status["success"] = False
|
||||
keys[key] = True
|
||||
|
||||
json.loads(contents, object_pairs_hook=check_pairs)
|
||||
return status["success"]
|
||||
|
||||
|
||||
class StatusFilesProcessor(SourceFileProcessor):
|
||||
"""Checks status files for incorrect syntax and duplicate keys."""
|
||||
|
||||
def IsRelevant(self, name):
|
||||
# Several changes to files under the test directories could impact status
|
||||
# files.
|
||||
return True
|
||||
|
||||
def GetPathsToSearch(self):
|
||||
return ['test', 'tools/testrunner']
|
||||
|
||||
def ProcessFiles(self, files):
|
||||
success = True
|
||||
for status_file_path in sorted(self._GetStatusFiles(files)):
|
||||
success &= statusfile.PresubmitCheck(status_file_path)
|
||||
success &= _CheckStatusFileForDuplicateKeys(status_file_path)
|
||||
return success
|
||||
|
||||
def _GetStatusFiles(self, files):
|
||||
test_path = join(dirname(TOOLS_PATH), 'test')
|
||||
testrunner_path = join(TOOLS_PATH, 'testrunner')
|
||||
status_files = set()
|
||||
|
||||
for file_path in files:
|
||||
if file_path.startswith(testrunner_path):
|
||||
for suitepath in os.listdir(test_path):
|
||||
suitename = os.path.basename(suitepath)
|
||||
status_file = os.path.join(
|
||||
test_path, suitename, suitename + ".status")
|
||||
if os.path.exists(status_file):
|
||||
status_files.add(status_file)
|
||||
return status_files
|
||||
|
||||
for file_path in files:
|
||||
if file_path.startswith(test_path):
|
||||
# Strip off absolute path prefix pointing to test suites.
|
||||
pieces = file_path[len(test_path):].lstrip(os.sep).split(os.sep)
|
||||
if pieces:
|
||||
# Infer affected status file name. Only care for existing status
|
||||
# files. Some directories under "test" don't have any.
|
||||
if not os.path.isdir(join(test_path, pieces[0])):
|
||||
continue
|
||||
status_file = join(test_path, pieces[0], pieces[0] + ".status")
|
||||
if not os.path.exists(status_file):
|
||||
continue
|
||||
status_files.add(status_file)
|
||||
return status_files
|
||||
|
||||
|
||||
def CheckDeps(workspace):
|
||||
checkdeps_py = join(workspace, 'buildtools', 'checkdeps', 'checkdeps.py')
|
||||
return subprocess.call([sys.executable, checkdeps_py, workspace]) == 0
|
||||
|
||||
|
||||
def PyTests(workspace):
|
||||
result = True
|
||||
for script in [
|
||||
join(workspace, 'tools', 'release', 'test_scripts.py'),
|
||||
join(workspace, 'tools', 'unittests', 'run_tests_test.py'),
|
||||
]:
|
||||
print 'Running ' + script
|
||||
result &= subprocess.call(
|
||||
[sys.executable, script], stdout=subprocess.PIPE) == 0
|
||||
return result
|
||||
|
||||
|
||||
def GetOptions():
|
||||
result = optparse.OptionParser()
|
||||
result.add_option('--no-lint', help="Do not run cpplint", default=False,
|
||||
action="store_true")
|
||||
return result
|
||||
|
||||
|
||||
def Main():
|
||||
workspace = abspath(join(dirname(sys.argv[0]), '..'))
|
||||
parser = GetOptions()
|
||||
(options, args) = parser.parse_args()
|
||||
success = True
|
||||
print "Running checkdeps..."
|
||||
success &= CheckDeps(workspace)
|
||||
if not options.no_lint:
|
||||
print "Running C++ lint check..."
|
||||
success &= CppLintProcessor().RunOnPath(workspace)
|
||||
print "Running Torque formatting check..."
|
||||
success &= TorqueFormatProcessor().RunOnPath(workspace)
|
||||
print "Running copyright header, trailing whitespaces and " \
|
||||
"two empty lines between declarations check..."
|
||||
success &= SourceProcessor().RunOnPath(workspace)
|
||||
print "Running status-files check..."
|
||||
success &= StatusFilesProcessor().RunOnPath(workspace)
|
||||
print "Running python tests..."
|
||||
success &= PyTests(workspace)
|
||||
if success:
|
||||
return 0
|
||||
else:
|
||||
return 1
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(Main())
|
||||
Loading…
Reference in New Issue
Block a user