Run auto-formatter (autopep8) on 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 30 matching lines @@
 import unittest
 
 import cpp as cpp_style
 from cpp import CppChecker
 from ..filter import FilterConfiguration
 from webkitpy.common.system.filesystem import FileSystem
 
 # 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 = {}
 
     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 = []
@@ skipping 114 matching lines @@
         self.assertEqual(single_line_view.single_line, '""')
 
     def test_create_skeleton_parameters(self):
         self.assertEqual(cpp_style.create_skeleton_parameters(''), '')
         self.assertEqual(cpp_style.create_skeleton_parameters(' '), ' ')
         self.assertEqual(cpp_style.create_skeleton_parameters('long'), 'long,')
         self.assertEqual(cpp_style.create_skeleton_parameters('const unsigned long int'), '                    int,')
         self.assertEqual(cpp_style.create_skeleton_parameters('long int*'), '     int ,')
         self.assertEqual(cpp_style.create_skeleton_parameters('PassRefPtr<Foo> a'), 'PassRefPtr      a,')
         self.assertEqual(cpp_style.create_skeleton_parameters(
-                'ComplexTemplate<NestedTemplate1<MyClass1, MyClass2>, NestedTemplate1<MyClass1, MyClass2> > param, int second'),
-                          'ComplexTemplate                                                                            param, int second,')
+            'ComplexTemplate<NestedTemplate1<MyClass1, MyClass2>, NestedTemplate1<MyClass1, MyClass2> > param, int second'),
+            'ComplexTemplate                                                                            param, int second,')
         self.assertEqual(cpp_style.create_skeleton_parameters('int = 0, Namespace::Type& a'), 'int    ,            Type  a,')
         # Create skeleton parameters is a bit too aggressive with function variables, but
         # it allows for parsing other parameters and declarations like this are rare.
         self.assertEqual(cpp_style.create_skeleton_parameters('void (*fn)(int a, int b), Namespace::Type& a'),
-                          'void                    ,            Type  a,')
+                         'void                    ,            Type  a,')
 
         # This doesn't look like functions declarations but the simplifications help to eliminate false positives.
         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):
@@ skipping 15 matching lines @@
             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]')
+                         '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;
+    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."""
         return cpp_style.process_file_data(filename, file_extension, lines,
                                            error, self.min_confidence, fs)
 
     def perform_lint(self, code, filename, basic_error_rules, fs=None, lines_to_check=None):
         error_collector = ErrorCollector(self.assertTrue, FilterConfiguration(basic_error_rules), lines_to_check)
@@ skipping 75 matching lines @@
         self.assertEqual(expected_message, self.perform_multi_line_lint(code, file_extension))
 
     def assert_multi_line_lint_re(self, code, expected_message_re, file_name='foo.h'):
         file_extension = file_name[file_name.rfind('.') + 1:]
         message = self.perform_multi_line_lint(code, file_extension)
         if not re.search(expected_message_re, message):
             self.fail('Message was:\n' + message + 'Expected match to "' + expected_message_re + '"')
 
     def assert_language_rules_check(self, file_name, code, expected_message, lines_to_check=None):
         self.assertEqual(expected_message,
-                          self.perform_language_rules_check(file_name, code, lines_to_check))
+                         self.perform_language_rules_check(file_name, code, lines_to_check))
 
     def assert_include_what_you_use(self, code, expected_message):
         self.assertEqual(expected_message,
-                          self.perform_include_what_you_use(code))
+                         self.perform_include_what_you_use(code))
 
     def assert_blank_lines_check(self, lines, start_errors, end_errors):
         error_collector = ErrorCollector(self.assertTrue)
         self.process_file_data('foo.cpp', 'cpp', lines, error_collector)
         self.assertEqual(
             start_errors,
             error_collector.results().count(
                 'Blank line at the start of a code block.  Is this needed?'
                 '  [whitespace/blank_line] [2]'))
         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."""
         self.assertEqual(position, cpp_style.Position(tuple_position[0], tuple_position[1]),
-                          'position %s, tuple_position %s' % (position, tuple_position))
+                         '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)
         cpp_style.detect_functions(clean_lines, detection_line, function_state, error_collector)
         if not function_information:
             self.assertEqual(function_state.in_a_function, False)
             return
         self.assertEqual(function_state.in_a_function, True)
         self.assertEqual(function_state.current_function, function_information['name'] + '()')
         self.assertEqual(function_state.modifiers_and_return_type(), function_information['modifiers_and_return_type'])
         self.assertEqual(function_state.is_pure, function_information['is_pure'])
         self.assertEqual(function_state.is_declaration, function_information['is_declaration'])
