Run format-webkitpy and fix long lines.

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 186 matching lines @@
         self.assertEqual(cpp_style.create_skeleton_parameters('b{d}'), 'b   ,')
 
     def test_find_parameter_name_index(self):
         self.assertEqual(cpp_style.find_parameter_name_index(' int a '), 5)
         self.assertEqual(cpp_style.find_parameter_name_index(' PassRefPtr     '), 16)
         self.assertEqual(cpp_style.find_parameter_name_index('double'), 6)
 
     def test_parameter_list(self):
         elided_lines = ['int blah(PassRefPtr<MyClass> paramName,',
                         'const Other1Class& foo,',
-                        'const ComplexTemplate<Class1, NestedTemplate<P1, P2> >* const * param = new ComplexTemplate<Class1, NestedTemplate<P1, P2> >(34, 42),',
+                        ('const ComplexTemplate<Class1, NestedTemplate<P1, P2> >* const * param = '
+                         'new ComplexTemplate<Class1, NestedTemplate<P1, P2> >(34, 42),'),
                         'int* myCount = 0);']
         start_position = cpp_style.Position(row=0, column=8)
         end_position = cpp_style.Position(row=3, column=16)
 
         expected_parameters = ({'type': 'PassRefPtr<MyClass>', 'name': 'paramName', 'row': 0},
                                {'type': 'const Other1Class&', 'name': 'foo', 'row': 1},
                                {'type': 'const ComplexTemplate<Class1, NestedTemplate<P1, P2> >* const *',
                                 'name': 'param',
                                 'row': 2},
                                {'type': 'int*', 'name': 'myCount', 'row': 3})
         index = 0
         for parameter in cpp_style.parameter_list(elided_lines, start_position, end_position):
             expected_parameter = expected_parameters[index]
             self.assertEqual(parameter.type, expected_parameter['type'])
             self.assertEqual(parameter.name, expected_parameter['name'])
             self.assertEqual(parameter.row, expected_parameter['row'])
             index += 1
         self.assertEqual(index, len(expected_parameters))
 
     def test_check_parameter_against_text(self):
         error_collector = ErrorCollector(self.assertTrue)
         parameter = cpp_style.Parameter('FooF ooF', 4, 1)
         self.assertFalse(cpp_style._check_parameter_name_against_text(parameter, 'FooF', error_collector))
