Run yapf on files in webkit/layout_tests/.

third_party/WebKit/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
 # in the documentation and/or other materials provided with the
 # distribution.
 #     * Neither the Google name nor the names of its
 # contributors may be used to endorse or promote products derived from
 # this software without specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
 """Abstract base class of Port-specific entry points for the layout tests
 test infrastructure (the Port and Driver classes)."""
 
 import cgi
 import difflib
 import errno
 import itertools
 import json
 import logging
 import os
 import operator
 import optparse
 import re
 import sys
 
 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
 from webkitpy.common.memoized import memoized
 from webkitpy.common.system import path
 from webkitpy.common.system.executive import ScriptError
 from webkitpy.common.system.path import cygpath
 from webkitpy.common.system.systemhost import SystemHost
 from webkitpy.common.webkit_finder import WebKitFinder
 from webkitpy.layout_tests.layout_package.bot_test_expectations import BotTestExpectationsFactory
 from webkitpy.layout_tests.models import test_run_results
@@ skipping 29 matching lines @@
 
     # True if the port as aac and mp3 codecs built in.
     PORT_HAS_AUDIO_CODECS_BUILT_IN = False
 
     ALL_SYSTEMS = (
 
         # FIXME: We treat Retina (High-DPI) devices as if they are running
         # a different operating system version. This isn't accurate, but will work until
         # we need to test and support baselines across multiple O/S versions.
         ('retina', 'x86'),
-
         ('mac10.9', 'x86'),
         ('mac10.10', 'x86'),
         ('mac10.11', 'x86'),
         ('win7', 'x86'),
         ('win10', 'x86'),
         ('precise', 'x86_64'),
         ('trusty', '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'),
-        )
+        ('icecreamsandwich', 'x86'), )
 
     CONFIGURATION_SPECIFIER_MACROS = {
         'mac': ['retina', 'mac10.9', 'mac10.10', 'mac10.11'],
         'win': ['win7', 'win10'],
         'linux': ['precise', 'trusty'],
         'android': ['icecreamsandwich'],
     }
 
-    DEFAULT_BUILD_DIRECTORIES = ('out',)
+    DEFAULT_BUILD_DIRECTORIES = ('out', )
 
     # overridden in subclasses.
     FALLBACK_PATHS = {}
 
     SUPPORTED_VERSIONS = []
 
     # URL to the build requirements page.
     BUILD_REQUIREMENTS_URL = ''
 
     @classmethod
@@ skipping 79 matching lines @@
         if not hasattr(options, 'configuration') or not options.configuration:
             self.set_option_default('configuration', self.default_configuration())
         if not hasattr(options, 'target') or not options.target:
             self.set_option_default('target', self._options.configuration)
         self._test_configuration = None
         self._reftest_list = {}
         self._results_directory = None
         self._virtual_test_suites = None
 
     def __str__(self):
-        return "Port{name=%s, version=%s, architecture=%s, test_configuration=%s}" % (self._name, self._version, self._architecture, self._test_configuration)
+        return "Port{name=%s, version=%s, architecture=%s, test_configuration=%s}" % (self._name, self._version, self._architecture,
+                                                                                      self._test_configuration)
 
     def buildbot_archives_baselines(self):
         return True
 
     def additional_driver_flag(self):
         if self.driver_name() == self.CONTENT_SHELL_NAME:
             return ['--run-layout-test']
         return []
 
     def supports_per_test_timeout(self):
@@ skipping 82 matching lines @@
         return map(self._webkit_baseline_path, self.FALLBACK_PATHS[self.version()])
 
     @memoized
     def _compare_baseline(self):
         factory = PortFactory(self.host)
         target_port = self.get_option('compare_port')
         if target_port:
             return factory.get(target_port).default_baseline_search_path()
         return []
 
