Reformat webkitpy.layout_tests w/ format-webkitpy.

Tools/Scripts/webkitpy/layout_tests/port/base.py

 # Copyright (C) 2010 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 21 matching lines @@
 import cgi
 import difflib
 import errno
 import itertools
 import logging
 import os
 import operator
 import optparse
 import re
 import sys
+from functools import reduce
 
 try:
     from collections import OrderedDict
 except ImportError:
     # Needed for Python < 2.7
     from webkitpy.thirdparty.ordered_dict import OrderedDict
 
 
 from webkitpy.common import find_files
 from webkitpy.common import read_checksum_from_png
@@ skipping 11 matching lines @@
 from webkitpy.layout_tests.port import server_process
 from webkitpy.layout_tests.port.factory import PortFactory
 from webkitpy.layout_tests.servers import apache_http
 from webkitpy.layout_tests.servers import pywebsocket
 
 _log = logging.getLogger(__name__)
 
 
 # FIXME: This class should merge with WebKitPort now that Chromium behaves mostly like other webkit ports.
 class Port(object):
+
     """Abstract class for Port-specific hooks for the layout_test package."""
 
     # Subclasses override this. This should indicate the basic implementation
     # part of the port name, e.g., 'mac', 'win', 'gtk'; there is probably (?)
     # one unique value per class.
 
     # FIXME: We should probably rename this to something like 'implementation_name'.
     port_name = None
 
     # Test names resemble unix relative paths, and use '/' as a directory separator.
@@ skipping 17 matching lines @@
 
         ('mountainlion', 'x86'),
         ('mavericks', 'x86'),
         ('xp', 'x86'),
         ('win7', 'x86'),
         ('lucid', 'x86'),
         ('lucid', 'x86_64'),
         # FIXME: Technically this should be 'arm', but adding a third architecture type breaks TestConfigurationConverter.
         # If we need this to be 'arm' in the future, then we first have to fix TestConfigurationConverter.
         ('icecreamsandwich', 'x86'),
