Run auto-formatter (autopep8) on webkitpy.

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

 # Copyright (C) 2010 Chris Jerdonek (cjerdonek@webkit.org)
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
 # are met:
 # 1.  Redistributions of source code must retain the above copyright
 #     notice, this list of conditions and the following disclaimer.
 # 2.  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.
@@ skipping 37 matching lines @@
 
     def _mock_stderr_write(self, message):
         self._error_messages.append(message)
 
     def _style_checker_configuration(self):
         """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/tab": 2},
-                   min_confidence=3,
-                   output_format="vs7",
-                   stderr_write=self._mock_stderr_write)
+            filter_configuration=filter_configuration,
+            max_reports_per_category={"whitespace/tab": 2},
+            min_confidence=3,
+            output_format="vs7",
+            stderr_write=self._mock_stderr_write)
 
     def _error_handler(self, configuration, line_numbers=None):
         return DefaultStyleErrorHandler(configuration=configuration,
-                   file_path=self._file_path,
-                   increment_error_count=self._mock_increment_error_count,
-                   line_numbers=line_numbers)
+                                        file_path=self._file_path,
+                                        increment_error_count=self._mock_increment_error_count,
+                                        line_numbers=line_numbers)
 
     def _check_initialized(self):
         """Check that count and error messages are initialized."""
         self.assertEqual(0, self._error_count)
         self.assertEqual(0, len(self._error_messages))
 
     def _call_error_handler(self, handle_error, confidence, line_number=100):
         """Call the given error handler with a test error."""
         handle_error(line_number=line_number,
                      category=self._category,
                      confidence=confidence,
                      message="message")
 
     def test_eq__true_return_value(self):
         """Test the __eq__() method for the return value of True."""
         handler1 = self._error_handler(configuration=None)
         handler2 = self._error_handler(configuration=None)
 
         self.assertTrue(handler1.__eq__(handler2))
 
     def test_eq__false_return_value(self):
         """Test the __eq__() method for the return value of False."""
         def make_handler(configuration=self._style_checker_configuration(),
-                file_path='foo.txt', increment_error_count=lambda: True,
-                line_numbers=[100]):
+                         file_path='foo.txt', increment_error_count=lambda: True,
+                         line_numbers=[100]):
             return DefaultStyleErrorHandler(configuration=configuration,
-                       file_path=file_path,
-                       increment_error_count=increment_error_count,
-                       line_numbers=line_numbers)
+                                            file_path=file_path,
+                                            increment_error_count=increment_error_count,
+                                            line_numbers=line_numbers)
 
         handler = make_handler()
 
         # Establish a baseline for our comparisons below.
         self.assertTrue(handler.__eq__(make_handler()))
 
         # Verify that a difference in any argument causes equality to fail.
         self.assertFalse(handler.__eq__(make_handler(configuration=None)))
         self.assertFalse(handler.__eq__(make_handler(file_path='bar.txt')))
         self.assertFalse(handler.__eq__(make_handler(increment_error_count=None)))
@@ skipping 32 matching lines @@
         configuration = self._style_checker_configuration()
         error_handler = self._error_handler(configuration)
 
         confidence = 5
 
         # First call: usual reporting.
         self._call_error_handler(error_handler, confidence)
         self.assertEqual(1, self._error_count)
         self.assertEqual(1, len(self._error_messages))
         self.assertEqual(self._error_messages,
-                          ["foo.h(100):  message  [whitespace/tab] [5]\n"])
+                         ["foo.h(100):  message  [whitespace/tab] [5]\n"])
 
         # Second call: suppression message reported.
         self._call_error_handler(error_handler, confidence)
         # The "Suppressing further..." message counts as an additional
         # message (but not as an addition to the error count).
         self.assertEqual(2, self._error_count)
         self.assertEqual(3, len(self._error_messages))
         self.assertEqual(self._error_messages[-2],
-                          "foo.h(100):  message  [whitespace/tab] [5]\n")
+                         "foo.h(100):  message  [whitespace/tab] [5]\n")
         self.assertEqual(self._error_messages[-1],
-                          "Suppressing further [whitespace/tab] reports "
-                          "for this file.\n")
+                         "Suppressing further [whitespace/tab] reports "
+                         "for this file.\n")
 
         # Third call: no report.
         self._call_error_handler(error_handler, confidence)
         self.assertEqual(3, self._error_count)
         self.assertEqual(3, len(self._error_messages))
 
     def test_line_numbers(self):
         """Test the line_numbers parameter."""
         self._check_initialized()
         configuration = self._style_checker_configuration()
         error_handler = self._error_handler(configuration,
                                             line_numbers=[50])
         confidence = 5
 
         # Error on non-modified line: no error.
         self._call_error_handler(error_handler, confidence, line_number=60)
         self.assertEqual(0, self._error_count)
         self.assertEqual([], self._error_messages)
 
         # Error on modified line: error.
         self._call_error_handler(error_handler, confidence, line_number=50)
         self.assertEqual(1, self._error_count)
         self.assertEqual(self._error_messages,
-                          ["foo.h(50):  message  [whitespace/tab] [5]\n"])
+                         ["foo.h(50):  message  [whitespace/tab] [5]\n"])
 
         # Error on non-modified line after turning off line filtering: error.
         error_handler.turn_off_line_filtering()
         self._call_error_handler(error_handler, confidence, line_number=60)
         self.assertEqual(2, self._error_count)
         self.assertEqual(self._error_messages,
-                          ['foo.h(50):  message  [whitespace/tab] [5]\n',
-                           'foo.h(60):  message  [whitespace/tab] [5]\n',
-                           'Suppressing further [whitespace/tab] reports for this file.\n'])
+                         ['foo.h(50):  message  [whitespace/tab] [5]\n',
+                          'foo.h(60):  message  [whitespace/tab] [5]\n',
+                          'Suppressing further [whitespace/tab] reports for this file.\n'])