-    def _check_file_exists(self, path_to_file, file_description,
-                           override_step=None, logging=True):
+    def _check_file_exists(self, path_to_file, file_description, override_step=None, logging=True):
         """Verify the file is present where expected or log an error.
 
         Args:
             file_name: The (human friendly) name or description of the file
                 you're looking for (e.g., "HTTP Server"). Used for error logging.
             override_step: An optional string to be logged if the check fails.
             logging: Whether or not log the error messages."""
         if not self._filesystem.exists(path_to_file):
             if logging:
                 _log.error('Unable to find %s' % file_description)
                 _log.error('    at %s' % path_to_file)
                 if override_step:
                     _log.error('    %s' % override_step)
                     _log.error('')
             return False
         return True
 
     def check_build(self, needs_http, printer):
         result = True
 
         dump_render_tree_binary_path = self._path_to_driver()
-        result = self._check_file_exists(dump_render_tree_binary_path,
-                                         'test driver') and result
+        result = self._check_file_exists(dump_render_tree_binary_path, 'test driver') and result
         if not result and self.get_option('build'):
-            result = self._check_driver_build_up_to_date(
-                self.get_option('configuration'))
+            result = self._check_driver_build_up_to_date(self.get_option('configuration'))
         else:
             _log.error('')
 
         helper_path = self._path_to_helper()
         if helper_path:
-            result = self._check_file_exists(helper_path,
-                                             'layout test helper') and result
+            result = self._check_file_exists(helper_path, 'layout test helper') and result
 
         if self.get_option('pixel_tests'):
-            result = self.check_image_diff(
-                'To override, invoke with --no-pixel-tests') and result
+            result = self.check_image_diff('To override, invoke with --no-pixel-tests') and result
 
         # It's okay if pretty patch and wdiff aren't available, but we will at least log messages.
         self._pretty_patch_available = self.check_pretty_patch()
         self._wdiff_available = self.check_wdiff()
 
         if self._dump_reader:
             result = self._dump_reader.check_is_functional() and result
 
         if needs_http:
             result = self.check_httpd() and result
@@ skipping 160 matching lines @@
         """Returns a string containing the diff of the two text strings
         in 'unified diff' format."""
 
         # The filenames show up in the diff output, make sure they're
         # raw bytes and not unicode, so that they don't trigger join()
         # trying to decode the input.
         def to_raw_bytes(string_value):
             if isinstance(string_value, unicode):
                 return string_value.encode('utf-8')
             return string_value
+
         expected_filename = to_raw_bytes(expected_filename)
         actual_filename = to_raw_bytes(actual_filename)
-        diff = difflib.unified_diff(expected_text.splitlines(True),
-                                    actual_text.splitlines(True),
-                                    expected_filename,
-                                    actual_filename)
+        diff = difflib.unified_diff(
+            expected_text.splitlines(True), actual_text.splitlines(True), expected_filename, actual_filename)
 
         # The diff generated by the difflib is incorrect if one of the files
         # does not have a newline at the end of the file and it is present in
         # the diff. Relevant Python issue: http://bugs.python.org/issue2142
         def diff_fixup(diff):
             for line in diff:
                 yield line
                 if not line.endswith('\n'):
                     yield '\n\ No newline at end of file\n'
 
@@ skipping 161 matching lines @@
         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 extension in Port._supported_file_extensions:
