def __init__(self, new_path, filename, reference_support_info, host=Host(), convert_test_harness_links=True, webkit_test_runner_options=''):
HTMLParser.__init__(self)
self._host = host
self._filesystem = self._host.filesystem
self._webkit_root = WebKitFinder(self._filesystem).webkit_base()
self.converted_data = []
self.converted_properties = []
self.converted_property_values = []
self.in_style_tag = False
self.style_data = []
self.filename = filename
self.reference_support_info = reference_support_info
self.webkit_test_runner_options = webkit_test_runner_options
self.has_started = False
resources_path = self.path_from_webkit_root('LayoutTests', 'resources')
resources_relpath = self._filesystem.relpath(resources_path, new_path)
self.new_test_harness_path = resources_relpath
self.convert_test_harness_links = convert_test_harness_links
# These settings might vary between WebKit and Blink
css_property_file = self.path_from_webkit_root('Source', 'WebCore', 'css', 'CSSProperties.json')
css_property_value_file = self.path_from_webkit_root('Source', 'WebCore', 'css', 'CSSValueKeywords.in')
self.test_harness_re = re.compile('/resources/testharness')
self.prefixed_properties = self.read_webkit_prefixed_css_property_list(css_property_file)
prop_regex = '([\s{]|^)(' + "|".join(prop.replace('-webkit-', '') for prop in self.prefixed_properties) + ')(\s+:|:)'
self.prop_re = re.compile(prop_regex)
self.prefixed_property_values = self.legacy_read_webkit_prefixed_css_property_list(css_property_value_file)
prop_value_regex = '(:\s*|^\s*)(' + "|".join(value.replace('-webkit-', '') for value in self.prefixed_property_values) + ')(\s*;|\s*}|\s*$)'
self.prop_value_re = re.compile(prop_value_regex)
def __init__(self, host, source_repo_path, dest_dir_name='external'):
"""Initializes variables to prepare for copying and converting files.
Args:
host: An instance of Host.
source_repo_path: Path to the local checkout of a
web-platform-tests or csswg-test repository.
dest_dir_name: The name of the directory under the layout tests
directory where imported tests should be copied to.
TODO(qyearsley): This can be made into a constant.
"""
self.host = host
assert self.host.filesystem.exists(source_repo_path)
self.source_repo_path = source_repo_path
self.dest_dir_name = dest_dir_name
self.filesystem = self.host.filesystem
self.webkit_finder = WebKitFinder(self.filesystem)
self._webkit_root = self.webkit_finder.webkit_base()
self.layout_tests_dir = self.webkit_finder.path_from_webkit_base('LayoutTests')
self.destination_directory = self.filesystem.normpath(
self.filesystem.join(
self.layout_tests_dir,
dest_dir_name,
self.filesystem.basename(self.source_repo_path)))
self.import_in_place = (self.source_repo_path == self.destination_directory)
self.dir_above_repo = self.filesystem.dirname(self.source_repo_path)
self.is_wpt = self.filesystem.basename(self.source_repo_path) == 'wpt'
self.import_list = []
# This is just a FYI list of CSS properties that still need to be prefixed,
# which may be output after importing.
self._prefixed_properties = {}
def __init__(self, host, source_repo_path, dest_dir_name='external'):
"""Initializes variables to prepare for copying and converting files.
Args:
source_repo_path: Path to the local checkout of a WPT
"""
self.host = host
assert self.host.filesystem.exists(source_repo_path)
self.source_repo_path = source_repo_path
self.dest_dir_name = dest_dir_name
self.filesystem = self.host.filesystem
self.webkit_finder = WebKitFinder(self.filesystem)
self._webkit_root = self.webkit_finder.webkit_base()
self.layout_tests_dir = self.webkit_finder.path_from_webkit_base(
'LayoutTests')
self.destination_directory = self.filesystem.normpath(
self.filesystem.join(
self.layout_tests_dir, dest_dir_name,
self.filesystem.basename(self.source_repo_path)))
self.import_in_place = (
self.source_repo_path == self.destination_directory)
self.dir_above_repo = self.filesystem.dirname(self.source_repo_path)
self.import_list = []
# This is just a FYI list of CSS properties that still need to be prefixed,
# which may be output after importing.
self._prefixed_properties = {}
def __init__(self,
host,
bugzilla_id,
is_bug_id=True,
is_attachment_platform_specific=False,
attachment_fetcher=bugzilla.Bugzilla(),
unzip=None):
self.host = host
self.filesystem = self.host.filesystem
self.unzip = unzip if unzip else lambda content: zipfile.ZipFile(
io.BytesIO(content))
if is_bug_id:
self.platform_specific_attachments = {}
for attachment in attachment_fetcher.fetch_bug(
bugzilla_id).attachments():
bot_type = self._bot_type(attachment)
if bot_type:
self.platform_specific_attachments[bot_type] = attachment
self.generic_attachment = self.platform_specific_attachments.pop(
"mac-wk2"
) if "mac-wk2" in self.platform_specific_attachments else None
else:
attachment = attachment_fetcher.fetch_attachment(bugzilla_id)
self.platform_specific_attachments = {
self._bot_type(attachment): attachment
} if is_attachment_platform_specific else {}
self.generic_attachment = attachment if not is_attachment_platform_specific else None
webkit_finder = WebKitFinder(self.filesystem)
self.layout_test_repository = webkit_finder.path_from_webkit_base(
"LayoutTests")
def start(self):
assert not self._pid, '%s server is already running' % self._name
# Stop any stale servers left over from previous instances.
if self._port.host.filesystem.exists(self._pid_file):
try:
self._pid = int(
self._port.host.filesystem.read_text_file(self._pid_file))
self.stop()
except (ValueError, UnicodeDecodeError):
# These could be raised if the pid file is corrupt.
self._port.host.filesystem.remove(self._pid_file)
self._pid = None
_log.debug('Copying WebDriver WPT server config.json')
doc_root = os.path.join(
WebKitFinder(self._port.host.filesystem).path_from_webkit_base(
'WebDriverTests'), 'imported', 'w3c')
config_filename = os.path.join(doc_root, 'config.json')
config = json.loads(
self._port.host.filesystem.read_text_file(config_filename))
config['doc_root'] = doc_root
config['ssl']['openssl']['base_path'] = os.path.join(
self._runtime_path, '_wpt_certs')
self._port.host.filesystem.write_text_file(
os.path.join(self._layout_doc_root, 'config.json'),
json.dumps(config))
self._server_host = config['browser_host']
self._server_http_port = config['ports']['http'][0]
self._server_https_port = config['ports']['https'][0]
self._wsout = self._port.host.filesystem.open_text_file_for_writing(
self._output_log_path)
wpt_file = os.path.join(self._layout_doc_root, "wpt.py")
cmd = [
"python", wpt_file, "serve", "--config",
os.path.join(self._layout_doc_root, 'config.json')
]
self._process = self._port._executive.popen(
cmd,
cwd=self._layout_doc_root,
shell=False,
stdin=self._port._executive.PIPE,
stdout=self._wsout,
stderr=self._wsout)
self._pid = self._process.pid
self._port.host.filesystem.write_text_file(self._pid_file,
str(self._pid))
if not self._wait_for_server():
_log.error(
'WPT Server process exited prematurely with status code %s' %
self._process.returncode)
self.stop()
raise RuntimeError
_log.info(
'WebDriver WPT server listening at http://%s:%s/ and https://%s:%s/'
% (self._server_host, self._server_http_port, self._server_host,
self._server_https_port))
def _test_prefix_list(self, issue_number, only_changed_tests):
"""Returns a collection of test, builder and file extensions to get new baselines for.
Args:
issue_number: The CL number of the change which needs new baselines.
only_changed_tests: Whether to only include baselines for tests that
are changed in this CL. If False, all new baselines for failing
tests will be downloaded, even for tests that were not modified.
Returns:
A dict containing information about which new baselines to download.
"""
builds_to_tests = self._builds_to_tests(issue_number)
if only_changed_tests:
files_in_cl = self.rietveld.changed_files(issue_number)
finder = WebKitFinder(self._tool.filesystem)
tests_in_cl = [finder.layout_test_name(f) for f in files_in_cl]
result = {}
for build, tests in builds_to_tests.iteritems():
for test in tests:
if only_changed_tests and test not in tests_in_cl:
continue
if test not in result:
result[test] = {}
result[test][build] = BASELINE_SUFFIX_LIST
return result
def do_POST(self):
json_raw_data = self.rfile.read(
int(self.headers.getheader('content-length')))
json_data = json.loads(json_raw_data)
test_list = ''
for each in json_data['tests']:
test_list += each + ' '
filesystem = FileSystem()
webkit_finder = WebKitFinder(filesystem)
script_dir = webkit_finder.path_from_webkit_base('Tools', 'Scripts')
executable_path = script_dir + "/run-webkit-tests"
cmd = "python " + executable_path + " --no-show-results "
cmd += test_list
process = subprocess.Popen(cmd,
shell=True,
cwd=script_dir,
env=None,
stdout=subprocess.PIPE,
stderr=STDOUT)
self.send_response(200)
self.send_header('Access-Control-Allow-Origin', '*')
self.send_header("Content-type", "text/html")
self.end_headers()
while process.poll() is None:
html_output = '<br>' + str(process.stdout.readline())
self.wfile.write(html_output)
self.wfile.flush()
time.sleep(0.05)
process.wait()
def start(self):
assert not self._pid, '%s server is already running' % self._name
# Stop any stale servers left over from previous instances.
if self._port.host.filesystem.exists(self._pid_file):
try:
self._pid = int(self._port.host.filesystem.read_text_file(self._pid_file))
self.stop()
except (ValueError, UnicodeDecodeError):
# These could be raised if the pid file is corrupt.
self._port.host.filesystem.remove(self._pid_file)
self._pid = None
_log.debug('Copying WebDriver WPT server config.json')
doc_root = os.path.join(WebKitFinder(self._port.host.filesystem).path_from_webkit_base('WebDriverTests'), 'imported', 'w3c')
config_filename = os.path.join(doc_root, 'config.json')
config_json = self._port.host.filesystem.read_text_file(config_filename).replace("%DOC_ROOT%", doc_root)
self._port.host.filesystem.write_text_file(os.path.join(self._layout_doc_root, 'config.json'), config_json)
config = json.loads(config_json)
self._server_host = config['host']
self._server_port = config['ports']['http'][0]
self._wsout = self._port.host.filesystem.open_text_file_for_writing(self._output_log_path)
launcher = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'layout_tests', 'servers', 'web_platform_test_launcher.py'))
cmd = ['python', launcher, self._servers_file]
self._process = self._port._executive.popen(cmd, cwd=self._layout_doc_root, shell=False, stdin=self._port._executive.PIPE, stdout=self._wsout, stderr=self._wsout)
self._pid = self._process.pid
self._port.host.filesystem.write_text_file(self._pid_file, str(self._pid))
if not self._wait_for_server():
_log.error('WPT Server process exited prematurely with status code %s' % self._process.returncode)
self.stop()
raise RuntimeError
_log.info('WebDriver WPT server listening at http://%s:%s/' % (self._server_host, self._server_port))
def _read_configuration_from_gn(fs, options):
"""Return the configuration to used based on args.gn, if possible."""
# We should really default to 'out' everywhere at this point, but
# that's a separate cleanup CL.
build_directory = getattr(options, 'build_directory', None) or 'out'
target = options.target
finder = WebKitFinder(fs)
path = fs.join(finder.chromium_base(), build_directory, target, 'args.gn')
if not fs.exists(path):
path = fs.join(finder.chromium_base(), build_directory, target,
'toolchain.ninja')
if not fs.exists(path):
# This does not appear to be a GN-based build directory, so we don't know
# how to interpret it.
return None
# toolchain.ninja exists, but args.gn does not; this can happen when
# `gn gen` is run with no --args.
return 'Debug'
args = fs.read_text_file(path)
for l in args.splitlines():
if re.match(r'^\s*is_debug\s*=\s*false(\s*$|\s*#.*$)', l):
return 'Release'
# if is_debug is set to anything other than false, or if it
# does not exist at all, we should use the default value (True).
return 'Debug'
def __init__(self, port, options, printer):
"""Initialize test runner data structures.
Args:
port: An object implementing platform-specific functionality.
options: An options argument which contains command line options.
printer: A Printer object to record updates to.
"""
self._port = port
self._filesystem = port.host.filesystem
self._options = options
self._printer = printer
self._expectations = None
self.HTTP_SUBDIR = 'http' + port.TEST_PATH_SEPARATOR
self.INSPECTOR_SUBDIR = 'inspector' + port.TEST_PATH_SEPARATOR
self.PERF_SUBDIR = 'perf'
self.WEBSOCKET_SUBDIR = 'websocket' + port.TEST_PATH_SEPARATOR
self.LAYOUT_TESTS_DIRECTORY = 'LayoutTests'
self.ARCHIVED_RESULTS_LIMIT = 25
self._http_server_started = False
self._wptserve_started = False
self._websockets_server_started = False
self._results_directory = self._port.results_directory()
self._finder = LayoutTestFinder(self._port, self._options)
self._webkit_finder = WebKitFinder(port.host.filesystem)
self._runner = LayoutTestRunner(self._options, self._port,
self._printer, self._results_directory,
self._test_is_slow)
def __init__(self, new_path, filename, reference_support_info,
host=Host()):
HTMLParser.__init__(self)
self._host = host
self._filesystem = self._host.filesystem
self._webkit_root = WebKitFinder(self._filesystem).webkit_base()
self.converted_data = []
self.converted_properties = []
self.in_style_tag = False
self.style_data = []
self.filename = filename
self.reference_support_info = reference_support_info
resources_path = self.path_from_webkit_root('LayoutTests', 'resources')
resources_relpath = self._filesystem.relpath(resources_path, new_path)
self.resources_relpath = resources_relpath
# These settings might vary between WebKit and Blink.
# Only -webkit-text-emphasis is currently needed. See:
# https://bugs.chromium.org/p/chromium/issues/detail?id=614955#c1
self.prefixed_properties = [
'-webkit-text-emphasis',
'-webkit-text-emphasis-color',
'-webkit-text-emphasis-position',
'-webkit-text-emphasis-style',
]
prop_regex = r'([\s{]|^)(' + '|'.join(
prop.replace('-webkit-', '')
for prop in self.prefixed_properties) + r')(\s+:|:)'
self.prop_re = re.compile(prop_regex)
def __init__(self, host):
self.host = host
self.executive = host.executive
self.fs = host.filesystem
self.finder = WebKitFinder(self.fs)
self.verbose = False
self.git_cl = None
def __init__(self, new_path, filename, host=Host()):
HTMLParser.__init__(self)
self._host = host
self._filesystem = self._host.filesystem
self._webkit_root = WebKitFinder(self._filesystem).webkit_base()
self.converted_data = []
self.converted_properties = []
self.in_style_tag = False
self.style_data = []
self.filename = filename
resources_path = self.path_from_webkit_root('tests', 'resources')
resources_relpath = self._filesystem.relpath(resources_path, new_path)
self.resources_relpath = resources_relpath
# These settings might vary between WebKit and Blink
self._css_property_file = self.path_from_webkit_root(
'Source', 'core', 'css', 'CSSProperties.in')
self.prefixed_properties = self.read_webkit_prefixed_css_property_list(
)
self.prefixed_properties = self.read_webkit_prefixed_css_property_list(
)
prop_regex = '([\s{]|^)(' + "|".join(
prop.replace('-webkit-', '')
for prop in self.prefixed_properties) + ')(\s+:|:)'
self.prop_re = re.compile(prop_regex)
def _assertOptimization(self,
results_by_directory,
expected_new_results_by_directory,
baseline_dirname=''):
host = MockHost()
fs = host.filesystem
webkit_base = WebKitFinder(fs).webkit_base()
baseline_name = 'mock-baseline-expected.txt'
for dirname, contents in results_by_directory.items():
path = fs.join(webkit_base, 'LayoutTests', dirname, baseline_name)
fs.write_binary_file(path, contents)
baseline_optimizer = BaselineOptimizer(
host, host.port_factory.all_port_names())
self.assertTrue(
baseline_optimizer.optimize(
fs.join(baseline_dirname, baseline_name)))
for dirname, contents in expected_new_results_by_directory.items():
path = fs.join(webkit_base, 'LayoutTests', dirname, baseline_name)
if contents is None:
self.assertFalse(fs.exists(path))
else:
self.assertEqual(fs.read_binary_file(path), contents)
# Check that the files that were in the original set have been deleted where necessary.
for dirname in results_by_directory:
path = fs.join(webkit_base, 'LayoutTests', dirname, baseline_name)
if not dirname in expected_new_results_by_directory:
self.assertFalse(fs.exists(path))
def __init__(self, filesystem=None, webkit_finder=None):
self.filesystem = filesystem or FileSystem()
self.executive = Executive()
self.finder = Finder(self.filesystem)
self.printer = Printer(sys.stderr)
self.webkit_finder = webkit_finder or WebKitFinder(self.filesystem)
self._options = None
def __init__(self, host, test_paths, options):
self.host = host
self.source_directory = options.source
self.options = options
self.test_paths = test_paths if test_paths else []
self.filesystem = self.host.filesystem
webkit_finder = WebKitFinder(self.filesystem)
self._webkit_root = webkit_finder.webkit_base()
self.destination_directory = webkit_finder.path_from_webkit_base("LayoutTests", options.destination)
self.tests_w3c_relative_path = self.filesystem.join('imported', 'w3c')
self.layout_tests_path = webkit_finder.path_from_webkit_base('LayoutTests')
self.layout_tests_w3c_path = self.filesystem.join(self.layout_tests_path, self.tests_w3c_relative_path)
self.tests_download_path = webkit_finder.path_from_webkit_base('WebKitBuild', 'w3c-tests')
self._test_downloader = None
self._potential_test_resource_files = []
self.import_list = []
self._importing_downloaded_tests = self.source_directory is None
self._test_resource_files_json_path = self.filesystem.join(self.layout_tests_w3c_path, "resources", "resource-files.json")
self._test_resource_files = json.loads(self.filesystem.read_text_file(self._test_resource_files_json_path)) if self.filesystem.exists(self._test_resource_files_json_path) else None
self._tests_options_json_path = self.filesystem.join(self.layout_tests_path, 'tests-options.json')
self._tests_options = json.loads(self.filesystem.read_text_file(self._tests_options_json_path)) if self.filesystem.exists(self._tests_options_json_path) else None
self._slow_tests = []
if self.options.clean_destination_directory and self._test_resource_files:
self._test_resource_files["files"] = []
if self._tests_options:
self.remove_slow_from_w3c_tests_options()
def _assertOptimization(self, results_by_directory, expected_new_results_by_directory, baseline_dirname='', expected_files_to_delete=None, host=None):
if not host:
host = MockHost()
fs = host.filesystem
webkit_base = WebKitFinder(fs).webkit_base()
baseline_name = 'mock-baseline-expected.txt'
fs.write_text_file(fs.join(webkit_base, 'LayoutTests', 'VirtualTestSuites'),
'[{"prefix": "gpu", "base": "fast/canvas", "args": ["--foo"]}]')
for dirname, contents in results_by_directory.items():
path = fs.join(webkit_base, 'LayoutTests', dirname, baseline_name)
fs.write_binary_file(path, contents)
baseline_optimizer = BaselineOptimizer(host, host.port_factory.get(), host.port_factory.all_port_names(), skip_scm_commands=expected_files_to_delete is not None)
self.assertTrue(baseline_optimizer.optimize(fs.join(baseline_dirname, baseline_name)))
for dirname, contents in expected_new_results_by_directory.items():
path = fs.join(webkit_base, 'LayoutTests', dirname, baseline_name)
if contents is None:
self.assertTrue(not fs.exists(path) or path in baseline_optimizer._files_to_delete)
else:
self.assertEqual(fs.read_binary_file(path), contents)
# Check that the files that were in the original set have been deleted where necessary.
for dirname in results_by_directory:
path = fs.join(webkit_base, 'LayoutTests', dirname, baseline_name)
if not dirname in expected_new_results_by_directory:
self.assertTrue(not fs.exists(path) or path in baseline_optimizer._files_to_delete)
if expected_files_to_delete:
self.assertEqual(sorted(baseline_optimizer._files_to_delete), sorted(expected_files_to_delete))
def __init__(self, host, options, gitClass=Git, bugzillaClass=Bugzilla, WPTGitHubClass=WPTGitHub, WPTLinterClass=WPTLinter):
self._host = host
self._filesystem = host.filesystem
self._options = options
self._host.initialize_scm()
self._WPTGitHubClass = WPTGitHubClass
self._gitClass = gitClass
self._bugzilla = bugzillaClass()
self._bug_id = options.bug_id
if not self._bug_id:
if options.attachment_id:
self._bug_id = self._bugzilla.bug_id_for_attachment_id(options.attachment_id)
elif options.git_commit:
self._bug_id = self._host.checkout().bug_id_for_this_commit(options.git_commit)
if not self._options.repository_directory:
webkit_finder = WebKitFinder(self._filesystem)
self._options.repository_directory = WPTPaths.wpt_checkout_path(webkit_finder)
self._linter = WPTLinterClass(self._options.repository_directory, host.filesystem)
self._bugzilla_url = "https://bugs.webkit.org/show_bug.cgi?id=" + str(self._bug_id)
self._commit_message = options.message
if not self._commit_message:
self._commit_message = 'WebKit export of ' + self._bugzilla_url if self._bug_id else 'Export made from a WebKit repository'
def __init__(self, port):
self._port = port
_log.info('Using port %s' % self._port.name())
_log.info('Test configuration: %s' % self._port.test_configuration())
_log.info('Using display server %s' % (self._port._display_server))
self._display_driver = self._port._driver_class()(self._port,
worker_number=0,
pixel_tests=False,
no_timeout=True)
if not self._display_driver.check_driver(self._port):
raise RuntimeError("Failed to check driver %s" %
self._display_driver.__class__.__name__)
driver = create_driver(self._port)
_log.info('Using driver at %s' % (driver.binary_path()))
_log.info('Browser: %s' % (driver.browser_name()))
_log.info('Parsing expectations')
self._tests_dir = WebKitFinder(
self._port.host.filesystem).path_from_webkit_base('WebDriverTests')
expectations_file = os.path.join(self._tests_dir,
'TestExpectations.json')
build_type = 'Debug' if self._port.get_option('debug') else 'Release'
self._expectations = TestExpectations(self._port.name(),
expectations_file, build_type)
env = self._display_driver._setup_environ_for_test()
self._runners = [
runner_cls(self._port, driver, env, self._expectations)
for runner_cls in self.RUNNER_CLASSES
]
def __init__(self, repository_directory, host, options):
self._options = options
self._host = host
self._filesystem = host.filesystem
self._test_suites = []
self.repository_directory = repository_directory
self.test_repositories = self.load_test_repositories(self._filesystem)
self.paths_to_skip = []
self.paths_to_import = []
for test_repository in self.test_repositories:
self.paths_to_skip.extend([
self._filesystem.join(test_repository['name'], path)
for path in test_repository['paths_to_skip']
])
self.paths_to_import.extend([
self._filesystem.join(test_repository['name'], path)
for path in test_repository['paths_to_import']
])
webkit_finder = WebKitFinder(self._filesystem)
self.import_expectations_path = webkit_finder.path_from_webkit_base(
'LayoutTests', 'imported', 'w3c', 'resources',
'import-expectations.json')
if not self._filesystem.isfile(self.import_expectations_path):
_log.warning('Unable to read import expectation file: %s' %
self.import_expectations_path)
if not self._options.import_all:
self._init_paths_from_expectations()
def __init__(self, port, driver, env, expectations):
self._port = port
self._driver = driver
self._env = env
self._expectations = expectations
self._results = []
self._tests_dir = WebKitFinder(self._port.host.filesystem).path_from_webkit_base('WebDriverTests')
def _assertOptimization(self,
results_by_directory,
expected_new_results_by_directory,
baseline_dirname='',
host=None):
if not host:
host = MockHost()
fs = host.filesystem
webkit_base = WebKitFinder(fs).webkit_base()
baseline_name = 'mock-baseline-expected.txt'
fs.write_text_file(
fs.join(webkit_base, 'LayoutTests', 'VirtualTestSuites'),
'[{"prefix": "gpu", "base": "fast/canvas", "args": ["--foo"]}]')
for dirname, contents in results_by_directory.items():
path = fs.join(webkit_base, 'LayoutTests', dirname, baseline_name)
fs.write_binary_file(path, contents)
baseline_optimizer = BaselineOptimizer(
host, host.port_factory.get(), host.port_factory.all_port_names())
self.assertTrue(
baseline_optimizer.optimize(
fs.join(baseline_dirname, baseline_name)))
for dirname, contents in expected_new_results_by_directory.items():
path = fs.join(webkit_base, 'LayoutTests', dirname, baseline_name)
if contents is not None:
self.assertEqual(fs.read_binary_file(path), contents)
def __init__(self, repository_directory, host, options):
self._options = options
self._host = host
self._filesystem = host.filesystem
self._test_suites = []
self.repository_directory = repository_directory
self.test_repositories = self.load_test_repositories()
self.paths_to_skip = []
self.paths_to_import = []
for test_repository in self.test_repositories:
self.paths_to_skip.extend([
self._filesystem.join(test_repository['name'], path)
for path in test_repository['paths_to_skip']
])
self.paths_to_import.extend([
self._filesystem.join(test_repository['name'], path)
for path in test_repository['paths_to_import']
])
if not self._options.import_all:
webkit_finder = WebKitFinder(self._filesystem)
import_expectations_path = webkit_finder.path_from_webkit_base(
'LayoutTests', 'imported', 'w3c', 'resources',
'ImportExpectations')
self._init_paths_from_expectations(import_expectations_path)
def main():
filesystem = FileSystem()
wkf = WebKitFinder(filesystem)
tester = Tester(filesystem, wkf)
tester.add_tree(wkf.path_from_webkit_base('Tools', 'Scripts'), 'webkitpy')
tester.skip(('webkitpy.common.checkout.scm.scm_unittest', ),
'are really, really, slow', 31818)
if sys.platform == 'win32':
tester.skip(
('webkitpy.common.checkout', 'webkitpy.common.config',
'webkitpy.tool', 'webkitpy.w3c',
'webkitpy.layout_tests.layout_package.bot_test_expectations'),
'fail horribly on win32', 54526)
# This only needs to run on Unix, so don't worry about win32 for now.
appengine_sdk_path = '/usr/local/google_appengine'
if os.path.exists(appengine_sdk_path):
if not appengine_sdk_path in sys.path:
sys.path.append(appengine_sdk_path)
import dev_appserver
from google.appengine.dist import use_library
use_library('django', '1.2')
dev_appserver.fix_sys_path()
tester.add_tree(wkf.path_from_webkit_base('Tools', 'TestResultServer'))
else:
_log.info(
'Skipping TestResultServer tests; the Google AppEngine Python SDK is not installed.'
)
return not tester.run()
def get_port(self, target=None, configuration=None, files=None):
host = MockHost()
wkf = WebKitFinder(host.filesystem)
files = files or {}
for path, contents in files.items():
host.filesystem.write_text_file(wkf.path_from_chromium_base(path), contents)
options = MockOptions(target=target, configuration=configuration)
return factory.PortFactory(host).get(options=options)
def __init__(self, host):
self.host = host
self.executive = host.executive
self.fs = host.filesystem
self.finder = WebKitFinder(self.fs)
self.verbose = False
self.allow_local_blink_commits = False
self.keep_w3c_repos_around = False
def __init__(self, executive, name, pid, newer_than, filesystem, path_to_driver, port_name, configuration):
self.name = name
self.pid = pid
self.newer_than = newer_than
self._filesystem = filesystem
self._path_to_driver = path_to_driver
self._executive = executive
self._port_name = port_name
self._configuration = configuration
self._webkit_finder = WebKitFinder(filesystem)
def __init__(self):
self._host = Host()
self._filesystem = self._host.filesystem
self._webkit_root = WebKitFinder(self._filesystem).webkit_base()
# These settings might vary between WebKit and Blink
self._css_property_file = self.path_from_webkit_root('Source', 'WebCore', 'css', 'CSSPropertyNames.in')
self._css_property_split_string = '='
self.prefixed_properties = self.read_webkit_prefixed_css_property_list()
def _add_base_manifest_to_mock_filesystem(self, filesystem):
webkit_finder = WebKitFinder(filesystem)
external_dir = webkit_finder.path_from_webkit_base(
'LayoutTests', 'external')
filesystem.maybe_make_directory(filesystem.join(external_dir, 'wpt'))
manifest_base_path = filesystem.join(external_dir,
'WPT_BASE_MANIFEST.json')
filesystem.files[manifest_base_path] = '{}'
def _run_pylint(self, path):
wkf = WebKitFinder(FileSystem())
executive = Executive()
return executive.run_command([
sys.executable,
wkf.path_from_depot_tools_base('pylint.py'),
'--output-format=parseable',
'--errors-only', '--rcfile=' + wkf.path_from_webkit_base(
'Tools', 'Scripts', 'webkitpy', 'pylintrc'), path
],
error_handler=executive.ignore_error)