-        self.assert_positions_equal(function_state.function_name_start_position, function_information['function_name_start_position'])
+        self.assert_positions_equal(function_state.function_name_start_position,
+                                    function_information['function_name_start_position'])
         self.assert_positions_equal(function_state.parameter_start_position, function_information['parameter_start_position'])
         self.assert_positions_equal(function_state.parameter_end_position, function_information['parameter_end_position'])
         self.assert_positions_equal(function_state.body_start_position, function_information['body_start_position'])
         self.assert_positions_equal(function_state.end_position, function_information['end_position'])
         expected_parameters = function_information.get('parameter_list')
         if expected_parameters:
             actual_parameters = function_state.parameter_list()
             self.assertEqual(len(actual_parameters), len(expected_parameters))
             for index in range(len(expected_parameters)):
                 actual_parameter = actual_parameters[index]
@@ skipping 497 matching lines @@
         self.assert_lint(
             'typedef void Func(int x);',
             '')
         self.assert_lint(
             'typedef void Func(int *x);',
             '')
 
     def test_include_what_you_use_no_implementation_files(self):
         code = 'std::vector<int> foo;'
         self.assertEqual('Add #include <vector> for vector<>'
-                          '  [build/include_what_you_use] [4]',
-                          self.perform_include_what_you_use(code, 'foo.h'))
+                         '  [build/include_what_you_use] [4]',
+                         self.perform_include_what_you_use(code, 'foo.h'))
         self.assertEqual('',
-                          self.perform_include_what_you_use(code, 'foo.cpp'))
+                         self.perform_include_what_you_use(code, 'foo.cpp'))
 
     def test_include_what_you_use(self):
         self.assert_include_what_you_use(
             '''#include <vector>
                std::vector<int> foo;
             ''',
             '')
         self.assert_include_what_you_use(
             '''#include <map>
                std::pair<int,int> foo;
@@ skipping 89 matching lines @@
                void a(const std::multimap<int,string> &foobar);
             ''',
             'Add #include <map> for multimap<>'
             '  [build/include_what_you_use] [4]')
         self.assert_include_what_you_use(
             '''#include <queue>
                void a(const std::priority_queue<int> &foobar);
             ''',
             '')
         self.assert_include_what_you_use(
-             '''#include "base/basictypes.h"
+            '''#include "base/basictypes.h"
                 #include "base/port.h"
                 #include <assert.h>
                 #include <string>
                 #include <vector>
                 vector<string> hajoa;''', '')
         self.assert_include_what_you_use(
             '''#include <string>
                int i = numeric_limits<int>::max()
             ''',
             'Add #include <limits> for numeric_limits<>'
@@ skipping 43 matching lines @@
             # Make sure we find the headers with relative paths.
             mock_header_contents = ['']
             message = self.perform_include_what_you_use(
                 '''#include "config.h"
                    #include "%s%sa.h"
 
                    std::set<int> foo;''' % (os.path.basename(os.getcwd()), os.path.sep),
                 filename='a.cpp',
                 fs=fs)
             self.assertEqual(message, 'Add #include <set> for set<>  '
-                                       '[build/include_what_you_use] [4]')
+                             '[build/include_what_you_use] [4]')
         finally:
             fs.read_text_file = orig_read_text_file_fn
 
     def test_files_belong_to_same_module(self):
         f = cpp_style.files_belong_to_same_module
         self.assertEqual((True, ''), f('a.cpp', 'a.h'))
         self.assertEqual((True, ''), f('base/google.cpp', 'base/google.h'))
         self.assertEqual((True, ''), f('base/google_test.cpp', 'base/google.h'))
         self.assertEqual((True, ''),
-                          f('base/google_unittest.cpp', 'base/google.h'))
+                         f('base/google_unittest.cpp', 'base/google.h'))
         self.assertEqual((True, ''),
-                          f('base/internal/google_unittest.cpp',
-                            'base/public/google.h'))
+                         f('base/internal/google_unittest.cpp',
+                           'base/public/google.h'))
         self.assertEqual((True, 'xxx/yyy/'),
-                          f('xxx/yyy/base/internal/google_unittest.cpp',
-                            'base/public/google.h'))
+                         f('xxx/yyy/base/internal/google_unittest.cpp',
+                           'base/public/google.h'))
         self.assertEqual((True, 'xxx/yyy/'),
-                          f('xxx/yyy/base/google_unittest.cpp',
-                            'base/public/google.h'))
+                         f('xxx/yyy/base/google_unittest.cpp',
+                           'base/public/google.h'))
         self.assertEqual((True, ''),
-                          f('base/google_unittest.cpp', 'base/google-inl.h'))
+                         f('base/google_unittest.cpp', 'base/google-inl.h'))
         self.assertEqual((True, '/home/build/google3/'),
-                          f('/home/build/google3/base/google.cpp', 'base/google.h'))
+                         f('/home/build/google3/base/google.cpp', 'base/google.h'))
 
         self.assertEqual((False, ''),
-                          f('/home/build/google3/base/google.cpp', 'basu/google.h'))
+                         f('/home/build/google3/base/google.cpp', 'basu/google.h'))
         self.assertEqual((False, ''), f('a.cpp', 'b.h'))
 
     def test_cleanse_line(self):
         self.assertEqual('int foo = 0;  ',
-                          cpp_style.cleanse_comments('int foo = 0;  // danger!'))
+                         cpp_style.cleanse_comments('int foo = 0;  // danger!'))
         self.assertEqual('int o = 0;',
-                          cpp_style.cleanse_comments('int /* foo */ o = 0;'))
+                         cpp_style.cleanse_comments('int /* foo */ o = 0;'))
         self.assertEqual('foo(int a, int b);',
-                          cpp_style.cleanse_comments('foo(int a /* abc */, int b);'))
+                         cpp_style.cleanse_comments('foo(int a /* abc */, int b);'))
         self.assertEqual('f(a, b);',
                          cpp_style.cleanse_comments('f(a, /* name */ b);'))
         self.assertEqual('f(a, b);',
                          cpp_style.cleanse_comments('f(a /* name */, b);'))
         self.assertEqual('f(a, b);',
                          cpp_style.cleanse_comments('f(a, /* name */b);'))
 
     def test_multi_line_comments(self):
         # missing explicit is bad
         self.assert_multi_line_lint(
             r'''int a = 0;
                 /* multi-liner
                 class Foo {
                 Foo(int f);  // should cause a lint warning in code
                 }
             */ ''',
-        '')
+            '')
         self.assert_multi_line_lint(
             '''\
             /* int a = 0; multi-liner
             static const int b = 0;''',
             ['Could not find end of multi-line comment'
              '  [readability/multiline_comment] [5]',
              'Complex multi-line /*...*/-style comment found. '
              'Lint may give bogus warnings.  Consider replacing these with '
              '//-style comments, with #if 0...#endif, or with more clearly '
              'structured multi-line comments.  [readability/multiline_comment] [5]'])