@@ skipping 11 matching lines @@
         suites = self.virtual_test_suites()
         if paths:
             tests.extend(self._virtual_tests_matching_paths(paths, suites))
         else:
             tests.extend(self._all_virtual_tests(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'])
+    _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 18 matching lines @@
         dirname, basename = self.split_test(test_name)
         return (self._natural_sort_key(dirname + self.TEST_PATH_SEPARATOR), self._natural_sort_key(basename))
 
     def _natural_sort_key(self, string_to_split):
         """ Turns a string into a list of string and number chunks, i.e. "z23a" -> ["z", 23, "a"]
 
         This can be used to implement "natural sort" order. See:
         http://www.codinghorror.com/blog/2007/12/sorting-for-humans-natural-sort-order.html
         http://nedbatchelder.com/blog/200712.html#e20071211T054956
         """
+
         def tryint(val):
             try:
                 return int(val)
             except ValueError:
                 return val
 
         return [tryint(chunk) for chunk in re.split('(\d+)', string_to_split)]
 
     def test_dirs(self):
         """Returns the list of top-level test directories."""
@@ skipping 232 matching lines @@
             clean_env[name] = os.environ[name]
 
     def setup_environ_for_server(self, server_name=None):
         # We intentionally copy only a subset of os.environ when
         # launching subprocesses to ensure consistent test results.
         clean_env = {
             'LOCAL_RESOURCE_ROOT': self.layout_tests_dir(),  # FIXME: Is this used?
         }
         variables_to_copy = [
             'WEBKIT_TESTFONTS',  # FIXME: Is this still used?
-            'WEBKITOUTPUTDIR',   # FIXME: Is this still used?
+            'WEBKITOUTPUTDIR',  # FIXME: Is this still used?
             'CHROME_DEVEL_SANDBOX',
             'CHROME_IPC_LOGGING',
             'ASAN_OPTIONS',
             'TSAN_OPTIONS',
             'MSAN_OPTIONS',
             'LSAN_OPTIONS',
             'UBSAN_OPTIONS',
             'VALGRIND_LIB',
             'VALGRIND_LIB_INNER',
         ]
         if self.host.platform.is_linux() or self.host.platform.is_freebsd():
-            variables_to_copy += [
-                'XAUTHORITY',
-                'HOME',
-                'LANG',
-                'LD_LIBRARY_PATH',
-                'DBUS_SESSION_BUS_ADDRESS',
-                'XDG_DATA_DIRS',
-            ]
+            variables_to_copy += ['XAUTHORITY', 'HOME', 'LANG', 'LD_LIBRARY_PATH', 'DBUS_SESSION_BUS_ADDRESS', 'XDG_DATA_DIRS', ]
             clean_env['DISPLAY'] = self._value_or_default_from_environ('DISPLAY', ':1')
         if self.host.platform.is_mac():
             clean_env['DYLD_LIBRARY_PATH'] = self._build_path()
-            variables_to_copy += [
-                'HOME',
-            ]
+            variables_to_copy += ['HOME', ]
         if self.host.platform.is_win():
             variables_to_copy += [
                 'PATH',
                 'GYP_DEFINES',  # Required to locate win sdk.
             ]
         if self.host.platform.is_cygwin():
-            variables_to_copy += [
-                'HOMEDRIVE',
-                'HOMEPATH',
-                '_NT_SYMBOL_PATH',
-            ]
+            variables_to_copy += ['HOMEDRIVE', 'HOMEPATH', '_NT_SYMBOL_PATH', ]
 
         for variable in variables_to_copy:
             self._copy_value_from_environ_if_set(clean_env, variable)
 
         for string_variable in self.get_option('additional_env_var', []):
             [name, value] = string_variable.split('=', 1)
             clean_env[name] = value
 
         return clean_env
 
     def show_results_html_file(self, results_filename):
         """This routine should display the HTML file pointed at by
         results_filename in a users' browser."""
         return self.host.user.open_url(path.abspath_to_uri(self.host.platform, results_filename))
 
     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)
             # 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")
 
     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."""
         assert not self._http_server, 'Already running an http server.'
 
-        server = apache_http.ApacheHTTP(self, self.results_directory(),
+        server = apache_http.ApacheHTTP(self,
+                                        self.results_directory(),
                                         additional_dirs=additional_dirs,
                                         number_of_servers=(number_of_drivers * 4))
         server.start()
         self._http_server = server
 
     def start_websocket_server(self):
         """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 websocket server to be running."""
         assert not self._websocket_server, 'Already running a websocket server.'
@@ skipping 157 matching lines @@
 
         ignore_mode = self.get_option('ignore_flaky_tests')
         if ignore_mode == 'very-flaky' or ignore_mode == 'maybe-flaky':
             return expectations.flakes_by_path(ignore_mode == 'very-flaky')
         if ignore_mode == 'unexpected':
             return expectations.unexpected_results_by_path()
         _log.warning("Unexpected ignore mode: '%s'." % ignore_mode)
         return {}
 
     def expectations_files(self):
-        return ([self.path_to_generic_test_expectations_file()] +
-                self._port_specific_expectations_files() +
+        return ([self.path_to_generic_test_expectations_file()] + self._port_specific_expectations_files() +
                 self._flag_specific_expectations_files())
 
     def repository_path(self):
         """Returns the repository path for the chromium code base."""
         return 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
         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,
-                actual_filename,
-                expected_filename]
+        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, 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)
+        wdiff = self._executive.run_command(command, decode_output=False, error_handler=self._handle_wdiff_error)
         return self._format_wdiff_output_as_html(wdiff)
 
     _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 ""
@@ skipping 12 matching lines @@
             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."
 
     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),
-                   self._pretty_patch_path, diff_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:
             # 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))
             return self._pretty_patch_error_html
         except ScriptError, e:
@@ skipping 104 matching lines @@
             return 'AddressSanitizer'
         if 'MemorySanitizer' in output:
             return 'MemorySanitizer'
         return None
 
     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.
 
-            llvm_symbolizer_path = self.path_from_chromium_base('third_party', 'llvm-build', 'Release+Asserts', 'bin', 'llvm-symbolizer')
+            llvm_symbolizer_path = self.path_from_chromium_base('third_party', 'llvm-build', 'Release+Asserts', 'bin',
+                                                                'llvm-symbolizer')
             if self._filesystem.exists(llvm_symbolizer_path):
                 env = os.environ.copy()
                 env['LLVM_SYMBOLIZER_PATH'] = llvm_symbolizer_path
             else:
                 env = None
             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, env=env)
+                stderr = self._executive.run_command(
+                    ['flock', sys.executable, sanitizer_filter_path, sanitizer_strip_path_prefix],
+                    input=stderr,
+                    decode_output=False,
+                    env=env)
 
         name_str = name or '<unknown process name>'
         pid_str = str(pid or '<unknown>')
 
         # We require stdout and stderr to be bytestrings, not character strings.
         if stdout:
             assert isinstance(stdout, str)
             stdout_lines = stdout.decode('utf8', 'replace').splitlines()
         else:
             stdout_lines = [u'<empty>']
         if stderr:
             assert isinstance(stderr, str)
             stderr_lines = stderr.decode('utf8', 'replace').splitlines()
         else:
             stderr_lines = [u'<empty>']
 
-        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)))
+        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)))
 
     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
 
@@ skipping 105 matching lines @@
 
     # 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"],
-            }
+            return {"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_target(self._options.target, *comps)
 
     def _build_path_with_target(self, target, *comps):
         # Note that we don't do the option caching that the
         # base class does, because finding the right directory is relatively
         # fast.
         target = target or self.get_option('target')
-        return self._static_build_path(self._filesystem, self.get_option('build_directory'),
-                                       self.path_from_chromium_base(), target, comps)
+        return self._static_build_path(self._filesystem, self.get_option('build_directory'), self.path_from_chromium_base(), target,
+                                       comps)
 
     def _check_driver_build_up_to_date(self, target):
         # We should probably get rid of this check altogether as it has
         # outlived its usefulness in a GN-based world, but for the moment
         # we will just check things if they are using the standard
         # Debug or Release target directories.
         if target not in ('Debug', 'Release'):
             return True
 
         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 target == 'Release' or
-                    release_mtime > debug_mtime and target == 'Debug'):
+            if (debug_mtime > release_mtime and target == 'Release' or release_mtime > debug_mtime and target == 'Debug'):
                 most_recent_binary = 'Release' if target == 'Debug' else 'Debug'
                 _log.warning('You are running the %s binary. However the %s binary appears to be more recent. '
                              'Please pass --%s.', target, 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
@@ skipping 22 matching lines @@
 class PhysicalTestSuite(object):
     def __init__(self, base, args, reference_args=None):
         self.name = base
         self.base = base
         self.args = args
         self.reference_args = args if reference_args is None else reference_args
         self.tests = set()
 
     def __repr__(self):
         return "PhysicalTestSuite('%s', '%s', %s, %s)" % (self.name, self.base, self.args, self.reference_args)