-        self.assertEqual(error_collector.results(),
-                         'The parameter name "ooF" adds no information, so it should be removed.  [readability/parameter_name] [5]')
+        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.
     """
 
@@ skipping 340 matching lines @@
              'is_declaration': True,
              'parameter_list':
                  ({'type': 'unsigned', 'name': 'a', 'row': 0},
                   {'type': 'short', 'name': 'b', 'row': 0},
                   {'type': 'long', 'name': 'c', 'row': 0},
                   {'type': 'long long short unsigned int', 'name': '', 'row': 0})})
 
         # Some parameter type with modifiers and no parameter names.
         self.perform_function_detection(
             [
-                'virtual void determineARIADropEffects(Vector<String>*&, const unsigned long int*&, const MediaPlayer::Preload, Other<Other2, Other3<P1, P2> >, int);'],
+                'virtual void determineARIADropEffects(Vector<String>*&, '
+                'const unsigned long int*&, const MediaPlayer::Preload, '
+                'Other<Other2, Other3<P1, P2> >, int);'
+            ],
             {'name': 'determineARIADropEffects',
              'modifiers_and_return_type': 'virtual void',
              'parameter_start_position': (0, 37),
              'function_name_start_position': (0, 13),
              'parameter_end_position': (0, 147),
              'body_start_position': (0, 147),
              'end_position': (0, 148),
              'is_pure': False,
              'is_declaration': True,
              'parameter_list':
                  ({'type': 'Vector<String>*&', 'name': '', 'row': 0},
                   {'type': 'const unsigned long int*&', 'name': '', 'row': 0},
                   {'type': 'const MediaPlayer::Preload', 'name': '', 'row': 0},
                   {'type': 'Other<Other2, Other3<P1, P2> >', 'name': '', 'row': 0},
                   {'type': 'int', 'name': '', 'row': 0})})
 
         # Try parsing a function with a very complex definition.
         self.perform_function_detection(
             ['#define MyMacro(a) a',
              'virtual',
              'AnotherTemplate<Class1, Class2> aFunctionName(PassRefPtr<MyClass> paramName,',
              'const Other1Class& foo,',
-             'const ComplexTemplate<Class1, NestedTemplate<P1, P2> >* const * param = new ComplexTemplate<Class1, NestedTemplate<P1, P2> >(34, 42),',
+             ('const ComplexTemplate<Class1, NestedTemplate<P1, P2> >* const * param = '
+              'new ComplexTemplate<Class1, NestedTemplate<P1, P2> >(34, 42),'),
              'int* myCount = 0);'],
             {'name': 'aFunctionName',
              'modifiers_and_return_type': 'virtual AnotherTemplate<Class1, Class2>',
              'function_name_start_position': (2, 32),
              'parameter_start_position': (2, 45),
              'parameter_end_position': (5, 17),
              'body_start_position': (5, 17),
              'end_position': (5, 18),
              'is_pure': False,
              'is_declaration': True,
@@ skipping 2185 matching lines @@
         self.assert_language_rules_check('foo.h',
                                          '#include "a.h"\n'
                                          '#include "c.h"\n'
                                          '#include "b.h"\n',
                                          'Alphabetical sorting problem.  [build/include_order] [4]')
 
     def test_check_line_break_after_own_header(self):
         self.assert_language_rules_check('foo.cpp',
                                          '#include "foo.h"\n'
                                          '#include "bar.h"\n',
-                                         'You should add a blank line after implementation file\'s own header.  [build/include_order] [4]')
+                                         ('You should add a blank line after implementation file\'s own header.'
+                                          '  [build/include_order] [4]'))
 
         self.assert_language_rules_check('foo.cpp',
                                          '#include "foo.h"\n'
                                          '\n'
                                          '#include "bar.h"\n',
                                          '')
 
     def test_check_preprocessor_in_include_section(self):
         self.assert_language_rules_check('foo.cpp',
                                          '#include "foo.h"\n'
@@ skipping 1284 matching lines @@
             '')
         self.assert_multi_line_lint(
             'if (condition) {\n'
             '    doSomething();\n'
             '} else {\n'
             '    doSomethingElse();\n'
             '    doSomethingElseAgain();\n'
             '}\n',
             '')
         self.assert_multi_line_lint(
-            '#define TEST_ASSERT(expression) do { if (!(expression)) { TestsController::shared().testFailed(__FILE__, __LINE__, #expression); return; } } while (0)\n',
+            '#define TEST_ASSERT(expression) do { if (!(expression)) { '
+            'TestsController::shared().testFailed(__FILE__, __LINE__, #expression); '
+            'return; } } while (0)\n',
             '')
         self.assert_multi_line_lint(
-            '#define TEST_ASSERT(expression) do { if ( !(expression)) { TestsController::shared().testFailed(__FILE__, __LINE__, #expression); return; } } while (0)\n',
+            '#define TEST_ASSERT(expression) do { if ( !(expression)) { '
+            'TestsController::shared().testFailed(__FILE__, __LINE__, #expression); '
+            'return; } } while (0)\n',
             'Extra space after ( in if  [whitespace/parens] [5]')
         # FIXME: currently we only check first conditional, so we cannot detect errors in next ones.
-        # self.assert_multi_line_lint(
-        # '#define TEST_ASSERT(expression) do { if (!(expression)) { TestsController::shared().testFailed(__FILE__, __LINE__, #expression); return; } } while (0 )\n',
-        #     'Mismatching spaces inside () in if  [whitespace/parens] [5]')
         self.assert_multi_line_lint(
             'WTF_MAKE_NONCOPYABLE(ClassName); WTF_MAKE_FAST_ALLOCATED;\n',
             '')
         self.assert_multi_line_lint(
             'if (condition) {\n'
             '    doSomething();\n'
             '    doSomethingAgain();\n'
             '}\n'
             'else {\n'
             '    doSomethingElse();\n'
@@ skipping 744 matching lines @@
             'foo.h')
 
     def test_ctype_fucntion(self):
         self.assert_lint(
             'int i = isascii(8);',
             'Use equivalent function in <wtf/ASCIICType.h> instead of the '
             'isascii() function.  [runtime/ctype_function] [4]',
             'foo.cpp')
 
     def test_names(self):
-        name_underscore_error_message = " is incorrectly named. Don't use underscores in your identifier names.  [readability/naming/underscores] [4]"
-        name_tooshort_error_message = " is incorrectly named. Don't use the single letter 'l' as an identifier name.  [readability/naming] [4]"
+        name_underscore_error_message = (" is incorrectly named. Don't use underscores in your identifier names."
+                                         "  [readability/naming/underscores] [4]")
+        name_tooshort_error_message = (" is incorrectly named. Don't use the single letter 'l' as an identifier name."
+                                       "  [readability/naming] [4]")
 
         # Basic cases from WebKit style guide.
         self.assert_lint('struct Data;', '')
         self.assert_lint('size_t bufferSize;', '')
         self.assert_lint('class HTMLDocument;', '')
         self.assert_lint('String mimeType();', '')
         self.assert_lint('size_t buffer_size;',
                          'buffer_size' + name_underscore_error_message)
         self.assert_lint('short m_length;', '')
         self.assert_lint('short _length;',
@@ skipping 124 matching lines @@
 
         # There is an exception for GTK+ API.
         self.assert_lint('void webkit_web_view_load(int var1, int var2)', '', 'Source/Webkit/gtk/webkit/foo.cpp')
         self.assert_lint('void webkit_web_view_load(int var1, int var2)', '', 'Source/Webkit2/UIProcess/gtk/foo.cpp')
 
         # Test that this doesn't also apply to files not in a 'gtk' directory.
         self.assert_lint('void webkit_web_view_load(int var1, int var2)',
                          'webkit_web_view_load is incorrectly named. Don\'t use underscores in your identifier names.'
                          '  [readability/naming/underscores] [4]', 'Source/Webkit/webkit/foo.cpp')
         # Test that this doesn't also apply to names that don't start with 'webkit_'.
-        self.assert_lint_one_of_many_errors_re('void otherkit_web_view_load(int var1, int var2)',
-                                               'otherkit_web_view_load is incorrectly named. Don\'t use underscores in your identifier names.'
-                                               '  [readability/naming/underscores] [4]', 'Source/Webkit/webkit/foo.cpp')
+        self.assert_lint_one_of_many_errors_re(
+            'void otherkit_web_view_load(int var1, int var2)',
+            'otherkit_web_view_load is incorrectly named. Don\'t use underscores in your identifier names.'
+            '  [readability/naming/underscores] [4]', 'Source/Webkit/webkit/foo.cpp')
 
         # There is an exception for some unit tests that begin with "tst_".
         self.assert_lint('void tst_QWebFrame::arrayObjectEnumerable(int var1, int var2)', '')
 
         # The Qt API uses names that begin with "qt_" or "_q_".
         self.assert_lint('void QTFrame::qt_drt_is_awesome(int var1, int var2)', '')
         self.assert_lint('void QTFrame::_q_drt_is_awesome(int var1, int var2)', '')
         self.assert_lint('void qt_drt_is_awesome(int var1, int var2);', '')
         self.assert_lint('void _q_drt_is_awesome(int var1, int var2);', '')
 
@@ skipping 28 matching lines @@
         self.assert_lint('OwnPtr<uint32_t> variable(new uint32_t);', '')
         self.assert_lint('OwnPtr<uint32_t> variable(new (expr) uint32_t);', '')
         self.assert_lint('OwnPtr<uint32_t> under_score(new uint32_t);',
                          'under_score' + name_underscore_error_message)
 
         # Conversion operator declaration.
         self.assert_lint('operator int64_t();', '')
 
     def test_parameter_names(self):
         # Leave meaningless variable names out of function declarations.
-        meaningless_variable_name_error_message = 'The parameter name "%s" adds no information, so it should be removed.  [readability/parameter_name] [5]'
+        # This variable name is very long.  # pylint: disable=invalid-name
+        meaningless_variable_name_error_message = ('The parameter name "%s" adds no information, '
+                                                   'so it should be removed.  [readability/parameter_name] [5]')
 
-        parameter_error_rules = ('-',
-                                 '+readability/parameter_name')
+        parameter_error_rules = ('-', '+readability/parameter_name')
         # No variable name, so no error.
-        self.assertEqual('',
-                         self.perform_lint('void func(int);', 'test.cpp', parameter_error_rules))
+        self.assertEqual(
+            '',
+            self.perform_lint('void func(int);', 'test.cpp', parameter_error_rules))
 
         # Verify that copying the name of the set function causes the error (with some odd casing).
-        self.assertEqual(meaningless_variable_name_error_message % 'itemCount',
-                         self.perform_lint('void setItemCount(size_t itemCount);', 'test.cpp', parameter_error_rules))
-        self.assertEqual(meaningless_variable_name_error_message % 'abcCount',
-                         self.perform_lint('void setABCCount(size_t abcCount);', 'test.cpp', parameter_error_rules))
+        self.assertEqual(
+            meaningless_variable_name_error_message % 'itemCount',
+            self.perform_lint('void setItemCount(size_t itemCount);', 'test.cpp', parameter_error_rules))
+        self.assertEqual(
+            meaningless_variable_name_error_message % 'abcCount',
+            self.perform_lint('void setABCCount(size_t abcCount);', 'test.cpp', parameter_error_rules))
 
         # Verify that copying a type name will trigger the warning (even if the type is a template parameter).
-        self.assertEqual(meaningless_variable_name_error_message % 'context',
-                         self.perform_lint('void funct(PassRefPtr<ScriptExecutionContext> context);', 'test.cpp', parameter_error_rules))
+        self.assertEqual(
+            meaningless_variable_name_error_message % 'context',
+            self.perform_lint('void funct(PassRefPtr<ScriptExecutionContext> context);', 'test.cpp', parameter_error_rules))
 
         # Verify that acronyms as variable names trigger the error (for both set functions and type names).
-        self.assertEqual(meaningless_variable_name_error_message % 'ec',
-                         self.perform_lint('void setExceptionCode(int ec);', 'test.cpp', parameter_error_rules))
-        self.assertEqual(meaningless_variable_name_error_message % 'ec',
-                         self.perform_lint('void funct(ExceptionCode ec);', 'test.cpp', parameter_error_rules))
+        self.assertEqual(
+            meaningless_variable_name_error_message % 'ec',
+            self.perform_lint('void setExceptionCode(int ec);', 'test.cpp', parameter_error_rules))
+        self.assertEqual(
+            meaningless_variable_name_error_message % 'ec',
+            self.perform_lint('void funct(ExceptionCode ec);', 'test.cpp', parameter_error_rules))
 
         # 'object' alone, appended, or as part of an acronym is meaningless.
-        self.assertEqual(meaningless_variable_name_error_message % 'object',
-                         self.perform_lint('void funct(RenderView object);', 'test.cpp', parameter_error_rules))
-        self.assertEqual(meaningless_variable_name_error_message % 'viewObject',
-                         self.perform_lint('void funct(RenderView viewObject);', 'test.cpp', parameter_error_rules))
-        self.assertEqual(meaningless_variable_name_error_message % 'rvo',
-                         self.perform_lint('void funct(RenderView rvo);', 'test.cpp', parameter_error_rules))
+        self.assertEqual(
+            meaningless_variable_name_error_message % 'object',
+            self.perform_lint('void funct(RenderView object);', 'test.cpp', parameter_error_rules))
+        self.assertEqual(
+            meaningless_variable_name_error_message % 'viewObject',
+            self.perform_lint('void funct(RenderView viewObject);', 'test.cpp', parameter_error_rules))
+        self.assertEqual(
+            meaningless_variable_name_error_message % 'rvo',
+            self.perform_lint('void funct(RenderView rvo);', 'test.cpp', parameter_error_rules))
 
         # Check that r, g, b, and a are allowed.
-        self.assertEqual('',
-                         self.perform_lint('void setRGBAValues(int r, int g, int b, int a);', 'test.cpp', parameter_error_rules))
+        self.assertEqual(
+            '',
+            self.perform_lint('void setRGBAValues(int r, int g, int b, int a);', 'test.cpp', parameter_error_rules))
 
         # Verify that a simple substring match isn't done which would cause false positives.
-        self.assertEqual('',
-                         self.perform_lint('void setNateLateCount(size_t elate);', 'test.cpp', parameter_error_rules))
-        self.assertEqual('',
-                         self.perform_lint('void funct(NateLate elate);', 'test.cpp', parameter_error_rules))
+        self.assertEqual(
+            '',
+            self.perform_lint('void setNateLateCount(size_t elate);', 'test.cpp', parameter_error_rules))
+        self.assertEqual(
+            '',
+            self.perform_lint('void funct(NateLate elate);', 'test.cpp', parameter_error_rules))
 
         # Don't have generate warnings for functions (only declarations).
-        self.assertEqual('',
-                         self.perform_lint('void funct(PassRefPtr<ScriptExecutionContext> context)\n'
-                                           '{\n'
-                                           '}\n', 'test.cpp', parameter_error_rules))
+        self.assertEqual(
+            '',
+            self.perform_lint('void funct(PassRefPtr<ScriptExecutionContext> context)\n{\n}\n', 'test.cpp', parameter_error_rules))
 
     def test_comments(self):
         # A comment at the beginning of a line is ok.
         self.assert_lint('// comment', '')
         self.assert_lint('    // comment', '')
 
         self.assert_lint('}  // namespace WebCore',
                          'One space before end of line comments'
                          '  [whitespace/comments] [5]')
 
@@ skipping 25 matching lines @@
                                            'WebKit/chromium/public/test.h',
                                            webkit_export_error_rules))
         self.assertEqual('',
                          self.perform_lint('WEBKIT_EXPORT int foo();\n',
                                            'WebKit/chromium/tests/test.h',
                                            webkit_export_error_rules))
         self.assertEqual('WEBKIT_EXPORT should only be used in header files.  [readability/webkit_export] [5]',
                          self.perform_lint('WEBKIT_EXPORT int foo();\n',
                                            'WebKit/chromium/public/test.cpp',
                                            webkit_export_error_rules))
-        self.assertEqual('WEBKIT_EXPORT should only appear in the chromium public (or tests) directory.  [readability/webkit_export] [5]',
+        self.assertEqual('WEBKIT_EXPORT should only appear in the chromium public (or tests) directory.  '
+                         '[readability/webkit_export] [5]',
                          self.perform_lint('WEBKIT_EXPORT int foo();\n',
                                            'WebKit/chromium/src/test.h',
                                            webkit_export_error_rules))
         self.assertEqual('WEBKIT_EXPORT should not be used on a function with a body.  [readability/webkit_export] [5]',
                          self.perform_lint('WEBKIT_EXPORT int foo() { }\n',
                                            'WebKit/chromium/public/test.h',
                                            webkit_export_error_rules))
         self.assertEqual('WEBKIT_EXPORT should not be used on a function with a body.  [readability/webkit_export] [5]',
                          self.perform_lint('WEBKIT_EXPORT inline int foo()\n'
                                            '{\n'
@@ skipping 61 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)