@@ skipping 631 matching lines @@
         self.assert_lint('a<Foo*>&& t = &b;', '')
         self.assert_lint('a<Foo*> t >>= &b|c;', 'Missing spaces around |'
                          '  [whitespace/operators] [3]')
         self.assert_lint('a<Foo*> t <<= *b/c;', 'Missing spaces around /'
                          '  [whitespace/operators] [3]')
         self.assert_lint('a<Foo*> t <<= b/c; //Test', [
                          'Should have a space between // and comment  '
                          '[whitespace/comments] [4]', 'Missing'
                          ' spaces around /  [whitespace/operators] [3]'])
         self.assert_lint('a<Foo*> t <<= b||c;  //Test', ['One space before end'
-                         ' of line comments  [whitespace/comments] [5]',
-                         'Should have a space between // and comment  '
-                         '[whitespace/comments] [4]',
-                         'Missing spaces around ||  [whitespace/operators] [3]'])
+                                                         ' of line comments  [whitespace/comments] [5]',
+                                                         'Should have a space between // and comment  '
+                                                         '[whitespace/comments] [4]',
+                                                         'Missing spaces around ||  [whitespace/operators] [3]'])
         self.assert_lint('a<Foo*> t <<= b && *c; // Test', '')
         self.assert_lint('a<Foo*> t <<= b && &c; // Test', '')
         self.assert_lint('a<Foo*> t <<= b || &c;  /*Test', 'Complex multi-line '
                          '/*...*/-style comment found. Lint may give bogus '
                          'warnings.  Consider replacing these with //-style'
                          ' comments, with #if 0...#endif, or with more clearly'
                          ' structured multi-line comments.  [readability/multiline_comment] [5]')
         self.assert_lint('a<Foo&> t <<= &b | &c;', '')
         self.assert_lint('a<Foo*> t <<= &b & &c; // Test', '')
         self.assert_lint('a<Foo*> t <<= *b / &c; // Test', '')
         self.assert_lint('if (a=b == 1)', 'Missing spaces around =  [whitespace/operators] [4]')
         self.assert_lint('a = 1<<20', 'Missing spaces around <<  [whitespace/operators] [3]')
         self.assert_lint('a = 1>> 20', 'Missing spaces around >>  [whitespace/operators] [3]')
         self.assert_lint('a = 1 >>20', 'Missing spaces around >>  [whitespace/operators] [3]')
         self.assert_lint('a = 1>>20', 'Missing spaces around >>  [whitespace/operators] [3]')
         self.assert_lint('func(OwnPtr<Vector<Foo>>)', '')
         self.assert_lint('func(OwnPtr<Vector<Foo>> foo)', '')
         self.assert_lint('func(OwnPtr<HashMap<Foo, Member<Bar>>>)', '')
