Change logging statements to not use the "%" operator.

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
@@ skipping 315 matching lines @@
             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.
             more_logging: Whether or not to log the error messages.
 
         Returns:
             True if the file exists, else False.
         """
         if not self._filesystem.exists(path_to_file):
             if more_logging:
-                _log.error('Unable to find %s' % file_description)
-                _log.error('    at %s' % path_to_file)
+                _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('    %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
@@ skipping 19 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):
         """Checks whether the system is properly configured.
 
@@ skipping 21 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):
         """Checks 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, more_logging=True):
         """Checks whether we can use the PrettyPatch ruby script."""
         try:
             _ = self._executive.run_command(['ruby', '--version'])
         except OSError as e:
             if e.errno in [errno.ENOENT, errno.EACCES, errno.ECHILD]:
                 if more_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 more_logging:
-                _log.warning("Unable to find %s; can't generate pretty patches." % self._pretty_patch_path)
+                _log.warning("Unable to find %s; can't generate pretty patches.", self._pretty_patch_path)
                 _log.warning('')
             return False
 
         return True
 
     def check_wdiff(self, more_logging=True):
         if not self._path_to_wdiff():
             # Don't need to log here since this is the port choosing not to use wdiff.
             return False
 
@@ skipping 269 matching lines @@
         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))
+                _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)))
         return parsed_list
 
     def reference_files(self, test_name):
         """Return a list of expectation (== or !=) and filename pairs"""
@@ skipping 195 matching lines @@
             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")
             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 160 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)
             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."""
@@ skipping 146 matching lines @@
         # FIXME: rename this to test_expectations() once all the callers are updated to know about the ordered dict.
         expectations = collections.OrderedDict()
 
         for path in self.expectations_files():
             if self._filesystem.exists(path):
                 expectations[path] = self._filesystem.read_text_file(path)
 
         for path in self.get_option('additional_expectations', []):
             expanded_path = self._filesystem.expanduser(path)
             if self._filesystem.exists(expanded_path):
-                _log.debug("reading additional_expectations from path '%s'" % path)
+                _log.debug("reading additional_expectations from path '%s'", path)
                 expectations[path] = self._filesystem.read_text_file(expanded_path)
             else:
-                _log.warning("additional_expectations path '%s' does not exist" % path)
+                _log.warning("additional_expectations path '%s' does not exist", path)
         return expectations
 
     def bot_expectations(self):
         if not self.get_option('ignore_flaky_tests'):
             return {}
 
         full_port_name = self.determine_full_port_name(self.host, self._options, self.port_name)
         builder_category = self.get_option('ignore_builder_category', 'layout')
         factory = BotTestExpectationsFactory(self.host.builders)
         # FIXME: This only grabs release builder's flakiness data. If we're running debug,
         # when we should grab the debug builder's data.
         expectations = factory.expectations_for_port(full_port_name, builder_category)
 
         if not expectations:
             return {}
 
         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)
+        _log.warning("Unexpected ignore mode: '%s'.", ignore_mode)
         return {}
 
     def expectations_files(self):
         paths = [
             self.path_to_generic_test_expectations_file(),
             self._filesystem.join(self.layout_tests_dir(), 'NeverFixTests'),
             self._filesystem.join(self.layout_tests_dir(), 'StaleTestExpectations'),
             self._filesystem.join(self.layout_tests_dir(), 'SlowTests'),
         ]
         if self.is_wptserve_enabled():
@@ skipping 56 matching lines @@
         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 ""
             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."
 
     def pretty_patch_text(self, diff_path):
         if self._pretty_patch_available is None:
             self._pretty_patch_available = self.check_pretty_patch(more_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)
         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 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 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 'Release'
 
     def clobber_old_port_specific_results(self):
         pass
 
     # FIXME: This does not belong on the port object.
     @memoized
@@ skipping 235 matching lines @@
         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 as e:
-                _log.warn("Failed to run nm: %s.  Can't determine supported features correctly." % e)
+                _log.warning("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 {}
@@ skipping 97 matching lines @@
 
     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)