Make docstrings more consistent using format-webkitpy.

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 39 matching lines @@
 # 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 = {}
 
     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."""
+           filter: filters the errors that we are concerned about.
+           """

[Dirk Pranke, 2016/09/06 01:14:27]

also weird?

         self._assert_fn = assert_fn
         self._errors = []
         self._lines_to_check = lines_to_check
         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",'
@@ skipping 159 matching lines @@
         self.assertEqual(error_collector.results(),
                          'The parameter name "ooF" adds no information, so it should be removed.  [readability/parameter_name] [5]')
 
 
 class CppStyleTestBase(unittest.TestCase):
     """Provides some useful helper functions for cpp_style tests.
 
     Attributes:
       min_confidence: An integer that is the current minimum confidence
                       level for the tests.
-
     """
 
     # FIXME: Refactor the unit tests so the confidence level is passed
     #        explicitly, just like it is in the real code.
     min_confidence = 1
 
     # Helper function to avoid needing to explicitly pass confidence
     # in all the unit test calls to cpp_style.process_file_data().
     def process_file_data(self, filename, file_extension, lines, error, fs=None):
         """Call cpp_style.process_file_data() with the min_confidence."""
@@ skipping 104 matching lines @@
         self.assertEqual(
             end_errors,
             error_collector.results().count(
                 'Blank line at the end of a code block.  Is this needed?'
                 '  [whitespace/blank_line] [3]'))
 
     def assert_positions_equal(self, position, tuple_position):
         """Checks if the two positions are equal.
 
         position: a cpp_style.Position object.
-        tuple_position: a tuple (row, column) to compare against."""
+        tuple_position: a tuple (row, column) to compare against.
+        """
         self.assertEqual(position, cpp_style.Position(tuple_position[0], tuple_position[1]),
                          'position %s, tuple_position %s' % (position, tuple_position))
 
 
 class FunctionDetectionTest(CppStyleTestBase):
 
     def perform_function_detection(self, lines, function_information, detection_line=0):
         clean_lines = cpp_style.CleansedLines(lines)
         function_state = cpp_style._FunctionState(5)
         error_collector = ErrorCollector(self.assertTrue)
@@ skipping 4884 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)