Run auto-formatter (autopep8) on webkitpy.

third_party/WebKit/Tools/Scripts/webkitpy/style/checker_unittest.py

 # -*- coding: utf-8; -*-
 #
 # Copyright (C) 2009 Google Inc. All rights reserved.
 # Copyright (C) 2009 Torch Mobile Inc.
 # Copyright (C) 2009 Apple Inc. All rights reserved.
 # Copyright (C) 2010 Chris Jerdonek (chris.jerdonek@gmail.com)
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
@@ skipping 239 matching lines @@
 
     """Tests the "should skip" methods of the CheckerDispatcher class."""
 
     def setUp(self):
         self._dispatcher = CheckerDispatcher()
 
     def test_should_skip_with_warning(self):
         """Test should_skip_with_warning()."""
         # Check skipped files.
         paths_to_skip = [
-           "Source/WebKit/gtk/tests/testatk.c",
-           "Source/WebKit2/UIProcess/API/gtk/webkit2.h",
-           "Source/WebKit2/UIProcess/API/gtk/WebKitWebView.h",
-           "Source/WebKit2/UIProcess/API/gtk/WebKitLoader.h",
-            ]
+            "Source/WebKit/gtk/tests/testatk.c",
+            "Source/WebKit2/UIProcess/API/gtk/webkit2.h",
+            "Source/WebKit2/UIProcess/API/gtk/WebKitWebView.h",
+            "Source/WebKit2/UIProcess/API/gtk/WebKitLoader.h",
+        ]
 
         for path in paths_to_skip:
             self.assertTrue(self._dispatcher.should_skip_with_warning(path),
                             "Checking: " + path)
 
         # Verify that some files are not skipped.
         paths_not_to_skip = [
-           "foo.txt",
-           "Source/WebKit2/UIProcess/API/gtk/HelperClass.cpp",
-           "Source/WebKit2/UIProcess/API/gtk/HelperClass.h",
-           "Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp",
-           "Source/WebKit2/UIProcess/API/gtk/WebKitWebViewPrivate.h",
-           "Source/WebKit2/UIProcess/API/gtk/tests/WebViewTest.cpp",
-           "Source/WebKit2/UIProcess/API/gtk/tests/WebViewTest.h",
-            ]
+            "foo.txt",
+            "Source/WebKit2/UIProcess/API/gtk/HelperClass.cpp",
+            "Source/WebKit2/UIProcess/API/gtk/HelperClass.h",
+            "Source/WebKit2/UIProcess/API/gtk/WebKitWebView.cpp",
+            "Source/WebKit2/UIProcess/API/gtk/WebKitWebViewPrivate.h",
+            "Source/WebKit2/UIProcess/API/gtk/tests/WebViewTest.cpp",
+            "Source/WebKit2/UIProcess/API/gtk/tests/WebViewTest.h",
+        ]
 
         for path in paths_not_to_skip:
             self.assertFalse(self._dispatcher.should_skip_with_warning(path))
 
     def _assert_should_skip_without_warning(self, path, is_checker_none,
                                             expected):
         # Check the file type before asserting the return value.
         checker = self._dispatcher.dispatch(file_path=path,
                                             handle_style_error=None,
                                             min_confidence=3)
         message = 'while checking: %s' % path
         self.assertEqual(checker is None, is_checker_none, message)
         self.assertEqual(self._dispatcher.should_skip_without_warning(path),
-                          expected, message)
+                         expected, message)
 
     def test_should_skip_without_warning__true(self):
         """Test should_skip_without_warning() for True return values."""
         # Check a file with NONE file type.
         path = 'foo.asdf'  # Non-sensical file extension.
         self._assert_should_skip_without_warning(path,
                                                  is_checker_none=True,
                                                  expected=True)
 
         # Check files with non-NONE file type.  These examples must be
         # drawn from the _SKIPPED_FILES_WITHOUT_WARNING configuration
         # variable.
         path = os.path.join('LayoutTests', 'foo.txt')
         self._assert_should_skip_without_warning(path,
                                                  is_checker_none=False,
                                                  expected=True)
 
     def test_should_skip_without_warning__false(self):
         """Test should_skip_without_warning() for False return values."""
         paths = ['foo.txt',
                  os.path.join('LayoutTests', 'TestExpectations'),
-        ]
+                 ]
 
         for path in paths:
             self._assert_should_skip_without_warning(path,
                                                      is_checker_none=False,
                                                      expected=False)
 
 
 class CheckerDispatcherCarriageReturnTest(unittest.TestCase):