-        )
+    )
 
     ALL_BASELINE_VARIANTS = [
         'mac-mavericks', 'mac-mountainlion', 'mac-retina', 'mac-lion', 'mac-snowleopard',
         'win-win7', 'win-xp',
         'linux-x86_64', 'linux-x86',
     ]
 
     CONFIGURATION_SPECIFIER_MACROS = {
         'mac': ['snowleopard', 'lion', 'retina', 'mountainlion', 'mavericks'],
         'win': ['xp', 'win7'],
@@ skipping 79 matching lines @@
         # wdiff, assume it's not available.  This will leak one
         # file descriptor but that's better than leaking each time
         # wdiff would be run.
         #
         # http://mail.python.org/pipermail/python-list/
         #    2008-August/505753.html
         # http://bugs.python.org/issue3210
         self._wdiff_available = None
 
         # FIXME: prettypatch.py knows this path, why is it copied here?
-        self._pretty_patch_path = self.path_from_webkit_base("Tools", "Scripts", "webkitruby", "PrettyPatch", "prettify.rb")
+        self._pretty_patch_path = self.path_from_webkit_base('Tools', 'Scripts', 'webkitruby', 'PrettyPatch', 'prettify.rb')
         self._pretty_patch_available = None
 
         if not hasattr(options, 'configuration') or not options.configuration:
             self.set_option_default('configuration', self.default_configuration())
         self._test_configuration = None
         self._reftest_list = {}
         self._results_directory = None
 
     def buildbot_archives_baselines(self):
         return True
@@ skipping 130 matching lines @@
             result = self._dump_reader.check_is_functional() and result
 
         if needs_http:
             result = self.check_httpd() and result
 
         return test_run_results.OK_EXIT_STATUS if result else test_run_results.UNEXPECTED_ERROR_EXIT_STATUS
 
     def _check_driver(self):
         driver_path = self._path_to_driver()
         if not self._filesystem.exists(driver_path):
-            _log.error("%s was not found at %s" % (self.driver_name(), driver_path))
+            _log.error('%s was not found at %s' % (self.driver_name(), driver_path))
             return False
         return True
 
     def _check_port_build(self):
         # Ports can override this method to do additional checks.
         return True
 
     def check_sys_deps(self, needs_http):
         """If the port needs to do some runtime checks to ensure that the
         tests can be run successfully, it should override this routine.
@@ skipping 17 matching lines @@
                 _log.error('')
                 _log.error('For complete build requirements, please see:')
                 _log.error(self.BUILD_REQUIREMENTS_URL)
             return test_run_results.SYS_DEPS_EXIT_STATUS
         return test_run_results.OK_EXIT_STATUS
 
     def check_image_diff(self, override_step=None, logging=True):
         """This routine is used to check whether image_diff binary exists."""
         image_diff_path = self._path_to_image_diff()
         if not self._filesystem.exists(image_diff_path):
-            _log.error("image_diff was not found at %s" % image_diff_path)
+            _log.error('image_diff was not found at %s' % image_diff_path)
             return False
         return True
 
     def check_pretty_patch(self, logging=True):
         """Checks whether we can use the PrettyPatch ruby script."""
         try:
             _ = self._executive.run_command(['ruby', '--version'])
-        except OSError, e:
+        except OSError as e:
             if e.errno in [errno.ENOENT, errno.EACCES, errno.ECHILD]:
                 if logging:
                     _log.warning("Ruby is not installed; can't generate pretty patches.")
                     _log.warning('')
                 return False
 
         if not self._filesystem.exists(self._pretty_patch_path):
             if logging:
                 _log.warning("Unable to find %s; can't generate pretty patches." % self._pretty_patch_path)
                 _log.warning('')
@@ skipping 20 matching lines @@
         return True
 
     def _wdiff_missing_message(self):
         return 'wdiff is not installed; please install it to generate word-by-word diffs.'
 
     def check_httpd(self):
         httpd_path = self.path_to_apache()
         try:
             server_name = self._filesystem.basename(httpd_path)
             env = self.setup_environ_for_server(server_name)
-            if self._executive.run_command([httpd_path, "-v"], env=env, return_exit_code=True) != 0:
-                _log.error("httpd seems broken. Cannot run http tests.")
+            if self._executive.run_command([httpd_path, '-v'], env=env, return_exit_code=True) != 0:
+                _log.error('httpd seems broken. Cannot run http tests.')
                 return False
             return True
         except OSError:
-            _log.error("No httpd found. Cannot run http tests.")
+            _log.error('No httpd found. Cannot run http tests.')
             return False
 
     def do_text_results_differ(self, expected_text, actual_text):
         return expected_text != actual_text
 
     def do_audio_results_differ(self, expected_audio, actual_audio):
         return expected_audio != actual_audio
 
     def diff_image(self, expected_contents, actual_contents):
         """Compare two images and return a tuple of an image diff, and an error string.
 
         If an error occurs (like image_diff isn't found, or crashes, we log an error and return True (for a diff).
         """
         # If only one of them exists, return that one.
         if not actual_contents and not expected_contents:
             return (None, None)
         if not actual_contents:
             return (expected_contents, None)
         if not expected_contents:
             return (actual_contents, None)
 
         tempdir = self._filesystem.mkdtemp()
 
-        expected_filename = self._filesystem.join(str(tempdir), "expected.png")
+        expected_filename = self._filesystem.join(str(tempdir), 'expected.png')
         self._filesystem.write_binary_file(expected_filename, expected_contents)
 
-        actual_filename = self._filesystem.join(str(tempdir), "actual.png")
+        actual_filename = self._filesystem.join(str(tempdir), 'actual.png')
         self._filesystem.write_binary_file(actual_filename, actual_contents)
 
-        diff_filename = self._filesystem.join(str(tempdir), "diff.png")
+        diff_filename = self._filesystem.join(str(tempdir), 'diff.png')
 
         # image_diff needs native win paths as arguments, so we need to convert them if running under cygwin.
         native_expected_filename = self._convert_path(expected_filename)
         native_actual_filename = self._convert_path(actual_filename)
         native_diff_filename = self._convert_path(diff_filename)
 
         executable = self._path_to_image_diff()
         # Note that although we are handed 'old', 'new', image_diff wants 'new', 'old'.
         comand = [executable, '--diff', native_actual_filename, native_expected_filename, native_diff_filename]
 
         result = None
         err_str = None
         try:
             exit_code = self._executive.run_command(comand, return_exit_code=True)
             if exit_code == 0:
                 # The images are the same.
                 result = None
             elif exit_code == 1:
                 result = self._filesystem.read_binary_file(native_diff_filename)
             else:
-                err_str = "Image diff returned an exit code of %s. See http://crbug.com/278596" % exit_code
-        except OSError, e:
+                err_str = 'Image diff returned an exit code of %s. See http://crbug.com/278596' % exit_code
+        except OSError as e:
             err_str = 'error running image diff: %s' % str(e)
         finally:
             self._filesystem.rmtree(str(tempdir))
 
         return (result, err_str or None)
 
     def diff_text(self, expected_text, actual_text, expected_filename, actual_filename):
         """Returns a string containing the diff of the two text strings
         in 'unified diff' format."""
 
@@ skipping 158 matching lines @@
         """Returns the text output we expect the test to produce, or None
         if we don't expect there to be any text output.
         End-of-line characters are normalized to '\n'."""
         # FIXME: DRT output is actually utf-8, but since we don't decode the
         # output from DRT (instead treating it as a binary string), we read the
         # baselines as a binary string, too.
         baseline_path = self.expected_filename(test_name, '.txt')
         if not self._filesystem.exists(baseline_path):
             return None
         text = self._filesystem.read_binary_file(baseline_path)
-        return text.replace("\r\n", "\n")
+        return text.replace('\r\n', '\n')
 
     def _get_reftest_list(self, test_name):
         dirname = self._filesystem.join(self.layout_tests_dir(), self._filesystem.dirname(test_name))
         if dirname not in self._reftest_list:
             self._reftest_list[dirname] = Port._parse_reftest_list(self._filesystem, dirname)
         return self._reftest_list[dirname]
 
     @staticmethod
     def _parse_reftest_list(filesystem, test_dirpath):
         reftest_list_path = filesystem.join(test_dirpath, 'reftest.list')
         if not filesystem.isfile(reftest_list_path):
             return None
         reftest_list_file = filesystem.read_text_file(reftest_list_path)
 
         parsed_list = {}
         for line in reftest_list_file.split('\n'):
             line = re.sub('#.+$', '', line)
             split_line = line.split()
             if len(split_line) == 4:
                 # FIXME: Probably one of mozilla's extensions in the reftest.list format. Do we need to support this?
                 _log.warning("unsupported reftest.list line '%s' in %s" % (line, reftest_list_path))
                 continue
             if len(split_line) < 3:
                 continue
             expectation_type, test_file, ref_file = split_line
-            parsed_list.setdefault(filesystem.join(test_dirpath, test_file), []).append((expectation_type, filesystem.join(test_dirpath, ref_file)))
+            parsed_list.setdefault(
+                filesystem.join(
+                    test_dirpath,
+                    test_file),
+                []).append(
+                (expectation_type,
+                 filesystem.join(
+                     test_dirpath,
+                     ref_file)))
         return parsed_list
 
     def reference_files(self, test_name):
         """Return a list of expectation (== or !=) and filename pairs"""
 
         reftest_list = self._get_reftest_list(test_name)
         if not reftest_list:
             reftest_list = []
             for expectation, prefix in (('==', ''), ('!=', '-mismatch')):
                 for extention in Port._supported_file_extensions:
                     path = self.expected_filename(test_name, prefix + extention)
                     if self._filesystem.exists(path):
                         reftest_list.append((expectation, path))
             return reftest_list
 
         return reftest_list.get(self._filesystem.join(self.layout_tests_dir(), test_name), [])  # pylint: disable=E1103
 
     def tests(self, paths):
         """Return the list of tests found matching paths."""
         tests = self._real_tests(paths)
         tests.extend(self._virtual_tests(paths, self.populated_virtual_test_suites()))
         return tests
 
     def _real_tests(self, paths):
         # When collecting test cases, skip these directories
         skipped_directories = set(['.svn', '_svn', 'platform', 'resources', 'support', 'script-tests', 'reference', 'reftest'])
-        files = find_files.find(self._filesystem, self.layout_tests_dir(), paths, skipped_directories, Port.is_test_file, self.test_key)
+        files = find_files.find(
+            self._filesystem,
+            self.layout_tests_dir(),
+            paths,
+            skipped_directories,
+            Port.is_test_file,
+            self.test_key)
         return [self.relative_test_filename(f) for f in files]
 
     # When collecting test cases, we include any file with these extensions.
     _supported_file_extensions = set(['.html', '.xml', '.xhtml', '.xht', '.pl',
                                       '.htm', '.php', '.svg', '.mht', '.pdf'])
 
     @staticmethod
     # If any changes are made here be sure to update the isUsedInReftest method in old-run-webkit-tests as well.
     def is_reference_html_file(filesystem, dirname, filename):
         if filename.startswith('ref-') or filename.startswith('notref-'):
             return True
         filename_wihout_ext, unused = filesystem.splitext(filename)
         for suffix in ['-expected', '-expected-mismatch', '-ref', '-notref']:
             if filename_wihout_ext.endswith(suffix):
                 return True
         return False
 
     @staticmethod
     def _has_supported_extension(filesystem, filename):
         """Return true if filename is one of the file extensions we want to run a test on."""
         extension = filesystem.splitext(filename)[1]
         return extension in Port._supported_file_extensions
 
     @staticmethod
     def is_test_file(filesystem, dirname, filename):
-        return Port._has_supported_extension(filesystem, filename) and not Port.is_reference_html_file(filesystem, dirname, filename)
+        return Port._has_supported_extension(
+            filesystem, filename) and not Port.is_reference_html_file(filesystem, dirname, filename)
 
     ALL_TEST_TYPES = ['audio', 'harness', 'pixel', 'ref', 'text', 'unknown']
 
     def test_type(self, test_name):
         fs = self._filesystem
         if fs.exists(self.expected_filename(test_name, '.png')):
             return 'pixel'
         if fs.exists(self.expected_filename(test_name, '.wav')):
             return 'audio'
         if self.reference_files(test_name):
@@ skipping 124 matching lines @@
             line = line.strip()
             line = line.rstrip('/')  # Best to normalize directory names to not include the trailing slash.
             if line.startswith('#') or not len(line):
                 continue
             tests_to_skip.append(line)
         return tests_to_skip
 
     def _expectations_from_skipped_files(self, skipped_file_paths):
         tests_to_skip = []
         for search_path in skipped_file_paths:
-            filename = self._filesystem.join(self._webkit_baseline_path(search_path), "Skipped")
+            filename = self._filesystem.join(self._webkit_baseline_path(search_path), 'Skipped')
             if not self._filesystem.exists(filename):
-                _log.debug("Skipped does not exist: %s" % filename)
+                _log.debug('Skipped does not exist: %s' % filename)
                 continue
-            _log.debug("Using Skipped file: %s" % filename)
+            _log.debug('Using Skipped file: %s' % filename)
             skipped_file_contents = self._filesystem.read_text_file(filename)
             tests_to_skip.extend(self._tests_from_skipped_file_contents(skipped_file_contents))
         return tests_to_skip
 
     @memoized
     def skipped_perf_tests(self):
         return self._expectations_from_skipped_files([self.perf_tests_dir()])
 
     def skips_perf_test(self, test_name):
         for test_or_category in self.skipped_perf_tests():
@@ skipping 69 matching lines @@
         try:
             return self.path_from_chromium_base('webkit', self.get_option('configuration'), 'layout-test-results')
         except AssertionError:
             return self._build_path('layout-test-results')
 
     def setup_test_run(self):
         """Perform port-specific work at the beginning of a test run."""
         # Delete the disk cache if any to ensure a clean test run.
         dump_render_tree_binary_path = self._path_to_driver()
         cachedir = self._filesystem.dirname(dump_render_tree_binary_path)
-        cachedir = self._filesystem.join(cachedir, "cache")
+        cachedir = self._filesystem.join(cachedir, 'cache')
         if self._filesystem.exists(cachedir):
             self._filesystem.rmtree(cachedir)
 
         if self._dump_reader:
             self._filesystem.maybe_make_directory(self._dump_reader.crash_dumps_directory())
 
     def num_workers(self, requested_num_workers):
         """Returns the number of available workers (possibly less than the number requested)."""
         return requested_num_workers
 
@@ skipping 73 matching lines @@
     def create_driver(self, worker_number, no_timeout=False):
         """Return a newly created Driver subclass for starting/stopping the test driver."""
         return self._driver_class()(self, worker_number, pixel_tests=self.get_option('pixel_tests'), no_timeout=no_timeout)
 
     def start_helper(self):
         """If a port needs to reconfigure graphics settings or do other
         things to ensure a known test configuration, it should override this
         method."""
         helper_path = self._path_to_helper()
         if helper_path:
-            _log.debug("Starting layout helper %s" % helper_path)
+            _log.debug('Starting layout helper %s' % helper_path)
             # Note: Not thread safe: http://bugs.python.org/issue2320
             self._helper = self._executive.popen([helper_path],
-                stdin=self._executive.PIPE, stdout=self._executive.PIPE, stderr=None)
+                                                 stdin=self._executive.PIPE, stdout=self._executive.PIPE, stderr=None)
             is_ready = self._helper.stdout.readline()
             if not is_ready.startswith('ready'):
-                _log.error("layout_test_helper failed to be ready")
+                _log.error('layout_test_helper failed to be ready')
 
     def requires_http_server(self):
         """Does the port require an HTTP server for running tests? This could
         be the case when the tests aren't run on the host platform."""
         return False
 
     def start_http_server(self, additional_dirs, number_of_drivers):
         """Start a web server. Raise an error if it can't start or is already running.
 
         Ports can stub this out if they don't need a web server to be running."""
@@ skipping 19 matching lines @@
         # Apache < 2.4 on win32 does not support IPv6, nor does cygwin apache.
         if self.host.platform.is_cygwin() or self.host.platform.is_win():
             return False
         return True
 
     def stop_helper(self):
         """Shut down the test helper if it is running. Do nothing if
         it isn't, or it isn't available. If a port overrides start_helper()
         it must override this routine as well."""
         if self._helper:
-            _log.debug("Stopping layout test helper")
+            _log.debug('Stopping layout test helper')
             try:
-                self._helper.stdin.write("x\n")
+                self._helper.stdin.write('x\n')
                 self._helper.stdin.close()
                 self._helper.wait()
-            except IOError, e:
+            except IOError as e:
                 pass
             finally:
                 self._helper = None
 
     def stop_http_server(self):
         """Shut down the http server if it is running. Do nothing if it isn't."""
         if self._http_server:
             self._http_server.stop()
             self._http_server = None
 
@@ skipping 129 matching lines @@
         """Returns a list of (repository_name, repository_path) tuples of its depending code base."""
         return [('blink', self.layout_tests_dir()),
                 ('chromium', self.path_from_chromium_base('build'))]
 
     _WDIFF_DEL = '##WDIFF_DEL##'
     _WDIFF_ADD = '##WDIFF_ADD##'
     _WDIFF_END = '##WDIFF_END##'
 
     def _format_wdiff_output_as_html(self, wdiff):
         wdiff = cgi.escape(wdiff)
-        wdiff = wdiff.replace(self._WDIFF_DEL, "<span class=del>")
-        wdiff = wdiff.replace(self._WDIFF_ADD, "<span class=add>")
-        wdiff = wdiff.replace(self._WDIFF_END, "</span>")
-        html = "<head><style>.del { background: #faa; } "
-        html += ".add { background: #afa; }</style></head>"
-        html += "<pre>%s</pre>" % wdiff
+        wdiff = wdiff.replace(self._WDIFF_DEL, '<span class=del>')
+        wdiff = wdiff.replace(self._WDIFF_ADD, '<span class=add>')
+        wdiff = wdiff.replace(self._WDIFF_END, '</span>')
+        html = '<head><style>.del { background: #faa; } '
+        html += '.add { background: #afa; }</style></head>'
+        html += '<pre>%s</pre>' % wdiff
         return html
 
     def _wdiff_command(self, actual_filename, expected_filename):
         executable = self._path_to_wdiff()
         return [executable,
-                "--start-delete=%s" % self._WDIFF_DEL,
-                "--end-delete=%s" % self._WDIFF_END,
-                "--start-insert=%s" % self._WDIFF_ADD,
-                "--end-insert=%s" % self._WDIFF_END,
+                '--start-delete=%s' % self._WDIFF_DEL,
+                '--end-delete=%s' % self._WDIFF_END,
+                '--start-insert=%s' % self._WDIFF_ADD,
+                '--end-insert=%s' % self._WDIFF_END,
                 actual_filename,
                 expected_filename]
 
     @staticmethod
     def _handle_wdiff_error(script_error):
         # Exit 1 means the files differed, any other exit code is an error.
         if script_error.exit_code != 1:
             raise script_error
 
     def _run_wdiff(self, actual_filename, expected_filename):
         """Runs wdiff and may throw exceptions.
         This is mostly a hook for unit testing."""
         # Diffs are treated as binary as they may include multiple files
         # with conflicting encodings.  Thus we do not decode the output.
         command = self._wdiff_command(actual_filename, expected_filename)
         wdiff = self._executive.run_command(command, decode_output=False,
-            error_handler=self._handle_wdiff_error)
+                                            error_handler=self._handle_wdiff_error)
         return self._format_wdiff_output_as_html(wdiff)
 
-    _wdiff_error_html = "Failed to run wdiff, see error log."
+    _wdiff_error_html = 'Failed to run wdiff, see error log.'
 
     def wdiff_text(self, actual_filename, expected_filename):
         """Returns a string of HTML indicating the word-level diff of the
         contents of the two filenames. Returns an empty string if word-level
         diffing isn't available."""
         if not self.wdiff_available():
-            return ""
+            return ''
         try:
             # It's possible to raise a ScriptError we pass wdiff invalid paths.
             return self._run_wdiff(actual_filename, expected_filename)
         except OSError as e:
             if e.errno in [errno.ENOENT, errno.EACCES, errno.ECHILD]:
                 # Silently ignore cases where wdiff is missing.
                 self._wdiff_available = False
-                return ""
+                return ''
             raise
         except ScriptError as e:
-            _log.error("Failed to run wdiff: %s" % e)
+            _log.error('Failed to run wdiff: %s' % e)
             self._wdiff_available = False
             return self._wdiff_error_html
 
     # This is a class variable so we can test error output easily.
-    _pretty_patch_error_html = "Failed to run PrettyPatch, see error log."
+    _pretty_patch_error_html = 'Failed to run PrettyPatch, see error log.'
 
     def pretty_patch_text(self, diff_path):
         if self._pretty_patch_available is None:
             self._pretty_patch_available = self.check_pretty_patch(logging=False)
         if not self._pretty_patch_available:
             return self._pretty_patch_error_html
-        command = ("ruby", "-I", self._filesystem.dirname(self._pretty_patch_path),
+        command = ('ruby', '-I', self._filesystem.dirname(self._pretty_patch_path),
                    self._pretty_patch_path, diff_path)
         try:
             # Diffs are treated as binary (we pass decode_output=False) as they
             # may contain multiple files of conflicting encodings.
             return self._executive.run_command(command, decode_output=False)
-        except OSError, e:
+        except OSError as e:
             # If the system is missing ruby log the error and stop trying.
             self._pretty_patch_available = False
-            _log.error("Failed to run PrettyPatch (%s): %s" % (command, e))
+            _log.error('Failed to run PrettyPatch (%s): %s' % (command, e))
             return self._pretty_patch_error_html
-        except ScriptError, e:
+        except ScriptError as e:
             # If ruby failed to run for some reason, log the command
             # output and stop trying.
             self._pretty_patch_available = False
-            _log.error("Failed to run PrettyPatch (%s):\n%s" % (command, e.message_with_output()))
+            _log.error('Failed to run PrettyPatch (%s):\n%s' % (command, e.message_with_output()))
             return self._pretty_patch_error_html
 
     def default_configuration(self):
         return self._config.default_configuration()
 
     def clobber_old_port_specific_results(self):
         pass
 
     # FIXME: This does not belong on the port object.
     @memoized
@@ skipping 40 matching lines @@
     # We pass sys_platform into this method to make it easy to unit test.
     def _apache_config_file_name_for_platform(self, sys_platform):
         if sys_platform == 'cygwin':
             return 'cygwin-httpd.conf'  # CYGWIN is the only platform to still use Apache 1.3.
         if sys_platform.startswith('linux'):
             if self._is_redhat_based():
                 return 'fedora-httpd-' + self._apache_version() + '.conf'
             if self._is_debian_based():
                 return 'debian-httpd-' + self._apache_version() + '.conf'
         # All platforms use apache2 except for CYGWIN (and Mac OS X Tiger and prior, which we no longer support).
-        return "apache2-httpd.conf"
+        return 'apache2-httpd.conf'
 
     def _path_to_driver(self, configuration=None):
         """Returns the full path to the test driver."""
         return self._build_path(self.driver_name())
 
     def _path_to_webcore_library(self):
         """Returns the full path to a built copy of WebCore."""
         return None
 
     def _path_to_helper(self):
         """Returns the full path to the layout_test_helper binary, which
         is used to help configure the system for the test run, or None
         if no helper is needed.
 
         This is likely only used by start/stop_helper()."""
         return None
 
     def _path_to_image_diff(self):
         """Returns the full path to the image_diff binary, or None if it is not available.
 
         This is likely used only by diff_image()"""
         return self._build_path('image_diff')
 
     @memoized
     def _path_to_wdiff(self):
         """Returns the full path to the wdiff binary, or None if it is not available.
 
         This is likely used only by wdiff_text()"""
-        for path in ("/usr/bin/wdiff", "/usr/bin/dwdiff"):
+        for path in ('/usr/bin/wdiff', '/usr/bin/dwdiff'):
             if self._filesystem.exists(path):
                 return path
         return None
 
     def _webkit_baseline_path(self, platform):
         """Return the  full path to the top of the baseline tree for a
         given platform."""
         return self._filesystem.join(self.layout_tests_dir(), 'platform', platform)
 
     def _driver_class(self):
@@ skipping 11 matching lines @@
 
     def _get_crash_log(self, name, pid, stdout, stderr, newer_than):
         if self._output_contains_sanitizer_messages(stderr):
             # Running the symbolizer script can take a lot of memory, so we need to
             # serialize access to it across all the concurrently running drivers.
 
             # FIXME: investigate using LLVM_SYMBOLIZER_PATH here to reduce the overhead.
             sanitizer_filter_path = self.path_from_chromium_base('tools', 'valgrind', 'asan', 'asan_symbolize.py')
             sanitizer_strip_path_prefix = 'Release/../../'
             if self._filesystem.exists(sanitizer_filter_path):
-                stderr = self._executive.run_command(['flock', sys.executable, sanitizer_filter_path, sanitizer_strip_path_prefix], input=stderr, decode_output=False)
+                stderr = self._executive.run_command(['flock',
+                                                      sys.executable,
+                                                      sanitizer_filter_path,
+                                                      sanitizer_strip_path_prefix],
+                                                     input=stderr,
+                                                     decode_output=False)
 
         name_str = name or '<unknown process name>'
         pid_str = str(pid or '<unknown>')
         stdout_lines = (stdout or '<empty>').decode('utf8', 'replace').splitlines()
         stderr_lines = (stderr or '<empty>').decode('utf8', 'replace').splitlines()
         return (stderr, 'crash log for %s (pid %s):\n%s\n%s\n' % (name_str, pid_str,
-            '\n'.join(('STDOUT: ' + l) for l in stdout_lines),
-            '\n'.join(('STDERR: ' + l) for l in stderr_lines)))
+                                                                  '\n'.join(('STDOUT: ' + l) for l in stdout_lines),
+                                                                  '\n'.join(('STDERR: ' + l) for l in stderr_lines)))
 
     def look_for_new_crash_logs(self, crashed_processes, start_time):
         pass
 
     def look_for_new_samples(self, unresponsive_processes, start_time):
         pass
 
     def sample_process(self, name, pid):
         pass
 
     def physical_test_suites(self):
         return [
             # For example, to turn on force-compositing-mode in the svg/ directory:
             # PhysicalTestSuite('svg',
             #                   ['--force-compositing-mode']),
-            ]
+        ]
 
     def virtual_test_suites(self):
         return [
             VirtualTestSuite('gpu',
                              'fast/canvas',
                              ['--enable-accelerated-2d-canvas']),
             VirtualTestSuite('gpu',
                              'canvas/philip',
                              ['--enable-accelerated-2d-canvas']),
             VirtualTestSuite('threaded',
@@ skipping 140 matching lines @@
         path = self._path_to_webcore_library()
         if path:
             return [path]
         return []
 
     def _symbols_string(self):
         symbols = ''
         for path_to_module in self._modules_to_search_for_symbols():
             try:
                 symbols += self._executive.run_command(['nm', path_to_module], error_handler=self._executive.ignore_error)
-            except OSError, e:
+            except OSError as e:
                 _log.warn("Failed to run nm: %s.  Can't determine supported features correctly." % e)
         return symbols
 
     # Ports which use compile-time feature detection should define this method and return
     # a dictionary mapping from symbol substrings to possibly disabled test directories.
     # When the symbol substrings are not matched, the directories will be skipped.
     # If ports don't ever enable certain features, then those directories can just be
     # in the Skipped list instead of compile-time-checked here.
     def _missing_symbol_to_skipped_tests(self):
         if self.PORT_HAS_AUDIO_CODECS_BUILT_IN:
             return {}
         else:
             return {
-                "ff_mp3_decoder": ["webaudio/codec-tests/mp3"],
-                "ff_aac_decoder": ["webaudio/codec-tests/aac"],
+                'ff_mp3_decoder': ['webaudio/codec-tests/mp3'],
+                'ff_aac_decoder': ['webaudio/codec-tests/aac'],
             }
 
     def _has_test_in_directories(self, directory_lists, test_list):
         if not test_list:
             return False
 
         directories = itertools.chain.from_iterable(directory_lists)
         for directory, test in itertools.product(directories, test_list):
             if test.startswith(directory):
                 return True
         return False
 
     def _skipped_tests_for_unsupported_features(self, test_list):
         # Only check the symbols of there are tests in the test_list that might get skipped.
         # This is a performance optimization to avoid the calling nm.
         # Runtime feature detection not supported, fallback to static detection:
         # Disable any tests for symbols missing from the executable or libraries.
         if self._has_test_in_directories(self._missing_symbol_to_skipped_tests().values(), test_list):
             symbols_string = self._symbols_string()
             if symbols_string is not None:
-                return reduce(operator.add, [directories for symbol_substring, directories in self._missing_symbol_to_skipped_tests().items() if symbol_substring not in symbols_string], [])
+                return reduce(operator.add, [directories for symbol_substring, directories in self._missing_symbol_to_skipped_tests(
+                ).items() if symbol_substring not in symbols_string], [])
         return []
 
     def _convert_path(self, path):
         """Handles filename conversion for subprocess command line args."""
         # See note above in diff_image() for why we need this.
         if sys.platform == 'cygwin':
             return cygpath(path)
         return path
 
     def _build_path(self, *comps):
         return self._build_path_with_configuration(None, *comps)
 
     def _build_path_with_configuration(self, configuration, *comps):
         # Note that we don't do the option caching that the
         # base class does, because finding the right directory is relatively
         # fast.
         configuration = configuration or self.get_option('configuration')
         return self._static_build_path(self._filesystem, self.get_option('build_directory'),
-            self.path_from_chromium_base(), configuration, comps)
+                                       self.path_from_chromium_base(), configuration, comps)
 
     def _check_driver_build_up_to_date(self, configuration):
         if configuration in ('Debug', 'Release'):
             try:
                 debug_path = self._path_to_driver('Debug')
                 release_path = self._path_to_driver('Release')
 
                 debug_mtime = self._filesystem.mtime(debug_path)
                 release_mtime = self._filesystem.mtime(release_path)
 
                 if (debug_mtime > release_mtime and configuration == 'Release' or
-                    release_mtime > debug_mtime and configuration == 'Debug'):
+                        release_mtime > debug_mtime and configuration == 'Debug'):
                     most_recent_binary = 'Release' if configuration == 'Debug' else 'Debug'
                     _log.warning('You are running the %s binary. However the %s binary appears to be more recent. '
                                  'Please pass --%s.', configuration, most_recent_binary, most_recent_binary.lower())
                     _log.warning('')
             # This will fail if we don't have both a debug and release binary.
             # That's fine because, in this case, we must already be running the
             # most up-to-date one.
             except OSError:
                 pass
         return True
 
     def _chromium_baseline_path(self, platform):
         if platform is None:
             platform = self.name()
         return self.path_from_webkit_base('LayoutTests', 'platform', platform)
 
+
 class VirtualTestSuite(object):
+
     def __init__(self, name, base, args, use_legacy_naming=False, tests=None):
         if use_legacy_naming:
             self.name = 'virtual/' + name
         else:
             if name.find('/') != -1:
                 _log.error("Virtual test suites names cannot contain /'s: %s" % name)
                 return
             self.name = 'virtual/' + name + '/' + base
         self.base = base
         self.args = args
         self.tests = tests or set()
 
     def __repr__(self):
         return "VirtualTestSuite('%s', '%s', %s)" % (self.name, self.base, self.args)
 
 
 class PhysicalTestSuite(object):
+
     def __init__(self, base, args):
         self.name = base
         self.base = base
         self.args = args
         self.tests = set()
 
     def __repr__(self):
         return "PhysicalTestSuite('%s', '%s', %s)" % (self.name, self.base, self.args)