-        self.assert_lint('func(OwnPtr<Vector<Foo> >)', 'Use >> for ending template instead of > >.  [readability/templatebrackets] [3]')
-        self.assert_lint('func(OwnPtr<HashMap<Foo, Member<Bar>> >)', 'Use >> for ending template instead of > >.  [readability/templatebrackets] [3]')
-        self.assert_lint('func(OwnPtr<HashMap<Foo, Member<Bar> >>)', 'Use >> for ending template instead of > >.  [readability/templatebrackets] [3]')
-        self.assert_lint('func(OwnPtr<HashMap<Foo, Member<Bar> > >)', 'Use >> for ending template instead of > >.  [readability/templatebrackets] [3]')
+        self.assert_lint('func(OwnPtr<Vector<Foo> >)',
+                         'Use >> for ending template instead of > >.  [readability/templatebrackets] [3]')
+        self.assert_lint('func(OwnPtr<HashMap<Foo, Member<Bar>> >)',
+                         'Use >> for ending template instead of > >.  [readability/templatebrackets] [3]')
+        self.assert_lint('func(OwnPtr<HashMap<Foo, Member<Bar> >>)',
+                         'Use >> for ending template instead of > >.  [readability/templatebrackets] [3]')
+        self.assert_lint('func(OwnPtr<HashMap<Foo, Member<Bar> > >)',
+                         'Use >> for ending template instead of > >.  [readability/templatebrackets] [3]')
         self.assert_lint('Vector< ::Foo>)', 'Use <:: for template start instead of < ::.  [readability/templatebrackets] [3]')
-        self.assert_lint('Vector<Vector< ::Foo>>)', 'Use <:: for template start instead of < ::.  [readability/templatebrackets] [3]')
+        self.assert_lint('Vector<Vector< ::Foo>>)',
+                         'Use <:: for template start instead of < ::.  [readability/templatebrackets] [3]')
         # FIXME: The following test should not show any error.
         self.assert_lint('func(OwnPtr<HashMap<Foo, Member<Bar\n    >>>)',
                          'Missing spaces around <  [whitespace/operators] [3]')
         self.assert_lint('if (a = b == 1)', '')
         self.assert_lint('a = 1 << 20', '')
         self.assert_multi_line_lint('#include <sys/io.h>\n', '')
         self.assert_multi_line_lint('#import <foo/bar.h>\n', '')
 
     def test_operator_methods(self):
         self.assert_lint('String operator+(const String&, const String&);', '')
@@ skipping 91 matching lines @@
                                     '')
 
     def test_one_spaces_between_code_and_comments(self):
         self.assert_lint('} // namespace foo',
                          '')
         self.assert_lint('}// namespace foo',
                          'One space before end of line comments'
                          '  [whitespace/comments] [5]')
         self.assert_lint('printf("foo"); // Outside quotes.',
                          '')
-        self.assert_lint('int i = 0; // Having one space is fine.','')
+        self.assert_lint('int i = 0; // Having one space is fine.', '')
         self.assert_lint('int i = 0;  // Having two spaces is bad.',
                          'One space before end of line comments'
                          '  [whitespace/comments] [5]')
         self.assert_lint('int i = 0;   // Having three spaces is bad.',
                          'One space before end of line comments'
                          '  [whitespace/comments] [5]')
         self.assert_lint('// Top level comment', '')
         self.assert_lint('    // Line starts with four spaces.', '')
         self.assert_lint('foo();\n'
                          '{ // A scope is opening.', '')
@@ skipping 198 matching lines @@
             '}\n',
             'Weird number of spaces at line-start.  Are you using a 4-space indent?  [whitespace/indent] [3]')
 
         self.assert_multi_line_lint(
             'if (true) {\n'
             '    myFunction(reallyLongParam1, reallyLongParam2,\n'
             '            reallyLongParam3);\n'
             '}\n',
             'When wrapping a line, only indent 4 spaces.  [whitespace/indent] [3]')
 
-
     def test_not_alabel(self):
         self.assert_lint('MyVeryLongNamespace::MyVeryLongClassName::', '')
 
     def test_tab(self):
         self.assert_lint('\tint a;',
                          'Tab found; better to use spaces  [whitespace/tab] [1]')
         self.assert_lint('int a = 5;\t// set a to 5',
                          'Tab found; better to use spaces  [whitespace/tab] [1]')
 
     def test_unnamed_namespaces_in_headers(self):