+
     def test_should_check_and_strip_carriage_returns(self):
         files = {
             'foo.txt': True,
             'foo.cpp': True,
             'foo.vcproj': False,
             'foo.vsprops': False,
         }
 
         dispatcher = CheckerDispatcher()
         for file_path, expected_result in files.items():
-            self.assertEqual(dispatcher.should_check_and_strip_carriage_returns(file_path), expected_result, 'Checking: %s' % file_path)
+            self.assertEqual(dispatcher.should_check_and_strip_carriage_returns(
+                file_path), expected_result, 'Checking: %s' % file_path)
 
 
 class CheckerDispatcherDispatchTest(unittest.TestCase):
 
     """Tests dispatch() method of CheckerDispatcher class."""
 
     def dispatch(self, file_path):
         """Call dispatch() with the given file path."""
         dispatcher = CheckerDispatcher()
         self.mock_handle_style_error = DefaultStyleErrorHandler('', None, None, [])
         checker = dispatcher.dispatch(file_path,
                                       self.mock_handle_style_error,
                                       min_confidence=3)
         return checker
 
     def assert_checker_none(self, file_path):
         """Assert that the dispatched checker is None."""
         checker = self.dispatch(file_path)
         self.assertIsNone(checker, 'Checking: "%s"' % file_path)
 
     def assert_checker(self, file_path, expected_class):
         """Assert the type of the dispatched checker."""
         checker = self.dispatch(file_path)
         got_class = checker.__class__
         self.assertEqual(got_class, expected_class,
-                          'For path "%(file_path)s" got %(got_class)s when '
-                          "expecting %(expected_class)s."
-                          % {"file_path": file_path,
+                         'For path "%(file_path)s" got %(got_class)s when '
+                         "expecting %(expected_class)s."
+                         % {"file_path": file_path,
                              "got_class": got_class,
                              "expected_class": expected_class})
 
     def assert_checker_cpp(self, file_path):
         """Assert that the dispatched checker is a CppChecker."""
         self.assert_checker(file_path, CppChecker)
 
     def assert_checker_json(self, file_path):
         """Assert that the dispatched checker is a JSONChecker."""
         self.assert_checker(file_path, JSONChecker)
@@ skipping 10 matching lines @@
         """Assert that the dispatched checker is a XMLChecker."""
         self.assert_checker(file_path, XMLChecker)
 
     def test_cpp_paths(self):
         """Test paths that should be checked as C++."""
         paths = [
             "-",
             "foo.c",
             "foo.cpp",
             "foo.h",
-            ]
+        ]
 
         for path in paths:
             self.assert_checker_cpp(path)
 
         # Check checker attributes on a typical input.
         file_base = "foo"
         file_extension = "c"
         file_path = file_base + "." + file_extension
         self.assert_checker_cpp(file_path)
         checker = self.dispatch(file_path)
         self.assertEqual(checker.file_extension, file_extension)
         self.assertEqual(checker.file_path, file_path)
         self.assertEqual(checker.handle_style_error, self.mock_handle_style_error)
         self.assertEqual(checker.min_confidence, 3)
         # Check "-" for good measure.
         file_base = "-"
         file_extension = ""
         file_path = file_base
         self.assert_checker_cpp(file_path)
         checker = self.dispatch(file_path)
         self.assertEqual(checker.file_extension, file_extension)
         self.assertEqual(checker.file_path, file_path)
 
     def test_json_paths(self):
         """Test paths that should be checked as JSON."""
         paths = [
-           "Source/WebCore/inspector/Inspector.json",
-           "Tools/BuildSlaveSupport/build.webkit.org-config/config.json",
+            "Source/WebCore/inspector/Inspector.json",
+            "Tools/BuildSlaveSupport/build.webkit.org-config/config.json",
         ]
 
         for path in paths:
             self.assert_checker_json(path)
 
         # Check checker attributes on a typical input.
         file_base = "foo"
         file_extension = "json"
         file_path = file_base + "." + file_extension
         self.assert_checker_json(file_path)
         checker = self.dispatch(file_path)
         self.assertEqual(checker._handle_style_error,
-                          self.mock_handle_style_error)
+                         self.mock_handle_style_error)
 
     def test_python_paths(self):
         """Test paths that should be checked as Python."""
         paths = [
-           "foo.py",
-           "Tools/Scripts/modules/text_style.py",
+            "foo.py",
+            "Tools/Scripts/modules/text_style.py",
         ]
 
         for path in paths:
             self.assert_checker_python(path)
 
         # Check checker attributes on a typical input.
         file_base = "foo"
         file_extension = "css"
         file_path = file_base + "." + file_extension
         self.assert_checker_text(file_path)
         checker = self.dispatch(file_path)
         self.assertEqual(checker.file_path, file_path)
         self.assertEqual(checker.handle_style_error,
-                          self.mock_handle_style_error)
+                         self.mock_handle_style_error)
 
     def test_text_paths(self):
         """Test paths that should be checked as text."""
         paths = [
-           "foo.cc",
-           "foo.cgi",
-           "foo.css",
-           "foo.gyp",
-           "foo.gypi",
-           "foo.html",
-           "foo.idl",
-           "foo.in",
-           "foo.js",
-           "foo.mm",
-           "foo.php",
-           "foo.pl",
-           "foo.pm",
-           "foo.rb",
-           "foo.sh",
-           "foo.txt",
-           "foo.xhtml",
-           "foo.y",
-           os.path.join("Source", "WebCore", "inspector", "front-end", "Main.js"),
-           os.path.join("Tools", "Scripts", "check-webkit-style"),
+            "foo.cc",
+            "foo.cgi",
+            "foo.css",
+            "foo.gyp",
+            "foo.gypi",
+            "foo.html",
+            "foo.idl",
+            "foo.in",
+            "foo.js",
+            "foo.mm",
+            "foo.php",
+            "foo.pl",
+            "foo.pm",
+            "foo.rb",
+            "foo.sh",
+            "foo.txt",
+            "foo.xhtml",
+            "foo.y",
+            os.path.join("Source", "WebCore", "inspector", "front-end", "Main.js"),
+            os.path.join("Tools", "Scripts", "check-webkit-style"),
         ]
 
         for path in paths:
             self.assert_checker_text(path)
 
         # Check checker attributes on a typical input.
         file_base = "foo"
         file_extension = "css"
         file_path = file_base + "." + file_extension
         self.assert_checker_text(file_path)
         checker = self.dispatch(file_path)
         self.assertEqual(checker.file_path, file_path)
         self.assertEqual(checker.handle_style_error, self.mock_handle_style_error)
 
     def test_xml_paths(self):
         """Test paths that should be checked as XML."""
         paths = [
-           "Source/WebCore/WebCore.vcproj/WebCore.vcproj",
-           "WebKitLibraries/win/tools/vsprops/common.vsprops",
+            "Source/WebCore/WebCore.vcproj/WebCore.vcproj",
+            "WebKitLibraries/win/tools/vsprops/common.vsprops",
         ]
 
         for path in paths:
             self.assert_checker_xml(path)
 
         # Check checker attributes on a typical input.
         file_base = "foo"
         file_extension = "vcproj"
         file_path = file_base + "." + file_extension
         self.assert_checker_xml(file_path)
         checker = self.dispatch(file_path)
         self.assertEqual(checker._handle_style_error,
-                          self.mock_handle_style_error)
+                         self.mock_handle_style_error)
 
     def test_none_paths(self):
         """Test paths that have no file type.."""
         paths = [
-           "Makefile",
-           "foo.asdf",  # Non-sensical file extension.
-           "foo.exe",
-            ]
+            "Makefile",
+            "foo.asdf",  # Non-sensical file extension.
+            "foo.exe",
+        ]
 
         for path in paths:
             self.assert_checker_none(path)
 
 
 class StyleProcessorConfigurationTest(unittest.TestCase):
 
     """Tests the StyleProcessorConfiguration class."""
 
     def setUp(self):
         self._error_messages = []
         """The messages written to _mock_stderr_write() of this class."""
 
     def _mock_stderr_write(self, message):
         self._error_messages.append(message)
 
     def _style_checker_configuration(self, output_format="vs7"):
         """Return a StyleProcessorConfiguration instance for testing."""
         base_rules = ["-whitespace", "+whitespace/tab"]
         filter_configuration = FilterConfiguration(base_rules=base_rules)
 
         return StyleProcessorConfiguration(
-                   filter_configuration=filter_configuration,
-                   max_reports_per_category={"whitespace/newline": 1},
-                   min_confidence=3,
-                   output_format=output_format,
-                   stderr_write=self._mock_stderr_write)
+            filter_configuration=filter_configuration,
+            max_reports_per_category={"whitespace/newline": 1},
+            min_confidence=3,
+            output_format=output_format,
+            stderr_write=self._mock_stderr_write)
 
     def test_init(self):
         """Test the __init__() method."""
         configuration = self._style_checker_configuration()
 
         # Check that __init__ sets the "public" data attributes correctly.
         self.assertEqual(configuration.max_reports_per_category,
-                          {"whitespace/newline": 1})
+                         {"whitespace/newline": 1})
         self.assertEqual(configuration.stderr_write, self._mock_stderr_write)
         self.assertEqual(configuration.min_confidence, 3)
 
     def test_is_reportable(self):
         """Test the is_reportable() method."""
         config = self._style_checker_configuration()
 
         self.assertTrue(config.is_reportable("whitespace/tab", 3, "foo.txt"))
 
         # Test the confidence check code path by varying the confidence.
         self.assertFalse(config.is_reportable("whitespace/tab", 2, "foo.txt"))
 
         # Test the category check code path by varying the category.
         self.assertFalse(config.is_reportable("whitespace/line", 4, "foo.txt"))
 
     def _call_write_style_error(self, output_format):
         config = self._style_checker_configuration(output_format=output_format)
         config.write_style_error(category="whitespace/tab",
                                  confidence_in_error=5,
                                  file_path="foo.h",
                                  line_number=100,
                                  message="message")
 
     def test_write_style_error_emacs(self):
         """Test the write_style_error() method."""
         self._call_write_style_error("emacs")
         self.assertEqual(self._error_messages,
-                          ["foo.h:100:  message  [whitespace/tab] [5]\n"])
+                         ["foo.h:100:  message  [whitespace/tab] [5]\n"])
 
     def test_write_style_error_vs7(self):
         """Test the write_style_error() method."""
         self._call_write_style_error("vs7")
         self.assertEqual(self._error_messages,
-                          ["foo.h(100):  message  [whitespace/tab] [5]\n"])
+                         ["foo.h(100):  message  [whitespace/tab] [5]\n"])
 
 
 class StyleProcessor_EndToEndTest(LoggingTestCase):
 
     """Test the StyleProcessor class with an emphasis on end-to-end tests."""
 
     def setUp(self):
         LoggingTestCase.setUp(self)
         self._messages = []
 
     def _mock_stderr_write(self, message):
         """Save a message so it can later be asserted."""
         self._messages.append(message)
 
     def test_init(self):
         """Test __init__ constructor."""
         configuration = StyleProcessorConfiguration(
-                            filter_configuration=FilterConfiguration(),
-                            max_reports_per_category={},
-                            min_confidence=3,
-                            output_format="vs7",
-                            stderr_write=self._mock_stderr_write)
+            filter_configuration=FilterConfiguration(),
+            max_reports_per_category={},
+            min_confidence=3,
+            output_format="vs7",
+            stderr_write=self._mock_stderr_write)
         processor = StyleProcessor(configuration)
 
         self.assertEqual(processor.error_count, 0)
         self.assertEqual(self._messages, [])
 
     def test_process(self):
         configuration = StyleProcessorConfiguration(
-                            filter_configuration=FilterConfiguration(),
-                            max_reports_per_category={},
-                            min_confidence=3,
-                            output_format="vs7",
-                            stderr_write=self._mock_stderr_write)
+            filter_configuration=FilterConfiguration(),
+            max_reports_per_category={},
+            min_confidence=3,
+            output_format="vs7",
+            stderr_write=self._mock_stderr_write)
         processor = StyleProcessor(configuration)
 
         processor.process(lines=['line1', 'Line with tab:\t'],
                           file_path='foo.txt')
         self.assertEqual(processor.error_count, 1)
         expected_messages = ['foo.txt(2):  Line contains tab character.  '
                              '[whitespace/tab] [5]\n']
         self.assertEqual(self._messages, expected_messages)
 
 
