Clean up most style warnings in webkitpy/style/checker_unittest.py.

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 19 matching lines @@
 # 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.
 
 """Unit tests for style.py."""
 
 import logging
 import os
 import unittest
 
-import checker as style
-from webkitpy.common.system.logtesting import LogTesting
+from webkitpy.common.system.logtesting import LoggingTestCase
 from webkitpy.common.system.logtesting import TestLogStream
-from checker import _BASE_FILTER_RULES
-from checker import _MAX_REPORTS_PER_CATEGORY
-from checker import _PATH_RULES_SPECIFIER as PATH_RULES_SPECIFIER
-from checker import _all_categories
-from checker import check_webkit_style_configuration
-from checker import check_webkit_style_parser
-from checker import configure_logging
-from checker import CheckerDispatcher
-from checker import ProcessorBase
-from checker import StyleProcessor
-from checker import StyleProcessorConfiguration
-from checkers.cpp import CppChecker
-from checkers.jsonchecker import JSONChecker
-from checkers.python import PythonChecker
-from checkers.text import TextChecker
-from checkers.xml import XMLChecker
-from error_handlers import DefaultStyleErrorHandler
-from filter import validate_filter_rules
-from filter import FilterConfiguration
-from optparser import ArgumentParser
-from optparser import CommandOptionValues
-from webkitpy.common.system.logtesting import LoggingTestCase
-from webkitpy.style.filereader import TextFileReader
+from webkitpy.style import checker as style
+from webkitpy.style.checker import _all_categories
+from webkitpy.style.checker import _BASE_FILTER_RULES
+from webkitpy.style.checker import _MAX_REPORTS_PER_CATEGORY
+from webkitpy.style.checker import _PATH_RULES_SPECIFIER as PATH_RULES_SPECIFIER
+from webkitpy.style.checker import check_webkit_style_configuration
+from webkitpy.style.checker import check_webkit_style_parser
+from webkitpy.style.checker import CheckerDispatcher
+from webkitpy.style.checker import configure_logging
+from webkitpy.style.checker import StyleProcessor
+from webkitpy.style.checker import StyleProcessorConfiguration
+from webkitpy.style.checkers.cpp import CppChecker
+from webkitpy.style.checkers.jsonchecker import JSONChecker
+from webkitpy.style.checkers.python import PythonChecker
+from webkitpy.style.checkers.text import TextChecker
+from webkitpy.style.checkers.xml import XMLChecker
+from webkitpy.style.error_handlers import DefaultStyleErrorHandler
+from webkitpy.style.filter import FilterConfiguration
+from webkitpy.style.filter import validate_filter_rules
+from webkitpy.style.optparser import ArgumentParser
+from webkitpy.style.optparser import CommandOptionValues
 
 
 class ConfigureLoggingTestBase(unittest.TestCase):
 
     """Base class for testing configure_logging().
 
     Sub-classes should implement:
 
       is_verbose: The is_verbose value to pass to configure_logging().
     """
 
+    is_verbose = False

[qyearsley, 2016/09/27 17:15:31]

Adding this line adds a default value for self.is_verbose, which is used in
setUp.

+
     def setUp(self):
         is_verbose = self.is_verbose
 
         log_stream = TestLogStream(self)
 
         # Use a logger other than the root logger or one prefixed with
         # webkit so as not to conflict with test-webkitpy logging.
         logger = logging.getLogger("unittest")
 
         # Configure the test logger not to pass messages along to the
@@ skipping 100 matching lines @@
         #
         # The default options are valid: no error or SystemExit.
         parser.parse(args=[])
 
     def test_path_rules_specifier(self):
         for _, path_rules in PATH_RULES_SPECIFIER:
             validate_filter_rules(path_rules, self._all_categories())
 
         config = FilterConfiguration(path_specific=PATH_RULES_SPECIFIER)
 
-        def assertCheck(path, category):
+        def assert_check(path, category):
             """Assert that the given category should be checked."""
             self.assertTrue(config.should_check(category, path))
 
-        def assertNoCheck(path, category):
+        def assert_no_check(path, category):
             """Assert that the given category should not be checked."""
             message = ('Should not check category "%s" for path "%s".'
                        % (category, path))
             self.assertFalse(config.should_check(category, path), message)
 
-        assertCheck("random_path.cpp",
+        assert_check("random_path.cpp",
                     "build/include")
-        assertCheck("random_path.cpp",
+        assert_check("random_path.cpp",
                     "readability/naming")
-        assertNoCheck("Source/core/css/CSSParser-in.cpp",
+        assert_no_check("Source/core/css/CSSParser-in.cpp",
                       "readability/naming")
 
         # Third-party Python code: webkitpy/thirdparty
         path = "Tools/Scripts/webkitpy/thirdparty/mock.py"
-        assertNoCheck(path, "build/include")
-        assertNoCheck(path, "pep8/E401")  # A random pep8 category.
-        assertCheck(path, "pep8/W191")
-        assertCheck(path, "pep8/W291")
-        assertCheck(path, "whitespace/carriage_return")
+        assert_no_check(path, "build/include")
+        assert_no_check(path, "pep8/E401")  # A random pep8 category.
+        assert_check(path, "pep8/W191")
+        assert_check(path, "pep8/W291")
+        assert_check(path, "whitespace/carriage_return")

[qyearsley, 2016/09/27 17:15:31]

These helper function names are changed to fit the general name convention of
lower_with_underscore.

 
     def test_max_reports_per_category(self):
         """Check that _MAX_REPORTS_PER_CATEGORY is valid."""
         all_categories = self._all_categories()
         for category in _MAX_REPORTS_PER_CATEGORY.iterkeys():
             self.assertIn(category, all_categories,
                           'Key "%s" is not a category' % category)
 
 
 class CheckWebKitStyleFunctionTest(unittest.TestCase):
@@ skipping 285 matching lines @@
 
         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."""
+        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(
@@ skipping 96 matching lines @@
     """
 
     class MockDispatchedChecker(object):
 
         """A mock checker dispatched by the MockDispatcher."""
 
         def __init__(self, file_path, min_confidence, style_error_handler):
             self.file_path = file_path
             self.min_confidence = min_confidence
             self.style_error_handler = style_error_handler
+            self.lines = None

[qyearsley, 2016/09/27 17:15:31]

(This line is added so that attributes are all defined in __init__)

 
         def check(self, lines):
             self.lines = lines
 
     class MockDispatcher(object):
 
         """A mock CheckerDispatcher class."""
 
         def __init__(self):
             self.dispatched_checker = None
@@ skipping 150 matching lines @@
         """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'))