Remove unused methods in webkitpy cpp style checker and test.

third_party/WebKit/Tools/Scripts/webkitpy/style/checkers/cpp_unittest.py

 # -*- coding: utf-8; -*-
 #
 # Copyright (C) 2011 Google Inc. All rights reserved.
 # Copyright (C) 2009 Torch Mobile Inc.
 # Copyright (C) 2009 Apple Inc. All rights reserved.
 # 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:
@@ skipping 32 matching lines @@
 from webkitpy.common.system.filesystem import FileSystem
 from webkitpy.style.checkers import cpp as cpp_style
 from webkitpy.style.checkers.cpp import CppChecker
 from webkitpy.style.filter import FilterConfiguration
 
 # This class works as an error collector and replaces cpp_style.Error
 # function for the unit tests.  We also verify each category we see
 # is in STYLE_CATEGORIES, to help keep that list up to date.
 
 
-class ErrorCollector:
-    _all_style_categories = CppChecker.categories
-    # This is a list including all categories seen in any unit test.
-    _seen_style_categories = {}
+class ErrorCollector(object):
 
     def __init__(self, assert_fn, filter=None, lines_to_check=None):
         """assert_fn: a function to call when we notice a problem.
            filter: filters the errors that we are concerned about.
         """
         self._assert_fn = assert_fn
         self._errors = []
         self._lines_to_check = lines_to_check
+        self._all_style_categories = CppChecker.categories
         if not filter:
             filter = FilterConfiguration()
         self._filter = filter
 
     def __call__(self, line_number, category, confidence, message):
         self._assert_fn(category in self._all_style_categories,
                         'Message "%s" has category "%s",'
                         ' which is not in STYLE_CATEGORIES' % (message, category))
 
         if self._lines_to_check and not line_number in self._lines_to_check:
             return False
 
         if self._filter.should_check(category, ""):
-            self._seen_style_categories[category] = 1
             self._errors.append('%s  [%s] [%d]' % (message, category, confidence))
         return True
 
     def results(self):
         if len(self._errors) < 2:
             return ''.join(self._errors)  # Most tests expect to have a string.
         else:
             return self._errors  # Let's give a list if there is more than one.
 
     def result_list(self):
         return self._errors
 
-    def verify_all_categories_are_seen(self):
-        """Fails if there's a category in _all_style_categories - _seen_style_categories.
-
-        This should only be called after all tests are run, so
-        _seen_style_categories has had a chance to fully populate.  Since
-        this isn't called from within the normal unittest framework, we
-        can't use the normal unittest assert macros.  Instead we just exit
-        when we see an error.  Good thing this test is always run last!
-        """
-        for category in self._all_style_categories:
-            if category not in self._seen_style_categories:
-                import sys
-                sys.exit('FATAL ERROR: There are no tests for category "%s"' % category)
-
 
 class CppFunctionsTest(unittest.TestCase):
 
     """Supports testing functions that do not need CppStyleTestBase."""
 
     def test_convert_to_lower_with_underscores(self):
         self.assertEqual(cpp_style._convert_to_lower_with_underscores('ABC'), 'abc')
         self.assertEqual(cpp_style._convert_to_lower_with_underscores('aB'), 'a_b')
         self.assertEqual(cpp_style._convert_to_lower_with_underscores('isAName'), 'is_a_name')
         self.assertEqual(cpp_style._convert_to_lower_with_underscores('AnotherTest'), 'another_test')
@@ skipping 504 matching lines @@
              'parameter_list':
                  ({'type': 'PassRefPtr<MyClass>', 'name': 'paramName', 'row': 2},
                   {'type': 'const Other1Class&', 'name': 'foo', 'row': 3},
                   {'type': 'const ComplexTemplate<Class1, NestedTemplate<P1, P2> >* const *', 'name': 'param', 'row': 4},
                   {'type': 'int*', 'name': 'myCount', 'row': 5})},
             detection_line=2)
 
 
 class CppStyleTest(CppStyleTestBase):
 
+    def tearDownClass(self):
+

[dcheng, 2017/03/14 04:45:54]

Why does this need an empty tearDownClass?

[qyearsley, 2017/03/14 16:11:00]

It doesn't, thanks for pointing this out :-)

When I was removing verify_all_categories_are_seen (which is unused), I was
thinking that maybe instead it would be better to call it once in tearDownClass.
But if we want to do this, then another change has to be made; all test methods
must be changed to use the same ErrorCollector object.

Then I thought, since this isn't used now and it adds complexity, maybe it's
better to just remove it. What do you think?

+
     def test_asm_lines_ignored(self):
         self.assert_lint(
             '__asm mov [registration], eax',
             '')
 
     # Test get line width.
     def test_get_line_width(self):
         self.assertEqual(0, cpp_style.get_line_width(''))
         self.assertEqual(10, cpp_style.get_line_width(u'x' * 10))
         self.assertEqual(16, cpp_style.get_line_width(u'都|道|府|県|支庁'))
@@ skipping 1896 matching lines @@
 
         Args:
           error_level: --v setting for cpp_style.
         """
         self.assert_function_length_check_definition(self.trigger_lines(error_level) + 1,
                                                      error_level)
 
     def function_body(self, number_of_lines):
         return ' {\n' + '  this_is_just_a_test();\n' * number_of_lines + '}'
 
-    def function_body_with_blank_lines(self, number_of_lines):
-        return ' {\n' + '  this_is_just_a_test();\n\n' * number_of_lines + '}'
-
     def function_body_with_no_lints(self, number_of_lines):
         return ' {\n' + '  this_is_just_a_test();  // NOLINT\n' * number_of_lines + '}'
 
     # Test line length checks.
     def test_function_length_check_declaration(self):
         self.assert_function_lengths_check(
             'void test();',  # Not a function definition
             '')
 
     def test_function_length_check_declaration_with_block_following(self):
@@ skipping 1577 matching lines @@
     def test_ne(self):
         """Test __ne__ inequality function."""
         checker1 = self._checker()
         checker2 = self._checker()
 
         # != calls __ne__.
         # By default, __ne__ always returns true on different objects.
         # Thus, just check the distinguishing case to verify that the
         # code defines __ne__.
         self.assertFalse(checker1 != checker2)