@@ skipping 31 matching lines @@
             return file_path.endswith('skip_without_warning.txt')
 
         def should_check_and_strip_carriage_returns(self, file_path):
             return not file_path.endswith('carriage_returns_allowed.txt')
 
         def dispatch(self, file_path, style_error_handler, min_confidence):
             if file_path.endswith('do_not_process.txt'):
                 return None
 
             checker = StyleProcessor_CodeCoverageTest.MockDispatchedChecker(
-                          file_path,
-                          min_confidence,
-                          style_error_handler)
+                file_path,
+                min_confidence,
+                style_error_handler)
 
             # Save the dispatched checker so the current test case has a
             # way to access and check it.
             self.dispatched_checker = checker
 
             return checker
 
     def setUp(self):
         LoggingTestCase.setUp(self)
         # We can pass an error-message swallower here because error message
         # output is tested instead in the end-to-end test case above.
         configuration = StyleProcessorConfiguration(
-                            filter_configuration=FilterConfiguration(),
-                            max_reports_per_category={"whitespace/newline": 1},
-                            min_confidence=3,
-                            output_format="vs7",
-                            stderr_write=self._swallow_stderr_message)
+            filter_configuration=FilterConfiguration(),
+            max_reports_per_category={"whitespace/newline": 1},
+            min_confidence=3,
+            output_format="vs7",
+            stderr_write=self._swallow_stderr_message)
 
         mock_carriage_checker_class = self._create_carriage_checker_class()
         mock_dispatcher = self.MockDispatcher()
         # We do not need to use a real incrementer here because error-count
         # incrementing is tested instead in the end-to-end test case above.
         mock_increment_error_count = self._do_nothing
 
         processor = StyleProcessor(configuration=configuration,
-                        mock_carriage_checker_class=mock_carriage_checker_class,
-                        mock_dispatcher=mock_dispatcher,
-                        mock_increment_error_count=mock_increment_error_count)
+                                   mock_carriage_checker_class=mock_carriage_checker_class,
+                                   mock_dispatcher=mock_dispatcher,
+                                   mock_increment_error_count=mock_increment_error_count)
 
         self._configuration = configuration
         self._mock_dispatcher = mock_dispatcher
         self._processor = processor
 
     def _do_nothing(self):
         # We provide this function so the caller can pass it to the
         # StyleProcessor constructor.  This lets us assert the equality of
         # the DefaultStyleErrorHandler instance generated by the process()
         # method with an expected instance.