@@ skipping 160 matching lines @@
         # Verify that we don't blindly suggest the WTF prefix for all headers.
         self.assertFalse(expected_guard.startswith('WTF_'))
 
         # Allow the WTF_ prefix for files in that directory.
         header_guard_filter = FilterConfiguration(('-', '+build/header_guard'))
         error_collector = ErrorCollector(self.assertTrue, header_guard_filter)
         self.process_file_data('Source/JavaScriptCore/wtf/TestName.h', 'h',
                                ['#ifndef WTF_TestName_h', '#define WTF_TestName_h'],
                                error_collector)
         self.assertEqual(0, len(error_collector.result_list()),
-                          error_collector.result_list())
+                         error_collector.result_list())
 
         # Also allow the non WTF_ prefix for files in that directory.
         error_collector = ErrorCollector(self.assertTrue, header_guard_filter)
         self.process_file_data('Source/JavaScriptCore/wtf/TestName.h', 'h',
                                ['#ifndef TestName_h', '#define TestName_h'],
                                error_collector)
         self.assertEqual(0, len(error_collector.result_list()),
-                          error_collector.result_list())
+                         error_collector.result_list())
 
         # Verify that we suggest the WTF prefix version.
         error_collector = ErrorCollector(self.assertTrue, header_guard_filter)
         self.process_file_data('Source/JavaScriptCore/wtf/TestName.h', 'h',
                                ['#ifndef BAD_TestName_h', '#define BAD_TestName_h'],
                                error_collector)
         self.assertEqual(
             1,
             error_collector.result_list().count(
                 '#ifndef header guard has wrong style, please use: WTF_TestName_h'
                 '  [build/header_guard] [5]'),
             error_collector.result_list())
 
         # Verify that the Chromium-style header guard is allowed as well.
         error_collector = ErrorCollector(self.assertTrue, header_guard_filter)
         self.process_file_data('Source/foo/testname.h', 'h',
                                ['#ifndef BLINK_FOO_TESTNAME_H_',
                                 '#define BLINK_FOO_TESTNAME_H_'],
-                              error_collector)
+                               error_collector)
         self.assertEqual(0, len(error_collector.result_list()),
-                          error_collector.result_list())
+                         error_collector.result_list())
 
     def test_build_printf_format(self):
         self.assert_lint(
             r'printf("\%%d", value);',
             '%, [, (, and { are undefined character escapes.  Unescape them.'
             '  [build/printf_format] [3]')
 
         self.assert_lint(
             r'snprintf(buffer, sizeof(buffer), "\[%d", value);',
             '%, [, (, and { are undefined character escapes.  Unescape them.'
@@ skipping 240 matching lines @@
 
         safe_bitfield_test('a', 'A', 'unsigned', 22)
         safe_bitfield_test('m_someField', 'SomeClass', 'bool', 1)
         safe_bitfield_test('m_someField', 'SomeClass', 'unsigned', 2)
 
         # Declarations in 'Expected' or 'SameSizeAs' classes are OK.
         warning_bitfield_test('m_bitfields', 'SomeClass', 'int32_t', 32)
         safe_bitfield_test('m_bitfields', 'ExpectedSomeClass', 'int32_t', 32)
         safe_bitfield_test('m_bitfields', 'SameSizeAsSomeClass', 'int32_t', 32)
 
+
 class CleansedLinesTest(unittest.TestCase):
+
     def test_init(self):
         lines = ['Line 1',
                  'Line 2',
                  'Line 3 // Comment test',
                  'Line 4 "foo"']
 
         clean_lines = cpp_style.CleansedLines(lines)
         self.assertEqual(lines, clean_lines.raw_lines)
         self.assertEqual(4, clean_lines.num_lines())
 
         self.assertEqual(['Line 1',
-                           'Line 2',
-                           'Line 3 ',
-                           'Line 4 "foo"'],
-                          clean_lines.lines)
+                          'Line 2',
+                          'Line 3 ',
+                          'Line 4 "foo"'],
+                         clean_lines.lines)
 
         self.assertEqual(['Line 1',
-                           'Line 2',
-                           'Line 3 ',
-                           'Line 4 ""'],
-                          clean_lines.elided)
+                          'Line 2',
+                          'Line 3 ',
+                          'Line 4 ""'],
+                         clean_lines.elided)
 
     def test_init_empty(self):
         clean_lines = cpp_style.CleansedLines([])
         self.assertEqual([], clean_lines.raw_lines)
         self.assertEqual(0, clean_lines.num_lines())
 
     def test_collapse_strings(self):
         collapse = cpp_style.CleansedLines.collapse_strings
         self.assertEqual('""', collapse('""'))             # ""     (empty)
         self.assertEqual('"""', collapse('"""'))           # """    (bad)
         self.assertEqual('""', collapse('"xyz"'))          # "xyz"  (string)
         self.assertEqual('""', collapse('"\\\""'))         # "\""   (string)
         self.assertEqual('""', collapse('"\'"'))           # "'"    (string)
         self.assertEqual('"\"', collapse('"\"'))           # "\"    (bad)
         self.assertEqual('""', collapse('"\\\\"'))         # "\\"   (string)
         self.assertEqual('"', collapse('"\\\\\\"'))        # "\\\"  (bad)
         self.assertEqual('""', collapse('"\\\\\\\\"'))     # "\\\\" (string)
 
         self.assertEqual('\'\'', collapse('\'\''))         # ''     (empty)
         self.assertEqual('\'\'', collapse('\'a\''))        # 'a'    (char)
         self.assertEqual('\'\'', collapse('\'\\\'\''))     # '\''   (char)
         self.assertEqual('\'', collapse('\'\\\''))         # '\'    (bad)
         self.assertEqual('', collapse('\\012'))            # '\012' (char)
         self.assertEqual('', collapse('\\xfF0'))           # '\xfF0' (char)
         self.assertEqual('', collapse('\\n'))              # '\n' (char)
         self.assertEqual('\#', collapse('\\#'))            # '\#' (bad)
 
         self.assertEqual('StringReplace(body, "", "");',
-                          collapse('StringReplace(body, "\\\\", "\\\\\\\\");'))
+                         collapse('StringReplace(body, "\\\\", "\\\\\\\\");'))
         self.assertEqual('\'\' ""',
-                          collapse('\'"\' "foo"'))
+                         collapse('\'"\' "foo"'))
         self.assertEqual('""', collapse('"a" "b" "c"'))
 
 
 class OrderOfIncludesTest(CppStyleTestBase):
