Run format-webkit on webkitpy code (without string conversion).

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 192 matching lines @@
     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),',
                         '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': '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]')
 
 
 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.
@@ skipping 336 matching lines @@
              'is_pure': False,
              '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.
         function_state = 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);'],

[qyearsley, 2016/05/27 16:06:03]

In cases like this, the formatting could be made better by manually breaking up
the string.

             {'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':
@@ skipping 203 matching lines @@
                 filename='casting.cpp',
                 fs=fs)
             self.assertEqual(message, 'static_cast of class objects is not allowed. Add toFoo in Foo.h and use it instead.'
                                       '  [runtime/casting] [4]')
         finally:
             fs.read_text_file = orig_read_text_file_fn
 
     # We cannot test this functionality because of difference of
     # function definitions.  Anyway, we may never enable this.
     #
-    # # Test for unnamed arguments in a method.
+    # Test for unnamed arguments in a method.
     # def test_check_for_unnamed_params(self):
     #   message = ('All parameters should be named in a function'
     #              '  [readability/function] [3]')
     #   self.assert_lint('virtual void A(int*) const;', message)
     #   self.assert_lint('virtual void B(void (*fn)(int*));', message)
     #   self.assert_lint('virtual void C(int*);', message)
     #   self.assert_lint('void *(*f)(void *) = x;', message)
     #   self.assert_lint('void Method(char*) {', message)
     #   self.assert_lint('void Method(char*);', message)
     #   self.assert_lint('void Method(char* /*x*/);', message)
     #   self.assert_lint('typedef void (*Method)(int32);', message)
     #   self.assert_lint('static void operator delete[](void*) throw();', message)
     #
     #   self.assert_lint('virtual void D(int* p);', '')
     #   self.assert_lint('void operator delete(void* x) throw();', '')
     #   self.assert_lint('void Method(char* x)\n{', '')
     #   self.assert_lint('void Method(char* /*x*/)\n{', '')
     #   self.assert_lint('void Method(char* x);', '')
     #   self.assert_lint('typedef void (*Method)(int32 x);', '')
     #   self.assert_lint('static void operator delete[](void* x) throw();', '')
     #   self.assert_lint('static void operator delete[](void* /*x*/) throw();', '')
     #
-    #   # This one should technically warn, but doesn't because the function
-    #   # pointer is confusing.
+    # This one should technically warn, but doesn't because the function
+    # pointer is confusing.
     #   self.assert_lint('virtual void E(void (*fn)(int* p));', '')
 
     # Test deprecated casts such as int(d)
     def test_deprecated_cast(self):
         self.assert_lint(
             'int a = int(2.2);',
             'Using deprecated casting style.  '
             'Use static_cast<int>(...) instead'
             '  [readability/casting] [4]')
         # Checks for false positives...
@@ skipping 2916 matching lines @@
             'Use adoptPtr and OwnPtr<HDC> when calling CreateCompatibleDC to avoid potential '
             'memory leaks.  [runtime/leaky_pattern] [5]')
         self.assert_leaky_pattern_check(
             'adoptPtr(CreateCompatibleDC(dc));',
             '')
 
 
 class WebKitStyleTest(CppStyleTestBase):
 
     # for http://webkit.org/coding/coding-style.html
+
     def test_indentation(self):
         # 1. Use spaces, not tabs. Tabs should only appear in files that
         #    require them for semantic meaning, like Makefiles.
         self.assert_multi_line_lint(
             'class Foo {\n'
             '    int goo;\n'
             '};',
             '')
         self.assert_multi_line_lint(
             'class Foo {\n'
@@ skipping 367 matching lines @@
             '}\n',
             '')
         self.assert_multi_line_lint(
             '#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',
             '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',
+        # '#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'
@@ skipping 1116 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)