@@ skipping 65 matching lines @@
             line_numbers=line_numbers)
 
         self._processor.process(lines=lines,
                                 file_path=file_path,
                                 line_numbers=line_numbers)
 
         # Check that the carriage-return checker was instantiated correctly
         # and was passed lines correctly.
         carriage_checker = self.carriage_checker
         self.assertEqual(carriage_checker.style_error_handler,
-                          expected_error_handler)
+                         expected_error_handler)
         self.assertEqual(carriage_checker.lines, ['line1', 'line2'])
 
         # Check that the style checker was dispatched correctly and was
         # passed lines correctly.
         checker = self._mock_dispatcher.dispatched_checker
         self.assertEqual(checker.file_path, 'foo.txt')
         self.assertEqual(checker.min_confidence, 3)
         self.assertEqual(checker.style_error_handler, expected_error_handler)
 
         self.assertEqual(checker.lines, ['line1', 'line2'])
 
     def test_process__no_checker_dispatched(self):
         """Test the process() method for a path with no dispatched checker."""
         path = os.path.join('foo', 'do_not_process.txt')
         self.assertRaises(AssertionError, self._processor.process,
                           lines=['line1', 'line2'], file_path=path,
                           line_numbers=[100])
 
     def test_process__carriage_returns_not_stripped(self):
         """Test that carriage returns aren't stripped from files that are allowed to contain them."""
         file_path = 'carriage_returns_allowed.txt'
         lines = ['line1\r', 'line2\r']
         line_numbers = [100]
         self._processor.process(lines=lines,
                                 file_path=file_path,
                                 line_numbers=line_numbers)
         # The carriage return checker should never have been invoked, and so
         # should not have saved off any lines.
         self.assertFalse(hasattr(self.carriage_checker, 'lines'))