+
     def setUp(self):
         self.include_state = cpp_style._IncludeState()
 
         # Cheat os.path.abspath called in FileInfo class.
         self.os_path_abspath_orig = os.path.abspath
         os.path.abspath = lambda value: value
 
     def tearDown(self):
         os.path.abspath = self.os_path_abspath_orig
 
     def test_try_drop_common_suffixes(self):
         self.assertEqual('foo/foo', cpp_style._drop_common_suffixes('foo/foo-inl.h'))
         self.assertEqual('foo/bar/foo',
                          cpp_style._drop_common_suffixes('foo/bar/foo_inl.h'))
         self.assertEqual('foo/foo', cpp_style._drop_common_suffixes('foo/foo.cpp'))
         self.assertEqual('foo/foo_unusualinternal',
                          cpp_style._drop_common_suffixes('foo/foo_unusualinternal.h'))
         self.assertEqual('',
                          cpp_style._drop_common_suffixes('_test.cpp'))
         self.assertEqual('test',
                          cpp_style._drop_common_suffixes('test.cpp'))
 
 
 class OrderOfIncludesTest(CppStyleTestBase):
+
     def setUp(self):
         self.include_state = cpp_style._IncludeState()
 
         # Cheat os.path.abspath called in FileInfo class.
         self.os_path_abspath_orig = os.path.abspath
         self.os_path_isfile_orig = os.path.isfile
         os.path.abspath = lambda value: value
 
     def tearDown(self):
         os.path.abspath = self.os_path_abspath_orig
@@ skipping 86 matching lines @@
 
     def test_check_preprocessor_in_include_section(self):
         self.assert_language_rules_check('foo.cpp',
                                          '#include "foo.h"\n'
                                          '\n'
                                          '#ifdef BAZ\n'
                                          '#include "baz.h"\n'
                                          '#else\n'
                                          '#include "foobar.h"\n'
                                          '#endif"\n'
-                                         '#include "bar.h"\n', # No flag because previous is in preprocessor section
+                                         '#include "bar.h"\n',  # No flag because previous is in preprocessor section
                                          '')
 
         self.assert_language_rules_check('foo.cpp',
                                          '#include "foo.h"\n'
                                          '\n'
                                          '#ifdef BAZ\n'
                                          '#include "baz.h"\n'
                                          '#endif"\n'
                                          '#include "bar.h"\n'
-                                         '#include "a.h"\n', # Should still flag this.
+                                         '#include "a.h"\n',  # Should still flag this.
                                          'Alphabetical sorting problem.  [build/include_order] [4]')
 
         self.assert_language_rules_check('foo.cpp',
                                          '#include "foo.h"\n'
                                          '\n'
                                          '#ifdef BAZ\n'
                                          '#include "baz.h"\n'
-                                         '#include "bar.h"\n' #Should still flag this
+                                         '#include "bar.h"\n'  # Should still flag this
                                          '#endif"\n',
                                          'Alphabetical sorting problem.  [build/include_order] [4]')
 
         self.assert_language_rules_check('foo.cpp',
                                          '#include "foo.h"\n'
                                          '\n'
                                          '#ifdef BAZ\n'
                                          '#include "baz.h"\n'
                                          '#endif"\n'
                                          '#ifdef FOOBAR\n'
                                          '#include "foobar.h"\n'
                                          '#endif"\n'
                                          '#include "bar.h"\n'
-                                         '#include "a.h"\n', # Should still flag this.
+                                         '#include "a.h"\n',  # Should still flag this.
                                          'Alphabetical sorting problem.  [build/include_order] [4]')
 
         # Check that after an already included error, the sorting rules still work.
         self.assert_language_rules_check('foo.cpp',
                                          '#include "foo.h"\n'
                                          '\n'
                                          '#include "foo.h"\n'
                                          '#include "g.h"\n',
                                          '"foo.h" already included at foo.cpp:1  [build/include] [4]')
 
