Use simctl instead of LayoutTestRelay
[WebKit.git] / Tools / Scripts / webkitpy / port / base.py
1 # Copyright (C) 2010 Google Inc. All rights reserved.
2 # Copyright (C) 2013 Apple Inc. All rights reserved.
3 #
4 # Redistribution and use in source and binary forms, with or without
5 # modification, are permitted provided that the following conditions are
6 # met:
7 #
8 #     * Redistributions of source code must retain the above copyright
9 # notice, this list of conditions and the following disclaimer.
10 #     * Redistributions in binary form must reproduce the above
11 # copyright notice, this list of conditions and the following disclaimer
12 # in the documentation and/or other materials provided with the
13 # distribution.
14 #     * Neither the Google name nor the names of its
15 # contributors may be used to endorse or promote products derived from
16 # this software without specific prior written permission.
17 #
18 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30 """Abstract base class of Port-specific entry points for the layout tests
31 test infrastructure (the Port and Driver classes)."""
32
33 import difflib
34 import itertools
35 import json
36 import logging
37 import os
38 import operator
39 import optparse
40 import re
41 import sys
42
43 from collections import OrderedDict
44 from functools import partial
45
46 from webkitpy.common import find_files
47 from webkitpy.common import read_checksum_from_png
48 from webkitpy.common.memoized import memoized
49 from webkitpy.common.prettypatch import PrettyPatch
50 from webkitpy.common.system import path
51 from webkitpy.common.system.executive import ScriptError
52 from webkitpy.common.wavediff import WaveDiff
53 from webkitpy.common.webkit_finder import WebKitFinder
54 from webkitpy.layout_tests.models.test_configuration import TestConfiguration
55 from webkitpy.port import config as port_config
56 from webkitpy.port import driver
57 from webkitpy.port import image_diff
58 from webkitpy.port import server_process
59 from webkitpy.port.factory import PortFactory
60 from webkitpy.layout_tests.servers import apache_http_server
61 from webkitpy.layout_tests.servers import http_server
62 from webkitpy.layout_tests.servers import web_platform_test_server
63 from webkitpy.layout_tests.servers import websocket_server
64
65 _log = logging.getLogger(__name__)
66
67
68 class Port(object):
69     """Abstract class for Port-specific hooks for the layout_test package."""
70
71     # Subclasses override this. This should indicate the basic implementation
72     # part of the port name, e.g., 'win', 'gtk'; there is probably (?) one unique value per class.
73
74     # FIXME: We should probably rename this to something like 'implementation_name'.
75     port_name = None
76
77     # Test names resemble unix relative paths, and use '/' as a directory separator.
78     TEST_PATH_SEPARATOR = '/'
79
80     ALL_BUILD_TYPES = ('debug', 'release')
81
82     DEFAULT_ARCHITECTURE = 'x86'
83
84     CUSTOM_DEVICE_CLASSES = []
85
86     @classmethod
87     def determine_full_port_name(cls, host, options, port_name):
88         """Return a fully-specified port name that can be used to construct objects."""
89         # Subclasses will usually override this.
90         options = options or {}
91         assert port_name.startswith(cls.port_name)
92         if getattr(options, 'webkit_test_runner', False) and not '-wk2' in port_name:
93             return port_name + '-wk2'
94         return port_name
95
96     def __init__(self, host, port_name, options=None, **kwargs):
97
98         # This value may be different from cls.port_name by having version modifiers
99         # and other fields appended to it (for example, 'mac-wk2' or 'win').
100         self._name = port_name
101
102         # These are default values that should be overridden in a subclasses.
103         self._version = ''
104
105         # FIXME: This can be removed once default architectures for GTK and EFL EWS bots are set.
106         self.did_override_architecture = False
107
108         # FIXME: Ideally we'd have a package-wide way to get a
109         # well-formed options object that had all of the necessary
110         # options defined on it.
111         self._options = options or optparse.Values()
112
113         if self.get_option('architecture'):
114             self.did_override_architecture = True
115         else:
116             self.set_option('architecture', self.DEFAULT_ARCHITECTURE)
117
118         if self._name and '-wk2' in self._name:
119             self._options.webkit_test_runner = True
120
121         self.host = host
122         self._executive = host.executive
123         self._filesystem = host.filesystem
124         self._webkit_finder = WebKitFinder(host.filesystem)
125         self._config = port_config.Config(self._executive, self._filesystem, self.port_name)
126         self.pretty_patch = PrettyPatch(self._executive, self.path_from_webkit_base(), self._filesystem)
127
128         self._helper = None
129         self._http_server = None
130         self._websocket_server = None
131         self._web_platform_test_server = None
132         self._image_differ = None
133         self._server_process_constructor = server_process.ServerProcess  # overridable for testing
134         self._test_runner_process_constructor = server_process.ServerProcess
135
136         if not hasattr(options, 'configuration') or not options.configuration:
137             self.set_option_default('configuration', self.default_configuration())
138         self._test_configuration = None
139         self._reftest_list = {}
140         self._results_directory = None
141         self._root_was_set = hasattr(options, 'root') and options.root
142         self._jhbuild_wrapper = []
143         self._layout_tests_dir = hasattr(options, 'layout_tests_dir') and options.layout_tests_dir and self._filesystem.abspath(options.layout_tests_dir)
144         self._w3c_resource_files = None
145
146     def architecture(self):
147         return self.get_option('architecture')
148
149     def set_architecture(self, arch):
150         self.did_override_architecture = True
151         self.set_option('architecture', arch)
152
153     def additional_drt_flag(self):
154         return []
155
156     def supports_per_test_timeout(self):
157         return True
158
159     def default_pixel_tests(self):
160         # FIXME: Disable until they are run by default on build.webkit.org.
161         return False
162
163     def default_timeout_ms(self):
164         return 30 * 1000
165
166     def driver_stop_timeout(self):
167         """ Returns the amount of time in seconds to wait before killing the process in driver.stop()."""
168         # We want to wait for at least 3 seconds, but if we are really slow, we want to be slow on cleanup as
169         # well (for things like ASAN, Valgrind, etc.)
170         return 3.0 * float(self.get_option('time_out_ms', '0')) / self.default_timeout_ms()
171
172     def should_retry_crashes(self):
173         return False
174
175     def default_child_processes(self):
176         """Return the number of DumpRenderTree instances to use for this port."""
177         return self._executive.cpu_count()
178
179     def worker_startup_delay_secs(self):
180         # FIXME: If we start workers up too quickly, DumpRenderTree appears
181         # to thrash on something and time out its first few tests. Until
182         # we can figure out what's going on, sleep a bit in between
183         # workers. See https://bugs.webkit.org/show_bug.cgi?id=79147 .
184         return 0.1
185
186     def baseline_path(self):
187         """Return the absolute path to the directory to store new baselines in for this port."""
188         # FIXME: remove once all callers are calling either baseline_version_dir() or baseline_platform_dir()
189         return self.baseline_version_dir()
190
191     def baseline_platform_dir(self):
192         """Return the absolute path to the default (version-independent) platform-specific results."""
193         return self._filesystem.join(self.layout_tests_dir(), 'platform', self.port_name)
194
195     def baseline_version_dir(self):
196         """Return the absolute path to the platform-and-version-specific results."""
197         baseline_search_paths = self.baseline_search_path()
198         return baseline_search_paths[0]
199
200     def baseline_search_path(self):
201         return self.get_option('additional_platform_directory', []) + self._compare_baseline() + self.default_baseline_search_path()
202
203     def default_baseline_search_path(self):
204         """Return a list of absolute paths to directories to search under for
205         baselines. The directories are searched in order."""
206         search_paths = []
207         if self.get_option('webkit_test_runner'):
208             search_paths.append(self._wk2_port_name())
209         search_paths.append(self.name())
210         if self.name() != self.port_name:
211             search_paths.append(self.port_name)
212         return map(self._webkit_baseline_path, search_paths)
213
214     @memoized
215     def _compare_baseline(self):
216         factory = PortFactory(self.host)
217         target_port = self.get_option('compare_port')
218         if target_port:
219             return factory.get(target_port).default_baseline_search_path()
220         return []
221
222     def check_build(self, needs_http):
223         """This routine is used to ensure that the build is up to date
224         and all the needed binaries are present."""
225         # If we're using a pre-built copy of WebKit (--root), we assume it also includes a build of DRT.
226         if not self._root_was_set and self.get_option('build') and not self._build_driver():
227             return False
228         if not self._check_driver():
229             return False
230         if self.get_option('pixel_tests'):
231             if not self.check_image_diff():
232                 return False
233         if not self._check_port_build():
234             return False
235         return True
236
237     def _check_driver(self):
238         driver_path = self._path_to_driver()
239         if not self._filesystem.exists(driver_path):
240             _log.error("%s was not found at %s" % (self.driver_name(), driver_path))
241             return False
242         return True
243
244     def _check_port_build(self):
245         # Ports can override this method to do additional checks.
246         return True
247
248     def check_sys_deps(self, needs_http):
249         """If the port needs to do some runtime checks to ensure that the
250         tests can be run successfully, it should override this routine.
251         This step can be skipped with --nocheck-sys-deps.
252
253         Returns whether the system is properly configured."""
254         if needs_http:
255             return self.check_httpd()
256         return True
257
258     def check_image_diff(self, override_step=None, logging=True):
259         """This routine is used to check whether image_diff binary exists."""
260         image_diff_path = self._path_to_image_diff()
261         if not self._filesystem.exists(image_diff_path):
262             _log.error("ImageDiff was not found at %s" % image_diff_path)
263             return False
264         return True
265
266     def check_httpd(self):
267         if self._uses_apache():
268             httpd_path = self._path_to_apache()
269         else:
270             httpd_path = self._path_to_lighttpd()
271
272         try:
273             server_name = self._filesystem.basename(httpd_path)
274             env = self.setup_environ_for_server(server_name)
275             if self._executive.run_command([httpd_path, "-v"], env=env, return_exit_code=True) != 0:
276                 _log.error("httpd seems broken. Cannot run http tests.")
277                 return False
278             return True
279         except OSError:
280             _log.error("No httpd found. Cannot run http tests.")
281             return False
282
283     def do_text_results_differ(self, expected_text, actual_text):
284         return expected_text != actual_text
285
286     def do_audio_results_differ(self, expected_audio, actual_audio):
287         if expected_audio == actual_audio:
288             return False
289         return not WaveDiff(expected_audio, actual_audio).filesAreIdenticalWithinTolerance()
290
291     def diff_image(self, expected_contents, actual_contents, tolerance=None):
292         """Compare two images and return a tuple of an image diff, a percentage difference (0-100), and an error string.
293
294         |tolerance| should be a percentage value (0.0 - 100.0).
295         If it is omitted, the port default tolerance value is used.
296
297         If an error occurs (like ImageDiff isn't found, or crashes, we log an error and return True (for a diff).
298         """
299         if not actual_contents and not expected_contents:
300             return (None, 0, None)
301         if not actual_contents or not expected_contents:
302             return (True, 0, None)
303         if not self._image_differ:
304             self._image_differ = image_diff.ImageDiffer(self)
305         self.set_option_default('tolerance', 0.1)
306         if tolerance is None:
307             tolerance = self.get_option('tolerance')
308         return self._image_differ.diff_image(expected_contents, actual_contents, tolerance)
309
310     def diff_text(self, expected_text, actual_text, expected_filename, actual_filename):
311         """Returns a string containing the diff of the two text strings
312         in 'unified diff' format."""
313
314         # The filenames show up in the diff output, make sure they're
315         # raw bytes and not unicode, so that they don't trigger join()
316         # trying to decode the input.
317         def to_raw_bytes(string_value):
318             if isinstance(string_value, unicode):
319                 return string_value.encode('utf-8')
320             return string_value
321         expected_filename = to_raw_bytes(expected_filename)
322         actual_filename = to_raw_bytes(actual_filename)
323         diff = difflib.unified_diff(expected_text.splitlines(True),
324                                     actual_text.splitlines(True),
325                                     expected_filename,
326                                     actual_filename)
327         result = ""
328         for line in diff:
329             result += line
330             if not line.endswith('\n'):
331                 result += '\n\ No newline at end of file\n'
332         return result
333
334     def check_for_leaks(self, process_name, process_pid):
335         # Subclasses should check for leaks in the running process
336         # and print any necessary warnings if leaks are found.
337         # FIXME: We should consider moving much of this logic into
338         # Executive and make it platform-specific instead of port-specific.
339         pass
340
341     def print_leaks_summary(self):
342         # Subclasses can override this to print a summary of leaks found
343         # while running the layout tests.
344         pass
345
346     def driver_name(self):
347         if self.get_option('driver_name'):
348             return self.get_option('driver_name')
349         if self.get_option('webkit_test_runner'):
350             return 'WebKitTestRunner'
351         return 'DumpRenderTree'
352
353     def expected_baselines_by_extension(self, test_name):
354         """Returns a dict mapping baseline suffix to relative path for each baseline in
355         a test. For reftests, it returns ".==" or ".!=" instead of the suffix."""
356         # FIXME: The name similarity between this and expected_baselines() below, is unfortunate.
357         # We should probably rename them both.
358         baseline_dict = {}
359         reference_files = self.reference_files(test_name)
360         if reference_files:
361             # FIXME: How should this handle more than one type of reftest?
362             baseline_dict['.' + reference_files[0][0]] = self.relative_test_filename(reference_files[0][1])
363
364         for extension in self.baseline_extensions():
365             path = self.expected_filename(test_name, extension, return_default=False)
366             baseline_dict[extension] = self.relative_test_filename(path) if path else path
367
368         return baseline_dict
369
370     def baseline_extensions(self):
371         """Returns a tuple of all of the non-reftest baseline extensions we use. The extensions include the leading '.'."""
372         return ('.wav', '.webarchive', '.txt', '.png')
373
374     def expected_baselines(self, test_name, suffix, all_baselines=False):
375         """Given a test name, finds where the baseline results are located.
376
377         Args:
378         test_name: name of test file (usually a relative path under LayoutTests/)
379         suffix: file suffix of the expected results, including dot; e.g.
380             '.txt' or '.png'.  This should not be None, but may be an empty
381             string.
382         all_baselines: If True, return an ordered list of all baseline paths
383             for the given platform. If False, return only the first one.
384         Returns
385         a list of ( platform_dir, results_filename ), where
386             platform_dir - abs path to the top of the results tree (or test
387                 tree)
388             results_filename - relative path from top of tree to the results
389                 file
390             (port.join() of the two gives you the full path to the file,
391                 unless None was returned.)
392         Return values will be in the format appropriate for the current
393         platform (e.g., "\\" for path separators on Windows). If the results
394         file is not found, then None will be returned for the directory,
395         but the expected relative pathname will still be returned.
396
397         This routine is generic but lives here since it is used in
398         conjunction with the other baseline and filename routines that are
399         platform specific.
400         """
401         baseline_filename = self._filesystem.splitext(test_name)[0] + '-expected' + suffix
402         baseline_search_path = self.baseline_search_path()
403
404         baselines = []
405         for platform_dir in baseline_search_path:
406             if self._filesystem.exists(self._filesystem.join(platform_dir, baseline_filename)):
407                 baselines.append((platform_dir, baseline_filename))
408
409             if not all_baselines and baselines:
410                 return baselines
411
412         # If it wasn't found in a platform directory, return the expected
413         # result in the test directory, even if no such file actually exists.
414         platform_dir = self.layout_tests_dir()
415         if self._filesystem.exists(self._filesystem.join(platform_dir, baseline_filename)):
416             baselines.append((platform_dir, baseline_filename))
417
418         if baselines:
419             return baselines
420
421         return [(None, baseline_filename)]
422
423     def expected_filename(self, test_name, suffix, return_default=True):
424         """Given a test name, returns an absolute path to its expected results.
425
426         If no expected results are found in any of the searched directories,
427         the directory in which the test itself is located will be returned.
428         The return value is in the format appropriate for the platform
429         (e.g., "\\" for path separators on windows).
430
431         Args:
432         test_name: name of test file (usually a relative path under LayoutTests/)
433         suffix: file suffix of the expected results, including dot; e.g. '.txt'
434             or '.png'.  This should not be None, but may be an empty string.
435         platform: the most-specific directory name to use to build the
436             search list of directories; e.g. 'mountainlion-wk2'
437         return_default: if True, returns the path to the generic expectation if nothing
438             else is found; if False, returns None.
439
440         This routine is generic but is implemented here to live alongside
441         the other baseline and filename manipulation routines.
442         """
443         # FIXME: The [0] here is very mysterious, as is the destructured return.
444         platform_dir, baseline_filename = self.expected_baselines(test_name, suffix)[0]
445         if platform_dir:
446             return self._filesystem.join(platform_dir, baseline_filename)
447
448         if return_default:
449             return self._filesystem.join(self.layout_tests_dir(), baseline_filename)
450         return None
451
452     def expected_checksum(self, test_name):
453         """Returns the checksum of the image we expect the test to produce, or None if it is a text-only test."""
454         png_path = self.expected_filename(test_name, '.png')
455
456         if self._filesystem.exists(png_path):
457             with self._filesystem.open_binary_file_for_reading(png_path) as filehandle:
458                 return read_checksum_from_png.read_checksum(filehandle)
459
460         return None
461
462     def expected_image(self, test_name):
463         """Returns the image we expect the test to produce."""
464         baseline_path = self.expected_filename(test_name, '.png')
465         if not self._filesystem.exists(baseline_path):
466             return None
467         return self._filesystem.read_binary_file(baseline_path)
468
469     def expected_audio(self, test_name):
470         baseline_path = self.expected_filename(test_name, '.wav')
471         if not self._filesystem.exists(baseline_path):
472             return None
473         return self._filesystem.read_binary_file(baseline_path)
474
475     def expected_text(self, test_name):
476         """Returns the text output we expect the test to produce, or None
477         if we don't expect there to be any text output.
478         End-of-line characters are normalized to '\n'."""
479         # FIXME: DRT output is actually utf-8, but since we don't decode the
480         # output from DRT (instead treating it as a binary string), we read the
481         # baselines as a binary string, too.
482         baseline_path = self.expected_filename(test_name, '.txt')
483         if not self._filesystem.exists(baseline_path):
484             baseline_path = self.expected_filename(test_name, '.webarchive')
485             if not self._filesystem.exists(baseline_path):
486                 return None
487         text = self._filesystem.read_binary_file(baseline_path)
488         return text.replace("\r\n", "\n")
489
490     def _get_reftest_list(self, test_name):
491         dirname = self._filesystem.join(self.layout_tests_dir(), self._filesystem.dirname(test_name))
492         if dirname not in self._reftest_list:
493             self._reftest_list[dirname] = Port._parse_reftest_list(self._filesystem, dirname)
494         return self._reftest_list[dirname]
495
496     @staticmethod
497     def _parse_reftest_list(filesystem, test_dirpath):
498         reftest_list_path = filesystem.join(test_dirpath, 'reftest.list')
499         if not filesystem.isfile(reftest_list_path):
500             return None
501         reftest_list_file = filesystem.read_text_file(reftest_list_path)
502
503         parsed_list = {}
504         for line in reftest_list_file.split('\n'):
505             line = re.sub('#.+$', '', line)
506             split_line = line.split()
507             if len(split_line) < 3:
508                 continue
509             expectation_type, test_file, ref_file = split_line
510             parsed_list.setdefault(filesystem.join(test_dirpath, test_file), []).append((expectation_type, filesystem.join(test_dirpath, ref_file)))
511         return parsed_list
512
513     def reference_files(self, test_name):
514         """Return a list of expectation (== or !=) and filename pairs"""
515
516         if self.get_option('treat_ref_tests_as_pixel_tests'):
517             return []
518
519         reftest_list = self._get_reftest_list(test_name)
520         if not reftest_list:
521             reftest_list = []
522             for expectation, prefix in (('==', ''), ('!=', '-mismatch')):
523                 for extention in Port._supported_reference_extensions:
524                     path = self.expected_filename(test_name, prefix + extention)
525                     if self._filesystem.exists(path):
526                         reftest_list.append((expectation, path))
527             return reftest_list
528
529         return reftest_list.get(self._filesystem.join(self.layout_tests_dir(), test_name), [])  # pylint: disable=E1103
530
531     def potential_test_names_from_expected_file(self, path):
532         """Return potential test names if any from a potential expected file path, relative to LayoutTests directory."""
533
534         if not '-expected.' in path:
535             return None
536
537         if path.startswith('platform' + self._filesystem.sep):
538             steps = path.split(self._filesystem.sep)
539             path = self._filesystem.join(self._filesystem.sep.join(steps[2:]))
540
541         return [self.host.filesystem.relpath(test, self.layout_tests_dir()) for test in self._filesystem.glob(re.sub('-expected.*', '.*', self._filesystem.join(self.layout_tests_dir(), path))) if self._filesystem.isfile(test)]
542
543     def tests(self, paths):
544         """Return the list of tests found. Both generic and platform-specific tests matching paths should be returned."""
545         expanded_paths = self._expanded_paths(paths)
546         return self._real_tests(expanded_paths)
547
548     def _expanded_paths(self, paths):
549         expanded_paths = []
550         fs = self._filesystem
551         all_platform_dirs = [path for path in fs.glob(fs.join(self.layout_tests_dir(), 'platform', '*')) if fs.isdir(path)]
552         for path in paths:
553             expanded_paths.append(path)
554             if self.test_isdir(path) and not path.startswith('platform') and not fs.isabs(path):
555                 for platform_dir in all_platform_dirs:
556                     if fs.isdir(fs.join(platform_dir, path)) and platform_dir in self.baseline_search_path():
557                         expanded_paths.append(self.relative_test_filename(fs.join(platform_dir, path)))
558
559         return expanded_paths
560
561     def _real_tests(self, paths):
562         # When collecting test cases, skip these directories
563         skipped_directories = set(['.svn', '_svn', 'resources', 'support', 'script-tests', 'reference', 'reftest'])
564         files = find_files.find(self._filesystem, self.layout_tests_dir(), paths, skipped_directories, partial(Port._is_test_file, self), self.test_key)
565         return [self.relative_test_filename(f) for f in files]
566
567     # When collecting test cases, we include any file with these extensions.
568     _supported_test_extensions = set(['.html', '.shtml', '.xml', '.xhtml', '.pl', '.htm', '.php', '.svg', '.mht', '.xht'])
569     _supported_reference_extensions = set(['.html', '.xml', '.xhtml', '.htm', '.svg', '.xht'])
570
571     def is_w3c_resource_file(self, filesystem, dirname, filename):
572         path = filesystem.join(dirname, filename)
573         w3c_path = filesystem.join(self.layout_tests_dir(), "imported", "w3c")
574         if not w3c_path in path:
575             return False
576
577         if not self._w3c_resource_files:
578             filepath = filesystem.join(w3c_path, "resources", "resource-files.json")
579             json_data = filesystem.read_text_file(filepath)
580             self._w3c_resource_files = json.loads(json_data)
581
582         subpath = path[len(w3c_path) + 1:].replace('\\', '/')
583         if subpath in self._w3c_resource_files["files"]:
584             return True
585         for dirpath in self._w3c_resource_files["directories"]:
586             if dirpath in subpath:
587                 return True
588         return False
589
590     @staticmethod
591     # If any changes are made here be sure to update the isUsedInReftest method in old-run-webkit-tests as well.
592     def is_reference_html_file(filesystem, dirname, filename):
593         if filename.startswith('ref-') or filename.startswith('notref-'):
594             return True
595         filename_wihout_ext, ext = filesystem.splitext(filename)
596         if ext not in Port._supported_reference_extensions:
597             return False
598         for suffix in ['-expected', '-expected-mismatch', '-ref', '-notref']:
599             if filename_wihout_ext.endswith(suffix):
600                 return True
601         return False
602
603     @staticmethod
604     def _has_supported_extension(filesystem, filename):
605         """Return true if filename is one of the file extensions we want to run a test on."""
606         extension = filesystem.splitext(filename)[1]
607         return extension in Port._supported_test_extensions
608
609     def _is_test_file(self, filesystem, dirname, filename):
610         if not Port._has_supported_extension(filesystem, filename):
611             return False
612         if Port.is_reference_html_file(filesystem, dirname, filename):
613             return False
614         if self.is_w3c_resource_file(filesystem, dirname, filename):
615             return False
616         return True
617
618     def test_key(self, test_name):
619         """Turns a test name into a list with two sublists, the natural key of the
620         dirname, and the natural key of the basename.
621
622         This can be used when sorting paths so that files in a directory.
623         directory are kept together rather than being mixed in with files in
624         subdirectories."""
625         dirname, basename = self.split_test(test_name)
626         return (self._natural_sort_key(dirname + self.TEST_PATH_SEPARATOR), self._natural_sort_key(basename))
627
628     def _natural_sort_key(self, string_to_split):
629         """ Turns a string into a list of string and number chunks, i.e. "z23a" -> ["z", 23, "a"]
630
631         This can be used to implement "natural sort" order. See:
632         http://www.codinghorror.com/blog/2007/12/sorting-for-humans-natural-sort-order.html
633         http://nedbatchelder.com/blog/200712.html#e20071211T054956
634         """
635         def tryint(val):
636             try:
637                 return int(val)
638             except ValueError:
639                 return val
640
641         return [tryint(chunk) for chunk in re.split('(\d+)', string_to_split)]
642
643     def test_dirs(self):
644         """Returns the list of top-level test directories."""
645         layout_tests_dir = self.layout_tests_dir()
646         return filter(lambda x: self._filesystem.isdir(self._filesystem.join(layout_tests_dir, x)),
647                       self._filesystem.listdir(layout_tests_dir))
648
649     @memoized
650     def test_isfile(self, test_name):
651         """Return True if the test name refers to a directory of tests."""
652         # Used by test_expectations.py to apply rules to whole directories.
653         return self._filesystem.isfile(self.abspath_for_test(test_name))
654
655     @memoized
656     def test_isdir(self, test_name):
657         """Return True if the test name refers to a directory of tests."""
658         # Used by test_expectations.py to apply rules to whole directories.
659         return self._filesystem.isdir(self.abspath_for_test(test_name))
660
661     @memoized
662     def test_exists(self, test_name):
663         """Return True if the test name refers to an existing test or baseline."""
664         # Used by test_expectations.py to determine if an entry refers to a
665         # valid test and by printing.py to determine if baselines exist.
666         return self.test_isfile(test_name) or self.test_isdir(test_name)
667
668     def split_test(self, test_name):
669         """Splits a test name into the 'directory' part and the 'basename' part."""
670         index = test_name.rfind(self.TEST_PATH_SEPARATOR)
671         if index < 1:
672             return ('', test_name)
673         return (test_name[0:index], test_name[index:])
674
675     def normalize_test_name(self, test_name):
676         """Returns a normalized version of the test name or test directory."""
677         if test_name.endswith('/'):
678             return test_name
679         if self.test_isdir(test_name):
680             return test_name + '/'
681         return test_name
682
683     def driver_cmd_line_for_logging(self):
684         """Prints the DRT command line that will be used."""
685         driver = self.create_driver(0)
686         return driver.cmd_line(self.get_option('pixel_tests'), [])
687
688     def update_baseline(self, baseline_path, data):
689         """Updates the baseline for a test.
690
691         Args:
692             baseline_path: the actual path to use for baseline, not the path to
693               the test. This function is used to update either generic or
694               platform-specific baselines, but we can't infer which here.
695             data: contents of the baseline.
696         """
697         self._filesystem.write_binary_file(baseline_path, data)
698
699     # FIXME: update callers to create a finder and call it instead of these next five routines (which should be protected).
700     def webkit_base(self):
701         return self._webkit_finder.webkit_base()
702
703     def path_from_webkit_base(self, *comps):
704         return self._webkit_finder.path_from_webkit_base(*comps)
705
706     def path_to_script(self, script_name):
707         return self._webkit_finder.path_to_script(script_name)
708
709     def layout_tests_dir(self):
710         if self._layout_tests_dir:
711             return self._layout_tests_dir
712         return self._webkit_finder.layout_tests_dir()
713
714     def perf_tests_dir(self):
715         return self._webkit_finder.perf_tests_dir()
716
717     def skipped_layout_tests(self, test_list):
718         """Returns tests skipped outside of the TestExpectations files."""
719         return set(self._tests_for_other_platforms()).union(self._skipped_tests_for_unsupported_features(test_list))
720
721     @memoized
722     def skipped_perf_tests(self):
723         filename = self._filesystem.join(self.perf_tests_dir(), "Skipped")
724         if not self._filesystem.exists(filename):
725             _log.debug("Skipped does not exist: %s" % filename)
726             return []
727
728         skipped_file_contents = self._filesystem.read_text_file(filename)
729         tests_to_skip = []
730         for line_number, line in enumerate(skipped_file_contents.split('\n')):
731             match = re.match(r'^\s*(\[(?P<platforms>[\w ]*?)\])?\s*(?P<test>[\w\-\/\.]+?)?\s*(?P<comment>\#.*)?$', line)
732             if not match:
733                 _log.error("Syntax error at line %d in %s: %s" % (line_number + 1, filename, line))
734             else:
735                 platform_names = filter(lambda token: token, match.group('platforms').lower().split(' ')) if match.group('platforms') else []
736                 test_name = match.group('test')
737                 if test_name and (not platform_names or self.port_name in platform_names or self._name in platform_names):
738                     tests_to_skip.append(test_name)
739
740         return tests_to_skip
741
742     def skips_perf_test(self, test_name):
743         for test_or_category in self.skipped_perf_tests():
744             if test_or_category == test_name:
745                 return True
746             category = self._filesystem.join(self.perf_tests_dir(), test_or_category)
747             if self._filesystem.isdir(category) and test_name.startswith(test_or_category):
748                 return True
749         return False
750
751     def name(self):
752         """Returns a name that uniquely identifies this particular type of port
753         (e.g., "mac-snowleopard" or "chromium-linux-x86_x64" and can be passed
754         to factory.get() to instantiate the port."""
755         return self._name
756
757     def operating_system(self):
758         # Subclasses should override this default implementation.
759         return 'mac'
760
761     def version(self):
762         """Returns a string indicating the version of a given platform, e.g.
763         'leopard' or 'xp'.
764
765         This is used to help identify the exact port when parsing test
766         expectations, determining search paths, and logging information."""
767         return self._version
768
769     def get_option(self, name, default_value=None):
770         return getattr(self._options, name, default_value)
771
772     def set_option(self, name, value):
773         setattr(self._options, name, value)
774         return self.get_option(name) == value
775
776     def set_option_default(self, name, default_value):
777         return self._options.ensure_value(name, default_value)
778
779     @memoized
780     def path_to_generic_test_expectations_file(self):
781         return self._filesystem.join(self.layout_tests_dir(), 'TestExpectations')
782
783     @memoized
784     def path_to_test_expectations_file(self):
785         """Update the test expectations to the passed-in string.
786
787         This is used by the rebaselining tool. Raises NotImplementedError
788         if the port does not use expectations files."""
789
790         # FIXME: We need to remove this when we make rebaselining work with multiple files and just generalize expectations_files().
791
792         # test_expectations are always in mac/ not mac-leopard/ by convention, hence we use port_name instead of name().
793         return self._filesystem.join(self._webkit_baseline_path(self.port_name), 'TestExpectations')
794
795     def relative_test_filename(self, filename):
796         """Returns a test_name a relative unix-style path for a filename under the LayoutTests
797         directory. Ports may legitimately return abspaths here if no relpath makes sense."""
798         # Ports that run on windows need to override this method to deal with
799         # filenames with backslashes in them.
800         if filename.startswith(self.layout_tests_dir()):
801             return self.host.filesystem.relpath(filename, self.layout_tests_dir())
802         else:
803             return self.host.filesystem.abspath(filename)
804
805     @memoized
806     def abspath_for_test(self, test_name):
807         """Returns the full path to the file for a given test name. This is the
808         inverse of relative_test_filename()."""
809         return self._filesystem.join(self.layout_tests_dir(), test_name)
810
811     def results_directory(self):
812         """Absolute path to the place to store the test results (uses --results-directory)."""
813         if not self._results_directory:
814             option_val = self.get_option('results_directory') or self.default_results_directory()
815             self._results_directory = self._filesystem.abspath(option_val)
816         return self._results_directory
817
818     def perf_results_directory(self):
819         return self._build_path()
820
821     def python_unittest_results_directory(self):
822         return self._build_path('python-unittest-results')
823
824     def default_results_directory(self):
825         """Absolute path to the default place to store the test results."""
826         # Results are store relative to the built products to make it easy
827         # to have multiple copies of webkit checked out and built.
828         return self._build_path('layout-test-results')
829
830     def setup_test_run(self, device_class=None):
831         """Perform port-specific work at the beginning of a test run."""
832         pass
833
834     def clean_up_test_run(self):
835         """Perform port-specific work at the end of a test run."""
836         if self._image_differ:
837             self._image_differ.stop()
838             self._image_differ = None
839
840     # FIXME: os.environ access should be moved to onto a common/system class to be more easily mockable.
841     def _value_or_default_from_environ(self, name, default=None):
842         if name in os.environ:
843             return os.environ[name]
844         return default
845
846     def _copy_value_from_environ_if_set(self, clean_env, name):
847         if name in os.environ:
848             clean_env[name] = os.environ[name]
849
850     def setup_environ_for_server(self, server_name=None):
851         # We intentionally copy only a subset of os.environ when
852         # launching subprocesses to ensure consistent test results.
853         clean_env = {}
854         variables_to_copy = [
855             # For Linux:
856             'ALSA_CARD',
857             'DBUS_SESSION_BUS_ADDRESS',
858             'HOME',
859             'LANG',
860             'LD_LIBRARY_PATH',
861             'XAUTHORITY',
862             'XDG_DATA_DIRS',
863             'XDG_RUNTIME_DIR',
864
865             # Darwin:
866             'DYLD_FRAMEWORK_PATH',
867             'DYLD_LIBRARY_PATH',
868             'HOME',
869             '__XPC_DYLD_FRAMEWORK_PATH',
870             '__XPC_DYLD_LIBRARY_PATH',
871
872             # CYGWIN:
873             'HOMEDRIVE',
874             'HOMEPATH',
875             '_NT_SYMBOL_PATH',
876
877             # Windows:
878             'COMSPEC',
879             'PATH',
880             'SYSTEMDRIVE',
881             'SYSTEMROOT',
882             'WEBKIT_LIBRARIES',
883
884             # Most ports (?):
885             'WEBKIT_TESTFONTS',
886             'WEBKIT_OUTPUTDIR',
887
888         ]
889         for variable in variables_to_copy:
890             self._copy_value_from_environ_if_set(clean_env, variable)
891
892         # For Linux:
893         clean_env['DISPLAY'] = self._value_or_default_from_environ('DISPLAY', ':1')
894
895         for string_variable in self.get_option('additional_env_var', []):
896             [name, value] = string_variable.split('=', 1)
897             clean_env[name] = value
898
899         return clean_env
900
901     def _clear_global_caches_and_temporary_files(self):
902         pass
903
904     @staticmethod
905     def _append_value_colon_separated(env, name, value):
906         assert ":" not in value
907         if name in env and env[name]:
908             env[name] = env[name] + ":" + value
909         else:
910             env[name] = value
911
912     def show_results_html_file(self, results_filename):
913         """This routine should display the HTML file pointed at by
914         results_filename in a users' browser."""
915         return self.host.user.open_url(path.abspath_to_uri(self.host.platform, results_filename))
916
917     def create_driver(self, worker_number, no_timeout=False):
918         """Return a newly created Driver subclass for starting/stopping the test driver."""
919         return driver.DriverProxy(self, worker_number, self._driver_class(), pixel_tests=self.get_option('pixel_tests'), no_timeout=no_timeout)
920
921     def start_helper(self, pixel_tests=False):
922         """If a port needs to reconfigure graphics settings or do other
923         things to ensure a known test configuration, it should override this
924         method."""
925         return True
926
927     def reset_preferences(self):
928         """If a port needs to reset platform-specific persistent preference
929         storage, it should override this method."""
930         pass
931
932     def start_http_server(self, additional_dirs=None):
933         """Start a web server. Raise an error if it can't start or is already running.
934
935         Ports can stub this out if they don't need a web server to be running."""
936         assert not self._http_server, 'Already running an http server.'
937         http_port = self.get_option('http_port')
938         if self._uses_apache():
939             server = apache_http_server.LayoutTestApacheHttpd(self, self.results_directory(), additional_dirs=additional_dirs, port=http_port)
940         else:
941             server = http_server.Lighttpd(self, self.results_directory(), additional_dirs=additional_dirs, port=http_port)
942
943         server.start()
944         self._http_server = server
945
946     def _extract_certificate_from_pem(self, pem_file, destination_certificate_file):
947         return self._executive.run_command(['openssl', 'x509', '-outform', 'pem', '-in', pem_file, '-out', destination_certificate_file], return_exit_code=True) == 0
948
949     def _extract_private_key_from_pem(self, pem_file, destination_private_key_file):
950         return self._executive.run_command(['openssl', 'rsa', '-in', pem_file, '-out', destination_private_key_file], return_exit_code=True) == 0
951
952     def start_websocket_server(self):
953         """Start a web server. Raise an error if it can't start or is already running.
954
955         Ports can stub this out if they don't need a websocket server to be running."""
956         assert not self._websocket_server, 'Already running a websocket server.'
957
958         server = websocket_server.PyWebSocket(self, self.results_directory())
959         server.start()
960         self._websocket_server = server
961
962         pem_file = self._filesystem.join(self.layout_tests_dir(), "http", "conf", "webkit-httpd.pem")
963         websocket_server_temporary_directory = self._filesystem.mkdtemp(prefix='webkitpy-websocket-server')
964         certificate_file = self._filesystem.join(str(websocket_server_temporary_directory), 'webkit-httpd.crt')
965         private_key_file = self._filesystem.join(str(websocket_server_temporary_directory), 'webkit-httpd.key')
966         self._websocket_server_temporary_directory = websocket_server_temporary_directory
967         if self._extract_certificate_from_pem(pem_file, certificate_file) and self._extract_private_key_from_pem(pem_file, private_key_file):
968             secure_server = self._websocket_secure_server = websocket_server.PyWebSocket(self, self.results_directory(),
969                                 use_tls=True, port=9323, private_key=private_key_file, certificate=certificate_file)
970             secure_server.start()
971             self._websocket_secure_server = secure_server
972
973     def start_web_platform_test_server(self, additional_dirs=None, number_of_servers=None):
974         assert not self._web_platform_test_server, 'Already running a Web Platform Test server.'
975
976         self._web_platform_test_server = web_platform_test_server.WebPlatformTestServer(self, "wptwk")
977         self._web_platform_test_server.start()
978
979     def web_platform_test_server_doc_root(self):
980         return web_platform_test_server.doc_root(self) + self.TEST_PATH_SEPARATOR
981
982     def web_platform_test_server_base_url(self):
983         return web_platform_test_server.base_url(self)
984
985     def http_server_supports_ipv6(self):
986         # Cygwin is the only platform to still use Apache 1.3, which only supports IPV4.
987         # Once it moves to Apache 2, we can drop this method altogether.
988         if self.host.platform.is_cygwin():
989             return False
990         return True
991
992     def stop_helper(self):
993         """Shut down the test helper if it is running. Do nothing if
994         it isn't, or it isn't available. If a port overrides start_helper()
995         it must override this routine as well."""
996         pass
997
998     def stop_http_server(self):
999         """Shut down the http server if it is running. Do nothing if it isn't."""
1000         if self._http_server:
1001             self._http_server.stop()
1002             self._http_server = None
1003
1004     def stop_websocket_server(self):
1005         """Shut down the websocket server if it is running. Do nothing if it isn't."""
1006         if self._websocket_server:
1007             self._websocket_server.stop()
1008             self._websocket_server = None
1009         if self._websocket_secure_server:
1010             self._websocket_secure_server.stop()
1011             self._websocket_secure_server = None
1012         if self._websocket_server_temporary_directory:
1013             self._filesystem.rmtree(str(self._websocket_server_temporary_directory))
1014
1015     def stop_web_platform_test_server(self):
1016         if self._web_platform_test_server:
1017             self._web_platform_test_server.stop()
1018             self._web_platform_test_server = None
1019
1020     def exit_code_from_summarized_results(self, unexpected_results):
1021         """Given summarized results, compute the exit code to be returned by new-run-webkit-tests.
1022         Bots turn red when this function returns a non-zero value. By default, return the number of regressions
1023         to avoid turning bots red by flaky failures, unexpected passes, and missing results"""
1024         # Don't turn bots red for flaky failures, unexpected passes, and missing results.
1025         return unexpected_results['num_regressions']
1026
1027     #
1028     # TEST EXPECTATION-RELATED METHODS
1029     #
1030
1031     def test_configuration(self):
1032         """Returns the current TestConfiguration for the port."""
1033         if not self._test_configuration:
1034             self._test_configuration = TestConfiguration(self._version, self.architecture(), self._options.configuration.lower())
1035         return self._test_configuration
1036
1037     # FIXME: Belongs on a Platform object.
1038     @memoized
1039     def all_test_configurations(self):
1040         """Returns a list of TestConfiguration instances, representing all available
1041         test configurations for this port."""
1042         return self._generate_all_test_configurations()
1043
1044     # FIXME: Belongs on a Platform object.
1045     def configuration_specifier_macros(self):
1046         """Ports may provide a way to abbreviate configuration specifiers to conveniently
1047         refer to them as one term or alias specific values to more generic ones. For example:
1048
1049         (xp, vista, win7) -> win # Abbreviate all Windows versions into one namesake.
1050         (lucid) -> linux  # Change specific name of the Linux distro to a more generic term.
1051
1052         Returns a dictionary, each key representing a macro term ('win', for example),
1053         and value being a list of valid configuration specifiers (such as ['xp', 'vista', 'win7'])."""
1054         return {}
1055
1056     def all_baseline_variants(self):
1057         """Returns a list of platform names sufficient to cover all the baselines.
1058
1059         The list should be sorted so that a later platform  will reuse
1060         an earlier platform's baselines if they are the same (e.g.,
1061         'snowleopard' should precede 'leopard')."""
1062         raise NotImplementedError
1063
1064     def uses_test_expectations_file(self):
1065         # This is different from checking test_expectations() is None, because
1066         # some ports have Skipped files which are returned as part of test_expectations().
1067         return self._filesystem.exists(self.path_to_test_expectations_file())
1068
1069     def warn_if_bug_missing_in_test_expectations(self):
1070         return False
1071
1072     def expectations_dict(self):
1073         """Returns an OrderedDict of name -> expectations strings.
1074         The names are expected to be (but not required to be) paths in the filesystem.
1075         If the name is a path, the file can be considered updatable for things like rebaselining,
1076         so don't use names that are paths if they're not paths.
1077         Generally speaking the ordering should be files in the filesystem in cascade order
1078         (TestExpectations followed by Skipped, if the port honors both formats),
1079         then any built-in expectations (e.g., from compile-time exclusions), then --additional-expectations options."""
1080         # FIXME: rename this to test_expectations() once all the callers are updated to know about the ordered dict.
1081         expectations = OrderedDict()
1082
1083         for path in self.expectations_files():
1084             if self._filesystem.exists(path):
1085                 expectations[path] = self._filesystem.read_text_file(path)
1086
1087         for path in self.get_option('additional_expectations', []):
1088             expanded_path = self._filesystem.expanduser(path)
1089             if self._filesystem.exists(expanded_path):
1090                 _log.debug("reading additional_expectations from path '%s'" % path)
1091                 expectations[path] = self._filesystem.read_text_file(expanded_path)
1092             else:
1093                 _log.warning("additional_expectations path '%s' does not exist" % path)
1094         return expectations
1095
1096     def _port_specific_expectations_files(self):
1097         # Unlike baseline_search_path, we only want to search [WK2-PORT, PORT-VERSION, PORT] and any directories
1098         # included via --additional-platform-directory, not the full casade.
1099         search_paths = [self.port_name]
1100
1101         non_wk2_name = self.name().replace('-wk2', '')
1102         if non_wk2_name != self.port_name:
1103             search_paths.append(non_wk2_name)
1104
1105         if self.get_option('webkit_test_runner'):
1106             # Because nearly all of the skipped tests for WebKit 2 are due to cross-platform
1107             # issues, all wk2 ports share a skipped list under platform/wk2.
1108             search_paths.extend(["wk2", self._wk2_port_name()])
1109
1110         search_paths.extend(self.get_option("additional_platform_directory", []))
1111
1112         return [self._filesystem.join(self._webkit_baseline_path(d), 'TestExpectations') for d in search_paths]
1113
1114     def expectations_files(self):
1115         return [self.path_to_generic_test_expectations_file()] + self._port_specific_expectations_files()
1116
1117     def repository_paths(self):
1118         """Returns a list of (repository_name, repository_path) tuples of its depending code base.
1119         By default it returns a list that only contains a ('WebKit', <webkitRepositoryPath>) tuple."""
1120
1121         # We use LayoutTest directory here because webkit_base isn't a part of WebKit repository in Chromium port
1122         # where turnk isn't checked out as a whole.
1123         repository_paths = [('WebKit', self.layout_tests_dir())]
1124         if self.get_option('additional_repository_name') and self.get_option('additional_repository_path'):
1125             repository_paths += [(self._options.additional_repository_name, self._options.additional_repository_path)]
1126         return repository_paths
1127
1128     def allowed_hosts(self):
1129         return self.get_option("allowed_host", [])
1130
1131     def default_configuration(self):
1132         return self._config.default_configuration()
1133
1134     #
1135     # PROTECTED ROUTINES
1136     #
1137     # The routines below should only be called by routines in this class
1138     # or any of its subclasses.
1139     #
1140
1141     def _uses_apache(self):
1142         return True
1143
1144     # FIXME: This does not belong on the port object.
1145     @memoized
1146     def _path_to_apache(self):
1147         """Returns the full path to the apache binary.
1148
1149         This is needed only by ports that use the apache_http_server module."""
1150         # The Apache binary path can vary depending on OS and distribution
1151         # See http://wiki.apache.org/httpd/DistrosDefaultLayout
1152         for path in ["/usr/sbin/httpd", "/usr/sbin/apache2"]:
1153             if self._filesystem.exists(path):
1154                 return path
1155         _log.error("Could not find apache. Not installed or unknown path.")
1156         return None
1157
1158     def _is_fedora_php_version_7(self):
1159         if self._filesystem.exists("/etc/httpd/modules/libphp7.so"):
1160             return True
1161         return False
1162
1163     def _is_debian_php_version_7(self):
1164         if self._filesystem.exists("/usr/lib/apache2/modules/libphp7.0.so"):
1165             return True
1166         return False
1167
1168     def _is_darwin_php_version_7(self):
1169         if self._filesystem.exists("/usr/libexec/apache2/libphp7.so"):
1170             return True
1171         return False
1172
1173     # FIXME: This belongs on some platform abstraction instead of Port.
1174     def _is_redhat_based(self):
1175         return self._filesystem.exists('/etc/redhat-release')
1176
1177     def _is_debian_based(self):
1178         return self._filesystem.exists('/etc/debian_version')
1179
1180     def _is_arch_based(self):
1181         return self._filesystem.exists('/etc/arch-release')
1182
1183     def _apache_version(self):
1184         config = self._executive.run_command([self._path_to_apache(), '-v'])
1185         return re.sub(r'(?:.|\n)*Server version: Apache/(\d+\.\d+)(?:.|\n)*', r'\1', config)
1186
1187     def _debian_php_version(self):
1188         if self._is_debian_php_version_7():
1189             return "-php7"
1190         return ""
1191
1192     def _darwin_php_version(self):
1193         if self._is_darwin_php_version_7():
1194             return "-php7"
1195         return ""
1196
1197     def _fedora_php_version(self):
1198         if self._is_fedora_php_version_7():
1199             return "-php7"
1200         return ""
1201
1202     # We pass sys_platform into this method to make it easy to unit test.
1203     def _apache_config_file_name_for_platform(self, sys_platform):
1204         if sys_platform == 'cygwin' or sys_platform.startswith('win'):
1205             return 'apache' + self._apache_version() + '-httpd-win.conf'
1206         if sys_platform == 'darwin':
1207             return 'apache' + self._apache_version() + self._darwin_php_version() + '-httpd.conf'
1208         if sys_platform.startswith('linux'):
1209             if self._is_redhat_based():
1210                 return 'fedora-httpd-' + self._apache_version() + self._fedora_php_version() + '.conf'
1211             if self._is_debian_based():
1212                 return 'debian-httpd-' + self._apache_version() + self._debian_php_version() + '.conf'
1213             if self._is_arch_based():
1214                 return 'archlinux-httpd.conf'
1215         # All platforms use apache2 except for CYGWIN (and Mac OS X Tiger and prior, which we no longer support).
1216         return 'apache' + self._apache_version() + '-httpd.conf'
1217
1218     def _path_to_apache_config_file(self):
1219         """Returns the full path to the apache configuration file.
1220
1221         If the WEBKIT_HTTP_SERVER_CONF_PATH environment variable is set, its
1222         contents will be used instead.
1223
1224         This is needed only by ports that use the apache_http_server module."""
1225         config_file_from_env = os.environ.get('WEBKIT_HTTP_SERVER_CONF_PATH')
1226         if config_file_from_env:
1227             if not self._filesystem.exists(config_file_from_env):
1228                 raise IOError('%s was not found on the system' % config_file_from_env)
1229             return config_file_from_env
1230
1231         config_file_name = self._apache_config_file_name_for_platform(sys.platform)
1232         return self._filesystem.join(self.layout_tests_dir(), 'http', 'conf', config_file_name)
1233
1234     def _build_path(self, *comps):
1235         root_directory = self.get_option('_cached_root') or self.get_option('root')
1236         if not root_directory:
1237             build_directory = self.get_option('build_directory')
1238             if build_directory:
1239                 root_directory = self._filesystem.join(build_directory, self.get_option('configuration'))
1240             else:
1241                 root_directory = self._config.build_directory(self.get_option('configuration'))
1242             # We take advantage of the behavior that self._options is passed by reference to worker
1243             # subprocesses to use it as data store to cache the computed root directory path. This
1244             # avoids making each worker subprocess compute this path again which is slow because of
1245             # the call to config.build_directory().
1246             #
1247             # FIXME: This is like decorating this function with @memoized, but more annoying and fragile;
1248             # there should be another way to propagate precomputed values to workers without modifying
1249             # the options list.
1250             self.set_option('_cached_root', root_directory)
1251
1252         if sys.platform.startswith('win') or sys.platform == 'cygwin':
1253             return self._filesystem.join(root_directory, *comps)
1254
1255         return self._filesystem.join(self._filesystem.abspath(root_directory), *comps)
1256
1257     def _path_to_driver(self, configuration=None):
1258         """Returns the full path to the test driver (DumpRenderTree)."""
1259         local_driver_path = self._build_path(self.driver_name())
1260         if sys.platform.startswith('win'):
1261             base = os.path.splitext(local_driver_path)[0]
1262             local_driver_path = base + ".exe"
1263         return local_driver_path
1264
1265     def _driver_tempdir(self):
1266         return self._filesystem.mkdtemp(prefix='%s-' % self.driver_name())
1267
1268     def _path_to_user_cache_directory(self, suffix=None):
1269         return None
1270
1271     def _path_to_webcore_library(self):
1272         """Returns the full path to a built copy of WebCore."""
1273         return None
1274
1275     def _path_to_helper(self):
1276         """Returns the full path to the layout_test_helper binary, which
1277         is used to help configure the system for the test run, or None
1278         if no helper is needed.
1279
1280         This is likely only used by start/stop_helper()."""
1281         return None
1282
1283     def _path_to_image_diff(self):
1284         """Returns the full path to the image_diff binary, or None if it is not available.
1285
1286         This is likely used only by diff_image()"""
1287         return self._build_path('ImageDiff')
1288
1289     def _path_to_lighttpd(self):
1290         """Returns the path to the LigHTTPd binary.
1291
1292         This is needed only by ports that use the http_server.py module."""
1293         raise NotImplementedError('Port._path_to_lighttpd')
1294
1295     def _path_to_lighttpd_modules(self):
1296         """Returns the path to the LigHTTPd modules directory.
1297
1298         This is needed only by ports that use the http_server.py module."""
1299         raise NotImplementedError('Port._path_to_lighttpd_modules')
1300
1301     def _path_to_lighttpd_php(self):
1302         """Returns the path to the LigHTTPd PHP executable.
1303
1304         This is needed only by ports that use the http_server.py module."""
1305         raise NotImplementedError('Port._path_to_lighttpd_php')
1306
1307     def _webkit_baseline_path(self, platform):
1308         """Return the  full path to the top of the baseline tree for a
1309         given platform."""
1310         return self._filesystem.join(self.layout_tests_dir(), 'platform', platform)
1311
1312     # FIXME: Belongs on a Platform object.
1313     def _generate_all_test_configurations(self):
1314         """Generates a list of TestConfiguration instances, representing configurations
1315         for a platform across all OSes, architectures, build and graphics types."""
1316         raise NotImplementedError('Port._generate_test_configurations')
1317
1318     def _driver_class(self):
1319         """Returns the port's driver implementation."""
1320         return driver.Driver
1321
1322     def _get_crash_log(self, name, pid, stdout, stderr, newer_than):
1323         name_str = name or '<unknown process name>'
1324         pid_str = str(pid or '<unknown>')
1325         stdout_lines = (stdout or '<empty>').decode('utf8', 'replace').splitlines()
1326         stderr_lines = (stderr or '<empty>').decode('utf8', 'replace').splitlines()
1327         return (stderr, 'crash log for %s (pid %s):\n%s\n%s\n' % (name_str, pid_str,
1328             '\n'.join(('STDOUT: ' + l) for l in stdout_lines),
1329             '\n'.join(('STDERR: ' + l) for l in stderr_lines)))
1330
1331     def look_for_new_crash_logs(self, crashed_processes, start_time):
1332         pass
1333
1334     def look_for_new_samples(self, unresponsive_processes, start_time):
1335         pass
1336
1337     def sample_process(self, name, pid):
1338         pass
1339
1340     def find_system_pid(self, name, pid):
1341         # This is only overridden on Windows
1342         return pid
1343
1344     def should_run_as_pixel_test(self, test_input):
1345         if not self._options.pixel_tests:
1346             return False
1347         if self._options.pixel_test_directories:
1348             return any(test_input.test_name.startswith(directory) for directory in self._options.pixel_test_directories)
1349         return self._should_run_as_pixel_test(test_input)
1350
1351     def _should_run_as_pixel_test(self, test_input):
1352         # Default behavior is to allow all test to run as pixel tests if --pixel-tests is on and
1353         # --pixel-test-directory is not specified.
1354         return True
1355
1356     def _should_use_jhbuild(self):
1357         suffix = ""
1358         if self.port_name:
1359             suffix = self.port_name.upper()
1360         return os.path.exists(self.path_from_webkit_base('WebKitBuild', 'Dependencies%s' % suffix))
1361
1362     # FIXME: Eventually we should standarize port naming, and make this method smart enough
1363     # to use for all port configurations (including architectures, graphics types, etc).
1364     def _port_flag_for_scripts(self):
1365         # This is overrriden by ports which need a flag passed to scripts to distinguish the use of that port.
1366         return None
1367
1368     # This is modeled after webkitdirs.pm argumentsForConfiguration() from old-run-webkit-tests
1369     def _arguments_for_configuration(self):
1370         config_args = []
1371         config_args.append(self._config.flag_for_configuration(self.get_option('configuration')))
1372         # FIXME: We may need to add support for passing --32-bit like old-run-webkit-tests had.
1373         port_flag = self._port_flag_for_scripts()
1374         if port_flag:
1375             config_args.append(port_flag)
1376         return config_args
1377
1378     def _run_script(self, script_name, args=None, include_configuration_arguments=True, decode_output=True, env=None):
1379         run_script_command = [self.path_to_script(script_name)]
1380         if include_configuration_arguments:
1381             run_script_command.extend(self._arguments_for_configuration())
1382         if args:
1383             run_script_command.extend(args)
1384         output = self._executive.run_command(run_script_command, cwd=self.webkit_base(), decode_output=decode_output, env=env)
1385         _log.debug('Output of %s:\n%s' % (run_script_command, output))
1386         return output
1387
1388     def _build_driver(self):
1389         environment = self.host.copy_current_environment()
1390         environment.disable_gcc_smartquotes()
1391         env = environment.to_dictionary()
1392
1393         # FIXME: We build both DumpRenderTree and WebKitTestRunner for WebKitTestRunner runs because
1394         # DumpRenderTree includes TestNetscapePlugin. It should be factored out into its own project.
1395         try:
1396             self._run_script("build-dumprendertree", args=self._build_driver_flags(), env=env)
1397             if self.get_option('webkit_test_runner'):
1398                 self._run_script("build-webkittestrunner", args=self._build_driver_flags(), env=env)
1399         except ScriptError, e:
1400             _log.error(e.message_with_output(output_limit=None))
1401             return False
1402         return True
1403
1404     def _build_driver_flags(self):
1405         return []
1406
1407     def test_search_path(self):
1408         return self.baseline_search_path()
1409
1410     def _tests_for_other_platforms(self):
1411         # By default we will skip any directory under LayoutTests/platform
1412         # that isn't in our baseline search path (this mirrors what
1413         # old-run-webkit-tests does in findTestsToRun()).
1414         # Note this returns LayoutTests/platform/*, not platform/*/*.
1415         entries = self._filesystem.glob(self._webkit_baseline_path('*'))
1416         dirs_to_skip = []
1417         for entry in entries:
1418             if self._filesystem.isdir(entry) and entry not in self.test_search_path():
1419                 basename = self._filesystem.basename(entry)
1420                 dirs_to_skip.append('platform/%s' % basename)
1421         return dirs_to_skip
1422
1423     def _runtime_feature_list(self):
1424         """If a port makes certain features available only through runtime flags, it can override this routine to indicate which ones are available."""
1425         return None
1426
1427     def nm_command(self):
1428         return 'nm'
1429
1430     def _modules_to_search_for_symbols(self):
1431         path = self._path_to_webcore_library()
1432         if path:
1433             return [path]
1434         return []
1435
1436     def _symbols_string(self):
1437         symbols = ''
1438         for path_to_module in self._modules_to_search_for_symbols():
1439             try:
1440                 symbols += self._executive.run_command([self.nm_command(), path_to_module], error_handler=self._executive.ignore_error)
1441             except OSError, e:
1442                 _log.warn("Failed to run nm: %s.  Can't determine supported features correctly." % e)
1443         return symbols
1444
1445     # Ports which use run-time feature detection should define this method and return
1446     # a dictionary mapping from Feature Names to skipped directoires.  NRWT will
1447     # run DumpRenderTree --print-supported-features and parse the output.
1448     # If the Feature Names are not found in the output, the corresponding directories
1449     # will be skipped.
1450     def _missing_feature_to_skipped_tests(self):
1451         """Return the supported feature dictionary. Keys are feature names and values
1452         are the lists of directories to skip if the feature name is not matched."""
1453         # FIXME: This list matches WebKitWin and should be moved onto the Win port.
1454         return {
1455             "Accelerated Compositing": ["compositing"],
1456             "3D Rendering": ["animations/3d", "transforms/3d"],
1457         }
1458
1459     def _has_test_in_directories(self, directory_lists, test_list):
1460         if not test_list:
1461             return False
1462
1463         directories = itertools.chain.from_iterable(directory_lists)
1464         for directory, test in itertools.product(directories, test_list):
1465             if test.startswith(directory):
1466                 return True
1467         return False
1468
1469     def _skipped_tests_for_unsupported_features(self, test_list):
1470         # Only check the runtime feature list of there are tests in the test_list that might get skipped.
1471         # This is a performance optimization to avoid the subprocess call to DRT.
1472         # If the port supports runtime feature detection, disable any tests
1473         # for features missing from the runtime feature list.
1474         # If _runtime_feature_list returns a non-None value, then prefer
1475         # runtime feature detection over static feature detection.
1476         if self._has_test_in_directories(self._missing_feature_to_skipped_tests().values(), test_list):
1477             supported_feature_list = self._runtime_feature_list()
1478             if supported_feature_list is not None:
1479                 return reduce(operator.add, [directories for feature, directories in self._missing_feature_to_skipped_tests().items() if feature not in supported_feature_list])
1480
1481         return []
1482
1483     def _wk2_port_name(self):
1484         # By current convention, the WebKit2 name is always mac-wk2, win-wk2, not mac-leopard-wk2, etc,
1485         return "%s-wk2" % self.port_name
1486
1487     def logging_patterns_to_strip(self):
1488         return []
1489
1490     def stderr_patterns_to_strip(self):
1491         return []
1492
1493     def test_expectations_file_position(self):
1494         # By default baseline search path schema is i.e. port-wk2 -> wk2 -> port -> generic, so port expectations file is at second to last position.
1495         return 1