@@ skipping 160 matching lines @@
         self.assertEqual('foo/foo', cpp_style._drop_common_suffixes('foo/foo.cpp'))
         self.assertEqual('foo/foo_unusualinternal',
                          cpp_style._drop_common_suffixes('foo/foo_unusualinternal.h'))
         self.assertEqual('',
                          cpp_style._drop_common_suffixes('_test.cpp'))
         self.assertEqual('test',
                          cpp_style._drop_common_suffixes('test.cpp'))
         self.assertEqual('test',
                          cpp_style._drop_common_suffixes('test.cpp'))
 
+
 class CheckForFunctionLengthsTest(CppStyleTestBase):
+
     def setUp(self):
         # Reducing these thresholds for the tests speeds up tests significantly.
         self.old_normal_trigger = cpp_style._FunctionState._NORMAL_TRIGGER
         self.old_test_trigger = cpp_style._FunctionState._TEST_TRIGGER
 
         cpp_style._FunctionState._NORMAL_TRIGGER = 10
         cpp_style._FunctionState._TEST_TRIGGER = 25
 
     def tearDown(self):
         cpp_style._FunctionState._NORMAL_TRIGGER = self.old_normal_trigger
         cpp_style._FunctionState._TEST_TRIGGER = self.old_test_trigger
 
     # FIXME: Eliminate the need for this function.
     def set_min_confidence(self, min_confidence):
         """Set new test confidence and return old test confidence."""
         old_min_confidence = self.min_confidence
         self.min_confidence = min_confidence
         return old_min_confidence
 
     def assert_function_lengths_check(self, code, expected_message):
         """Check warnings for long function bodies are as expected.
 
         Args:
           code: C++ source code expected to generate a warning message.
           expected_message: Message expected to be generated by the C++ code.
         """
         self.assertEqual(expected_message,
-                          self.perform_function_lengths_check(code))
+                         self.perform_function_lengths_check(code))
 
     def trigger_lines(self, error_level):
         """Return number of lines needed to trigger a function length warning.
 
         Args:
           error_level: --v setting for cpp_style.
 
         Returns:
           Number of lines needed to trigger a function length warning.
         """
@@ skipping 488 matching lines @@
     # For http://webkit.org/coding/RefPtr.html
 
     def assert_pass_ptr_check(self, code, expected_message):
         """Check warnings for Pass*Ptr are as expected.
 
         Args:
           code: C++ source code expected to generate a warning message.
           expected_message: Message expected to be generated by the C++ code.
         """
         self.assertEqual(expected_message,
-                          self.perform_pass_ptr_check(code))
+                         self.perform_pass_ptr_check(code))
 
     def test_pass_ref_ptr_in_function(self):
         self.assert_pass_ptr_check(
             'int myFunction()\n'
             '{\n'
             '    PassRefPtr<Type1> variable = variable2;\n'
             '}',
             'Local variables should never be PassRefPtr (see '
             'http://webkit.org/coding/RefPtr.html).  [readability/pass_ptr] [5]')
 
@@ skipping 124 matching lines @@
 class LeakyPatternTest(CppStyleTestBase):
 
     def assert_leaky_pattern_check(self, code, expected_message):
         """Check warnings for leaky patterns are as expected.
 
         Args:
           code: C++ source code expected to generate a warning message.
           expected_message: Message expected to be generated by the C++ code.
         """
         self.assertEqual(expected_message,
-                          self.perform_leaky_pattern_check(code))
+                         self.perform_leaky_pattern_check(code))
 
     def test_get_dc(self):
         self.assert_leaky_pattern_check(
             'HDC hdc = GetDC(hwnd);',
             'Use the class HWndDC instead of calling GetDC to avoid potential '
             'memory leaks.  [runtime/leaky_pattern] [5]')
 
     def test_get_dc(self):
         self.assert_leaky_pattern_check(
             'HDC hdc = GetDCEx(hwnd, 0, 0);',
@@ skipping 898 matching lines @@
             '    doSomething1();\n'
             'else if (condition2) {\n'
             '    doSomething2();\n'
             '    doSomething2_2();\n'
             '} else {\n'
             '    doSomething3();\n'
             '    doSomething3_2();\n'
             '}\n',
             'If one part of an if-else statement uses curly braces, the other part must too.  [whitespace/braces] [4]')
 
-
         # 5. Control clauses without a body should use empty braces.
         self.assert_multi_line_lint(
             'for ( ; current; current = current->next) { }\n',
             '')
         self.assert_multi_line_lint(
             'for ( ; current;\n'
             '     current = current->next) { }\n',
             'Weird number of spaces at line-start.  Are you using a 4-space indent?  [whitespace/indent] [3]')
         self.assert_multi_line_lint(
             'for ( ; current; current = current->next);\n',
@@ skipping 399 matching lines @@
         # GObject requires certain magical names in class declarations.
         self.assert_lint('void webkit_dom_object_init();', '')
         self.assert_lint('void webkit_dom_object_class_init();', '')
 
         # 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')
+                         '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')
+                                               '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 34 matching lines @@
         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]'
 
         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.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.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.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.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.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.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.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.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.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.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.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.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.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]')
 
     def test_redundant_virtual(self):
-        self.assert_lint('virtual void fooMethod() override;', '"virtual" is redundant since function is already declared as "override"  [readability/inheritance] [4]')
-        self.assert_lint('virtual void fooMethod(\n) override {}', '"virtual" is redundant since function is already declared as "override"  [readability/inheritance] [4]')
-        self.assert_lint('virtual void fooMethod() final;', '"virtual" is redundant since function is already declared as "final"  [readability/inheritance] [4]')
-        self.assert_lint('virtual void fooMethod(\n) final {}', '"virtual" is redundant since function is already declared as "final"  [readability/inheritance] [4]')
+        self.assert_lint('virtual void fooMethod() override;',
+                         '"virtual" is redundant since function is already declared as "override"  [readability/inheritance] [4]')
+        self.assert_lint('virtual void fooMethod(\n) override {}',
+                         '"virtual" is redundant since function is already declared as "override"  [readability/inheritance] [4]')
+        self.assert_lint('virtual void fooMethod() final;',
+                         '"virtual" is redundant since function is already declared as "final"  [readability/inheritance] [4]')
+        self.assert_lint('virtual void fooMethod(\n) final {}',
+                         '"virtual" is redundant since function is already declared as "final"  [readability/inheritance] [4]')
 
     def test_redundant_override(self):
-        self.assert_lint('void fooMethod() override final;', '"override" is redundant since function is already declared as "final"  [readability/inheritance] [4]')
-        self.assert_lint('void fooMethod(\n) override final {}', '"override" is redundant since function is already declared as "final"  [readability/inheritance] [4]')
-        self.assert_lint('void fooMethod() final override;', '"override" is redundant since function is already declared as "final"  [readability/inheritance] [4]')
-        self.assert_lint('void fooMethod(\n) final override {}', '"override" is redundant since function is already declared as "final"  [readability/inheritance] [4]')
+        self.assert_lint('void fooMethod() override final;',
+                         '"override" is redundant since function is already declared as "final"  [readability/inheritance] [4]')
+        self.assert_lint('void fooMethod(\n) override final {}',
+                         '"override" is redundant since function is already declared as "final"  [readability/inheritance] [4]')
+        self.assert_lint('void fooMethod() final override;',
+                         '"override" is redundant since function is already declared as "final"  [readability/inheritance] [4]')
+        self.assert_lint('void fooMethod(\n) final override {}',
+                         '"override" is redundant since function is already declared as "final"  [readability/inheritance] [4]')
 
     def test_webkit_export_check(self):
         webkit_export_error_rules = ('-',
-                                  '+readability/webkit_export')
+                                     '+readability/webkit_export')
         self.assertEqual('',
-                          self.perform_lint('WEBKIT_EXPORT int foo();\n',
-                                            'WebKit/chromium/public/test.h',
-                                            webkit_export_error_rules))
+                         self.perform_lint('WEBKIT_EXPORT int foo();\n',
+                                           '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.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.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.perform_lint('WEBKIT_EXPORT int foo();\n',
-                                            'WebKit/chromium/src/test.h',
-                                            webkit_export_error_rules))
+                         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.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'
-                                            '}\n',
-                                            'WebKit/chromium/public/test.h',
-                                            webkit_export_error_rules))
+                         self.perform_lint('WEBKIT_EXPORT inline int foo()\n'
+                                           '{\n'
+                                           '}\n',
+                                           'WebKit/chromium/public/test.h',
+                                           webkit_export_error_rules))
         self.assertEqual('WEBKIT_EXPORT should not be used with a pure virtual function.  [readability/webkit_export] [5]',
-                          self.perform_lint('{}\n'
-                                            'WEBKIT_EXPORT\n'
-                                            'virtual\n'
-                                            'int\n'
-                                            'foo() = 0;\n',
-                                            'WebKit/chromium/public/test.h',
-                                            webkit_export_error_rules))
+                         self.perform_lint('{}\n'
+                                           'WEBKIT_EXPORT\n'
+                                           'virtual\n'
+                                           'int\n'
+                                           'foo() = 0;\n',
+                                           'WebKit/chromium/public/test.h',
+                                           webkit_export_error_rules))
         self.assertEqual('',
-                          self.perform_lint('{}\n'
-                                            'WEBKIT_EXPORT\n'
-                                            'virtual\n'
-                                            'int\n'
-                                            'foo() = 0;\n',
-                                            'test.h',
-                                            webkit_export_error_rules))
+                         self.perform_lint('{}\n'
+                                           'WEBKIT_EXPORT\n'
+                                           'virtual\n'
+                                           'int\n'
+                                           'foo() = 0;\n',
+                                           'test.h',
+                                           webkit_export_error_rules))
 
     def test_other(self):
         # FIXME: Implement this.
         pass
 
 
 class CppCheckerTest(unittest.TestCase):
 
     """Tests CppChecker class."""
 
@@ skipping 32 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)