Teach check-webkit-py in one more place that indent is now 2 spaces

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 492 matching lines @@
              'is_pure': True,
              'is_declaration': True})
 
     def test_ignore_macros(self):
         self.perform_function_detection(['void aFunctionName(int); \\'], None)
 
     def test_non_functions(self):
         # This case exposed an error because the open brace was in quotes.
         self.perform_function_detection(
             ['asm(',
-             '    "stmdb sp!, {r1-r3}" "\n"',
+             '  "stmdb sp!, {r1-r3}" "\n"',
              ');'],
             # This isn't a function but it looks like one to our simple
             # algorithm and that is ok.
             {'name': 'asm',
              'modifiers_and_return_type': '',
              'function_name_start_position': (0, 0),
              'parameter_start_position': (0, 3),
              'parameter_end_position': (2, 1),
              'body_start_position': (2, 1),
              'end_position': (2, 2),
@@ skipping 776 matching lines @@
             '  [readability/multiline_comment] [5]')
 
     # Test suspicious usage of "if" like this:
     # if (a == b) {
     #   DoSomething();
     # } if (a == c) {   // Should be "else if".
     #   DoSomething();  // This gets called twice if a == b && a == c.
     # }
     def test_suspicious_usage_of_if(self):
         self.assert_lint(
-            '    if (a == b) {',
+            '  if (a == b) {',
             '')
         self.assert_lint(
-            '    } if (a == b) {',
+            '  } if (a == b) {',
             'Did you mean "else if"? If not, start a new line for "if".'
             '  [readability/braces] [4]')
 
     # Test suspicious usage of memset. Specifically, a 0
     # as the final argument is almost certainly an error.
     def test_suspicious_usage_of_memset(self):
         # Normal use is okay.
         self.assert_lint(
-            '    memset(buf, 0, sizeof(buf))',
+            '  memset(buf, 0, sizeof(buf))',
             '')
 
         # A 0 as the final argument is almost certainly an error.
         self.assert_lint(
-            '    memset(buf, sizeof(buf), 0)',
+            '  memset(buf, sizeof(buf), 0)',
             'Did you mean "memset(buf, 0, sizeof(buf))"?'
             '  [runtime/memset] [4]')
         self.assert_lint(
-            '    memset(buf, xsize * ysize, 0)',
+            '  memset(buf, xsize * ysize, 0)',
             'Did you mean "memset(buf, 0, xsize * ysize)"?'
             '  [runtime/memset] [4]')
 
         # There is legitimate test code that uses this form.
         # This is okay since the second argument is a literal.
         self.assert_lint(
             "    memset(buf, 'y', 0)",
             '')
         self.assert_lint(
-            '    memset(buf, 4, 0)',
+            '  memset(buf, 4, 0)',
             '')
         self.assert_lint(
-            '    memset(buf, -1, 0)',
+            '  memset(buf, -1, 0)',
             '')
         self.assert_lint(
-            '    memset(buf, 0xF1, 0)',
+            '  memset(buf, 0xF1, 0)',
             '')
         self.assert_lint(
-            '    memset(buf, 0xcd, 0)',
+            '  memset(buf, 0xcd, 0)',
             '')
 
     def test_check_posix_threading(self):
         self.assert_lint('sctime_r()', '')
         self.assert_lint('strtok_r()', '')
-        self.assert_lint('    strtok_r(foo, ba, r)', '')
+        self.assert_lint('  strtok_r(foo, ba, r)', '')
         self.assert_lint('brand()', '')
         self.assert_lint('_rand()', '')
         self.assert_lint('.rand()', '')
         self.assert_lint('>rand()', '')
         self.assert_lint('rand()',
                          'Consider using rand_r(...) instead of rand(...)'
                          ' for improved thread safety.'
                          '  [runtime/threadsafe_fn] [2]')
         self.assert_lint('strtok()',
                          'Consider using strtok_r(...) '
@@ skipping 183 matching lines @@
         self.assert_lint('CHECK(CreateTestFile(dir, (1 >> 20)));', '')
 
         self.assert_lint('CHECK(x<42)',
                          'Consider using CHECK_LT instead of CHECK(a < b)'
                          '  [readability/check] [2]')
         self.assert_lint('CHECK(x>42)',
                          'Consider using CHECK_GT instead of CHECK(a > b)'
                          '  [readability/check] [2]')
 
         self.assert_lint(
-            '    EXPECT_TRUE(42 < x) // Random comment.',
+            '  EXPECT_TRUE(42 < x) // Random comment.',
             'Consider using EXPECT_LT instead of EXPECT_TRUE(a < b)'
             '  [readability/check] [2]')
         self.assert_lint(
             'EXPECT_TRUE( 42 < x )',
             'Consider using EXPECT_LT instead of EXPECT_TRUE(a < b)'
             '  [readability/check] [2]')
         self.assert_lint(
             'CHECK("foo" == "foo")',
             'Consider using CHECK_EQ instead of CHECK(a == b)'
             '  [readability/check] [2]')
 
         self.assert_lint('CHECK_EQ("foo", "foo")', '')
 
     def test_check_deprecated_macros(self):
         self.assert_lint('ASSERT(foo)', 'ASSERT is deprecated. Use DCHECK or '
                          'its variants instead.  [build/deprecated] [5]')
-        self.assert_lint('    ASSERT_UNUSED(foo, foo)', 'ASSERT_UNUSED is '
+        self.assert_lint('  ASSERT_UNUSED(foo, foo)', 'ASSERT_UNUSED is '
                          'deprecated. Use DCHECK or its variants instead.  '
                          '[build/deprecated] [5]')
         self.assert_lint('ASSERT_NOT_REACHED()', 'ASSERT_NOT_REACHED is '
                          'deprecated. Use NOTREACHED instead.  '
                          '[build/deprecated] [5]')
         self.assert_lint('ASSERT_WITH_SECURITY_IMPLICATION(foo)',
                          'ASSERT_WITH_SECURITY_IMPLICATION is deprecated. Use '
                          'SECURITY_DCHECK instead.  [build/deprecated] [5]')
         self.assert_lint('WTF_LOG(foo)', 'WTF_LOG is deprecated. Use DVLOG '
                          'instead.  [build/deprecated] [5]')
@@ skipping 32 matching lines @@
         self.assert_lint('string Foo::bar;',
                          'For a static/global string constant, use a C style '
                          'string instead: "char Foo::bar[]".'
                          '  [runtime/string] [4]')
         # Rare case.
         self.assert_lint('string foo("foobar");',
                          'For a static/global string constant, use a C style '
                          'string instead: "char foo[]".'
                          '  [runtime/string] [4]')
         # Should not catch local or member variables.
-        self.assert_lint('    string foo', '')
+        self.assert_lint('  string foo', '')
         # Should not catch functions.
         self.assert_lint('string EmptyString() { return ""; }', '')
         self.assert_lint('string EmptyString () { return ""; }', '')
         self.assert_lint('string VeryLongNameFunctionSometimesEndsWith(\n'
                          '    VeryLongNameType veryLongNameVariable) { }', '')
         self.assert_lint('template<>\n'
                          'string FunctionTemplateSpecialization<SomeType>(\n'
                          '    int x) { return ""; }', '')
         self.assert_lint('template<>\n'
                          'string FunctionTemplateSpecialization<vector<A::B>* >(\n'
                          '    int x) { return ""; }', '')
 
         # should not catch methods of template classes.
         self.assert_lint('string Class<Type>::Method() const\n'
                          '{\n'
-                         '    return "";\n'
+                         '  return "";\n'
                          '}\n', '')
         self.assert_lint('string Class<Type>::Method(\n'
                          '    int arg) const\n'
                          '{\n'
-                         '    return "";\n'
+                         '  return "";\n'
                          '}\n', '')
 
     def test_no_spaces_in_function_calls(self):
         self.assert_lint('TellStory(1, 3);',
                          '')
         self.assert_lint('TellStory(1 /* wolf */, 3 /* pigs */);',
                          '')
         self.assert_multi_line_lint('#endif\n    );',
                                     '')
 
@@ skipping 57 matching lines @@
         self.assert_multi_line_lint(
             '''\
             struct Foo*
                 foo = NewFoo();''',
             '')
         # Here is an example where the linter gets confused, even though
         # the code doesn't violate the style guide.
         self.assert_multi_line_lint(
             'class Foo\n'
             '#ifdef DERIVE_FROM_GOO\n'
-            '    : public Goo {\n'
+            '  : public Goo {\n'
             '#else\n'
-            '    : public Hoo {\n'
+            '  : public Hoo {\n'
             '#endif\n'
             '};',
             'Failed to find complete declaration of class Foo'
             '  [build/class] [5]')
 
     def test_build_end_comment(self):
         # The crosstool compiler we currently use will fail to compile the
         # code in this test, so we might consider removing the lint check.
         self.assert_lint('#endif Not a comment',
                          'Uncommented text after #endif is non-standard.'
@@ skipping 366 matching lines @@
                         'MyClass', False)
         build_test_case([('unsigned', 'm_unsignedMember', 4), ('unsigned', 'm_anotherUnsigned', 3)],
                         'MyClass', False)
 
         build_test_case([('bool', 'm_boolMember', 4), ('bool', 'm_anotherbool', 3),
                          ('bool', 'm_moreBool', 1), ('bool', 'm_lastBool', 1),
                          ('unsigned int', 'm_tokenUnsigned', 4)],
                         'MyClass', True, ['Omit int when using unsigned  [runtime/unsigned] [1]'])
 
         self.assert_multi_line_lint('class NoProblemsHere {\n'
-                                    '    bool m_boolMember;\n'
-                                    '    unsigned m_unsignedMember;\n'
-                                    '    unsigned m_bitField1 : 1;\n'
-                                    '    unsigned m_bitField4 : 4;\n'
+                                    '  bool m_boolMember;\n'
+                                    '  unsigned m_unsignedMember;\n'
+                                    '  unsigned m_bitField1 : 1;\n'
+                                    '  unsigned m_bitField4 : 4;\n'
                                     '}\n', '')
 
     # Bitfields which are not declared unsigned or bool will generate a warning.
     def test_unsigned_bool_bitfields(self):
         def errmsg(member, name, bit_type):
             return ('Member %s of class %s defined as a bitfield of type %s. '
                     'Please declare all bitfields as unsigned.  [runtime/bitfields] [4]'
                     % (member, name, bit_type))
 
         def warning_bitfield_test(member, name, bit_type, bits):
@@ skipping 525 matching lines @@
     def assert_function_length_check_above_error_level(self, error_level):
         """Generate and check function just above the trigger level for --v setting.
 
         Args:
           error_level: --v setting for cpp_style.
         """
         self.assert_function_length_check_definition(self.trigger_lines(error_level) + 1,
                                                      error_level)
 
     def function_body(self, number_of_lines):
-        return ' {\n' + '    this_is_just_a_test();\n' * number_of_lines + '}'
+        return ' {\n' + '  this_is_just_a_test();\n' * number_of_lines + '}'
 
     def function_body_with_blank_lines(self, number_of_lines):
-        return ' {\n' + '    this_is_just_a_test();\n\n' * number_of_lines + '}'
+        return ' {\n' + '  this_is_just_a_test();\n\n' * number_of_lines + '}'
 
     def function_body_with_no_lints(self, number_of_lines):
-        return ' {\n' + '    this_is_just_a_test();  // NOLINT\n' * number_of_lines + '}'
+        return ' {\n' + '  this_is_just_a_test();  // NOLINT\n' * number_of_lines + '}'
 
     # Test line length checks.
     def test_function_length_check_declaration(self):
         self.assert_function_lengths_check(
             'void test();',  # Not a function definition
             '')
 
     def test_function_length_check_declaration_with_block_following(self):
         self.assert_function_lengths_check(
             ('void test();\n'
@@ skipping 46 matching lines @@
     def test_function_length_check_definition_at_severity1(self):
         self.assert_function_length_check_definition_ok(self.trigger_lines(1))
 
     def test_function_length_check_definition_above_severity1(self):
         self.assert_function_length_check_above_error_level(1)
 
     def test_function_length_check_definition_severity1_plus_indented(self):
         error_level = 1
         error_lines = self.trigger_lines(error_level) + 1
         trigger_level = self.trigger_lines(self.min_confidence)
-        indent_spaces = '    '
+        indent_spaces = '  '
         self.assert_function_lengths_check(
             re.sub(r'(?m)^(.)', indent_spaces + r'\1',
                    'void test_indent(int x)\n' + self.function_body(error_lines)),
             ('Small and focused functions are preferred: '
              'test_indent() has %d non-comment lines '
              '(error triggered by exceeding %d lines).'
              '  [readability/fn_size] [%d]')
             % (error_lines, trigger_level, error_level))
 
     def test_function_length_check_definition_severity1_plus_blanks(self):
@@ skipping 164 matching lines @@
 
         self.assert_multi_line_lint(
             '''\
                 class Foo::Goo {
                     virtual ~Goo();
                     virtual void goo();
                 };''',
             '')
         self.assert_multi_line_lint(
             'class MyClass {\n'
-            '    int getIntValue() { DCHECK(m_ptr); return *m_ptr; }\n'
+            '  int getIntValue() { DCHECK(m_ptr); return *m_ptr; }\n'
             '};\n',
             '')
 
         self.assert_multi_line_lint(
             '''\
                 class Qualified::Goo : public Foo {
                     virtual void goo();
                 };''',
             '')
 
@@ skipping 129 matching lines @@
           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))
 
     def test_pass_ref_ptr_in_function(self):
         self.assert_pass_ptr_check(
             'int myFunction()\n'
             '{\n'
-            '    PassRefPtr<Type1> variable = variable2;\n'
+            '  PassRefPtr<Type1> variable = variable2;\n'
             '}',
             'Local variables should never be PassRefPtr (see '
             'http://webkit.org/coding/RefPtr.html).  [readability/pass_ptr] [5]')
 
     def test_pass_own_ptr_in_function(self):
         self.assert_pass_ptr_check(
             'int myFunction()\n'
             '{\n'
-            '    PassOwnPtr<Type1> variable = variable2;\n'
+            '  PassOwnPtr<Type1> variable = variable2;\n'
             '}',
             'Local variables should never be PassOwnPtr (see '
             'http://webkit.org/coding/RefPtr.html).  [readability/pass_ptr] [5]')
 
     def test_pass_other_type_ptr_in_function(self):
         self.assert_pass_ptr_check(
             'int myFunction()\n'
             '{\n'
-            '    PassOtherTypePtr<Type1> variable;\n'
+            '  PassOtherTypePtr<Type1> variable;\n'
             '}',
             'Local variables should never be PassOtherTypePtr (see '
             'http://webkit.org/coding/RefPtr.html).  [readability/pass_ptr] [5]')
 
     def test_pass_ref_ptr_return_value(self):
         self.assert_pass_ptr_check(
             'PassRefPtr<Type1>\n'
             'myFunction(int)\n'
             '{\n'
             '}',
@@ skipping 55 matching lines @@
             '')
         self.assert_pass_ptr_check(
             'int myFunction(OwnPtr<Type1>& simple)\n'
             '{\n'
             '}',
             '')
 
     def test_ref_ptr_member_variable(self):
         self.assert_pass_ptr_check(
             'class Foo {'
-            '    RefPtr<Type1> m_other;\n'
+            '  RefPtr<Type1> m_other;\n'
             '};\n',
             '')
 
 
 class LeakyPatternTest(CppStyleTestBase):
 
     def assert_leaky_pattern_check(self, code, expected_message):
         """Check warnings for leaky patterns are as expected.
 
         Args:
@@ skipping 43 matching lines @@
 class WebKitStyleTest(CppStyleTestBase):
 
     # for https://www.chromium.org/blink/coding-style
 
     def test_line_breaking(self):
         # 2. An else statement should go on the same line as a preceding
         #   close brace if one is present, else it should line up with the
         #   if statement.
         self.assert_multi_line_lint(
             'if (condition) {\n'
-            '    doSomething();\n'
-            '    doSomethingAgain();\n'
+            '  doSomething();\n'
+            '  doSomethingAgain();\n'
             '} else {\n'
-            '    doSomethingElse();\n'
-            '    doSomethingElseAgain();\n'
+            '  doSomethingElse();\n'
+            '  doSomethingElseAgain();\n'
             '}\n',
             '')
         self.assert_multi_line_lint(
             'if (condition)\n'
-            '    doSomething();\n'
+            '  doSomething();\n'
             'else\n'
-            '    doSomethingElse();\n',
+            '  doSomethingElse();\n',
             '')
         self.assert_multi_line_lint(
             'if (condition) {\n'
-            '    doSomething();\n'
+            '  doSomething();\n'
             '} else {\n'
-            '    doSomethingElse();\n'
-            '    doSomethingElseAgain();\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',
             '')
         # FIXME: currently we only check first conditional, so we cannot detect errors in next ones.
         self.assert_multi_line_lint(
             'WTF_MAKE_NONCOPYABLE(ClassName); WTF_MAKE_FAST_ALLOCATED;\n',
             '')
         self.assert_multi_line_lint(
             'if (condition) doSomething(); else {\n'
-            '    doSomethingElse();\n'
+            '  doSomethingElse();\n'
             '}\n',
             'If one part of an if-else statement uses curly braces, the other part must too.  [whitespace/braces] [4]')
         self.assert_multi_line_lint(
             'void func()\n'
             '{\n'
-            '    while (condition) { }\n'
-            '    return 0;\n'
+            '  while (condition) { }\n'
+            '  return 0;\n'
             '}\n',
             '')
 
         # 3. An else if statement should be written as an if statement
         #    when the prior if concludes with a return statement.
         self.assert_multi_line_lint(
             'if (motivated) {\n'
-            '    if (liquid)\n'
-            '        return money;\n'
+            '  if (liquid)\n'
+            '    return money;\n'
             '} else if (tired) {\n'
-            '    break;\n'
+            '  break;\n'
             '}',
             '')
         self.assert_multi_line_lint(
             'if (condition)\n'
-            '    doSomething();\n'
+            '  doSomething();\n'
             'else if (otherCondition)\n'
-            '    doSomethingElse();\n',
+            '  doSomethingElse();\n',
             '')
         self.assert_multi_line_lint(
             'if (condition)\n'
-            '    doSomething();\n'
+            '  doSomething();\n'
             'else\n'
-            '    doSomethingElse();\n',
+            '  doSomethingElse();\n',
             '')
         self.assert_multi_line_lint(
             'if (condition)\n'
-            '    returnValue = foo;\n'
+            '  returnValue = foo;\n'
             'else if (otherCondition)\n'
-            '    returnValue = bar;\n',
+            '  returnValue = bar;\n',
             '')
         self.assert_multi_line_lint(
             'if (condition)\n'
-            '    returnValue = foo;\n'
+            '  returnValue = foo;\n'
             'else\n'
-            '    returnValue = bar;\n',
+            '  returnValue = bar;\n',
             '')
         self.assert_multi_line_lint(
             'if (condition)\n'
-            '    doSomething();\n'
+            '  doSomething();\n'
             'else if (liquid)\n'
-            '    return money;\n'
+            '  return money;\n'
             'else if (broke)\n'
-            '    return favor;\n'
+            '  return favor;\n'
             'else\n'
-            '    sleep(28800);\n',
+            '  sleep(28800);\n',
             '')
         self.assert_multi_line_lint(
             'if (liquid) {\n'
-            '    prepare();\n'
-            '    return money;\n'
+            '  prepare();\n'
+            '  return money;\n'
             '} else if (greedy) {\n'
-            '    keep();\n'
-            '    return nothing;\n'
+            '  keep();\n'
+            '  return nothing;\n'
             '}\n',
             'An else if statement should be written as an if statement when the '
             'prior "if" concludes with a return, break, continue or goto statement.'
             '  [readability/control_flow] [4]')
         self.assert_multi_line_lint(
-            '    if (stupid) {\n'
+            '  if (stupid) {\n'
             'infiniteLoop:\n'
-            '        goto infiniteLoop;\n'
-            '    } else if (evil)\n'
-            '        goto hell;\n',
+            '    goto infiniteLoop;\n'
+            '  } else if (evil)\n'
+            '    goto hell;\n',
             ['If one part of an if-else statement uses curly braces, the other part must too.  [whitespace/braces] [4]',
              'An else if statement should be written as an if statement when the '
              'prior "if" concludes with a return, break, continue or goto statement.'
              '  [readability/control_flow] [4]'])
         self.assert_multi_line_lint(
             'if (liquid)\n'
             '{\n'
-            '    prepare();\n'
-            '    return money;\n'
+            '  prepare();\n'
+            '  return money;\n'
             '}\n'
             'else if (greedy)\n'
-            '    keep();\n',
+            '  keep();\n',
             ['If one part of an if-else statement uses curly braces, the other part must too.  [whitespace/braces] [4]',
              'An else if statement should be written as an if statement when the '
              'prior "if" concludes with a return, break, continue or goto statement.'
              '  [readability/control_flow] [4]'])
         self.assert_multi_line_lint(
             'if (gone)\n'
-            '    return;\n'
+            '  return;\n'
             'else if (here)\n'
-            '    go();\n',
+            '  go();\n',
             'An else if statement should be written as an if statement when the '
             'prior "if" concludes with a return, break, continue or goto statement.'
             '  [readability/control_flow] [4]')
         self.assert_multi_line_lint(
             'if (gone)\n'
-            '    return;\n'
+            '  return;\n'
             'else\n'
-            '    go();\n',
+            '  go();\n',
             'An else statement can be removed when the prior "if" concludes '
             'with a return, break, continue or goto statement.'
             '  [readability/control_flow] [4]')
         self.assert_multi_line_lint(
             'if (motivated) {\n'
-            '    prepare();\n'
-            '    continue;\n'
+            '  prepare();\n'
+            '  continue;\n'
             '} else {\n'
-            '    cleanUp();\n'
-            '    break;\n'
+            '  cleanUp();\n'
+            '  break;\n'
             '}\n',
             'An else statement can be removed when the prior "if" concludes '
             'with a return, break, continue or goto statement.'
             '  [readability/control_flow] [4]')
         self.assert_multi_line_lint(
             'if (tired)\n'
-            '    break;\n'
+            '  break;\n'
             'else {\n'
-            '    prepare();\n'
-            '    continue;\n'
+            '  prepare();\n'
+            '  continue;\n'
             '}\n',
             ['If one part of an if-else statement uses curly braces, the other part must too.  [whitespace/braces] [4]',
              'An else statement can be removed when the prior "if" concludes '
              'with a return, break, continue or goto statement.'
              '  [readability/control_flow] [4]'])
 
     def test_braces(self):
         # 3. Curly braces are not required for single-line conditionals and
         #    loop bodies, but are required for single-statement bodies that
         #    span multiple lines.
 
         #
         # Positive tests
         #
         self.assert_multi_line_lint(
             'if (condition1)\n'
-            '    statement1();\n'
+            '  statement1();\n'
             'else\n'
-            '    statement2();\n',
+            '  statement2();\n',
             '')
 
         self.assert_multi_line_lint(
             'if (condition1)\n'
-            '    statement1();\n'
+            '  statement1();\n'
             'else if (condition2)\n'
-            '    statement2();\n',
+            '  statement2();\n',
             '')
 
         self.assert_multi_line_lint(
             'if (condition1)\n'
-            '    statement1();\n'
+            '  statement1();\n'
             'else if (condition2)\n'
-            '    statement2();\n'
+            '  statement2();\n'
             'else\n'
-            '    statement3();\n',
+            '  statement3();\n',
             '')
 
         self.assert_multi_line_lint(
             'for (; foo; bar)\n'
-            '    int foo;\n',
+            '  int foo;\n',
             '')
 
         self.assert_multi_line_lint(
             'for (; foo; bar) {\n'
-            '    int foo;\n'
+            '  int foo;\n'
             '}\n',
             '')
 
         self.assert_multi_line_lint(
             'foreach (foo, foos) {\n'
-            '    int bar;\n'
+            '  int bar;\n'
             '}\n',
             '')
 
         self.assert_multi_line_lint(
             'foreach (foo, foos)\n'
-            '    int bar;\n',
+            '  int bar;\n',
             '')
 
         self.assert_multi_line_lint(
             'while (true) {\n'
-            '    int foo;\n'
+            '  int foo;\n'
             '}\n',
             '')
 
         self.assert_multi_line_lint(
             'while (true)\n'
-            '    int foo;\n',
+            '  int foo;\n',
             '')
 
         self.assert_multi_line_lint(
             'if (condition1) {\n'
-            '    statement1();\n'
+            '  statement1();\n'
             '} else {\n'
-            '    statement2();\n'
+            '  statement2();\n'
             '}\n',
             '')
 
         self.assert_multi_line_lint(
             'if (condition1) {\n'
-            '    statement1();\n'
+            '  statement1();\n'
             '} else if (condition2) {\n'
-            '    statement2();\n'
+            '  statement2();\n'
             '}\n',
             '')
 
         self.assert_multi_line_lint(
             'if (condition1) {\n'
-            '    statement1();\n'
+            '  statement1();\n'
             '} else if (condition2) {\n'
-            '    statement2();\n'
+            '  statement2();\n'
             '} else {\n'
-            '    statement3();\n'
+            '  statement3();\n'
             '}\n',
             '')
 
         self.assert_multi_line_lint(
             'if (condition1) {\n'
-            '    statement1();\n'
-            '    statement1_2();\n'
+            '  statement1();\n'
+            '  statement1_2();\n'
             '} else if (condition2) {\n'
-            '    statement2();\n'
-            '    statement2_2();\n'
+            '  statement2();\n'
+            '  statement2_2();\n'
             '}\n',
             '')
 
         self.assert_multi_line_lint(
             'if (condition1) {\n'
-            '    statement1();\n'
-            '    statement1_2();\n'
+            '  statement1();\n'
+            '  statement1_2();\n'
             '} else if (condition2) {\n'
-            '    statement2();\n'
-            '    statement2_2();\n'
+            '  statement2();\n'
+            '  statement2_2();\n'
             '} else {\n'
-            '    statement3();\n'
-            '    statement3_2();\n'
+            '  statement3();\n'
+            '  statement3_2();\n'
             '}\n',
             '')
 
         #
         # Negative tests
         #
 
         self.assert_multi_line_lint(
             'if (condition)\n'
-            '    doSomething(\n'
-            '        spanningMultipleLines);\n',
+            '  doSomething(\n'
+            '      spanningMultipleLines);\n',
             'A conditional or loop body must use braces if the statement is more than one line long.  [whitespace/braces] [4]')
 
         self.assert_multi_line_lint(
             'if (condition)\n'
-            '    // Single-line comment\n'
-            '    doSomething();\n',
+            '  // Single-line comment\n'
+            '  doSomething();\n',
             'A conditional or loop body must use braces if the statement is more than one line long.  [whitespace/braces] [4]')
 
         self.assert_multi_line_lint(
             'if (condition1)\n'
-            '    statement1();\n'
+            '  statement1();\n'
             'else if (condition2)\n'
-            '    // Single-line comment\n'
-            '    statement2();\n',
+            '  // Single-line comment\n'
+            '  statement2();\n',
             'A conditional or loop body must use braces if the statement is more than one line long.  [whitespace/braces] [4]')
 
         self.assert_multi_line_lint(
             'if (condition1)\n'
-            '    statement1();\n'
+            '  statement1();\n'
             'else if (condition2)\n'
-            '    statement2();\n'
+            '  statement2();\n'
             'else\n'
-            '    // Single-line comment\n'
-            '    statement3();\n',
+            '  // Single-line comment\n'
+            '  statement3();\n',
             'A conditional or loop body must use braces if the statement is more than one line long.  [whitespace/braces] [4]')
 
         self.assert_multi_line_lint(
             'for (; foo; bar)\n'
-            '    // Single-line comment\n'
-            '    int foo;\n',
+            '  // Single-line comment\n'
+            '  int foo;\n',
             'A conditional or loop body must use braces if the statement is more than one line long.  [whitespace/braces] [4]')
 
         self.assert_multi_line_lint(
             'foreach (foo, foos)\n'
-            '    // Single-line comment\n'
-            '    int bar;\n',
+            '  // Single-line comment\n'
+            '  int bar;\n',
             'A conditional or loop body must use braces if the statement is more than one line long.  [whitespace/braces] [4]')
 
         self.assert_multi_line_lint(
             'while (true)\n'
-            '    // Single-line comment\n'
-            '    int foo;\n'
+            '  // Single-line comment\n'
+            '  int foo;\n'
             '\n',
             'A conditional or loop body must use braces if the statement is more than one line long.  [whitespace/braces] [4]')
 
         # 4. If one part of an if-else statement uses curly braces, the
         #    other part must too.
 
         self.assert_multi_line_lint(
             'if (condition1) {\n'
-            '    doSomething1();\n'
-            '    doSomething1_2();\n'
+            '  doSomething1();\n'
+            '  doSomething1_2();\n'
             '} else if (condition2)\n'
-            '    doSomething2();\n'
+            '  doSomething2();\n'
             'else\n'
-            '    doSomething3();\n',
+            '  doSomething3();\n',
             'If one part of an if-else statement uses curly braces, the other part must too.  [whitespace/braces] [4]')
 
         self.assert_multi_line_lint(
             'if (condition1)\n'
-            '    doSomething1();\n'
+            '  doSomething1();\n'
             'else if (condition2) {\n'
-            '    doSomething2();\n'
-            '    doSomething2_2();\n'
+            '  doSomething2();\n'
+            '  doSomething2_2();\n'
             '} else\n'
-            '    doSomething3();\n',
+            '  doSomething3();\n',
             'If one part of an if-else statement uses curly braces, the other part must too.  [whitespace/braces] [4]')
 
         self.assert_multi_line_lint(
             'if (condition1) {\n'
-            '    doSomething1();\n'
+            '  doSomething1();\n'
             '} else if (condition2) {\n'
-            '    doSomething2();\n'
-            '    doSomething2_2();\n'
+            '  doSomething2();\n'
+            '  doSomething2_2();\n'
             '} else\n'
-            '    doSomething3();\n',
+            '  doSomething3();\n',
             'If one part of an if-else statement uses curly braces, the other part must too.  [whitespace/braces] [4]')
 
         self.assert_multi_line_lint(
             'if (condition1)\n'
-            '    doSomething1();\n'
+            '  doSomething1();\n'
             'else if (condition2)\n'
-            '    doSomething2();\n'
+            '  doSomething2();\n'
             'else {\n'
-            '    doSomething3();\n'
-            '    doSomething3_2();\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]')
 
         self.assert_multi_line_lint(
             'if (condition1) {\n'
-            '    doSomething1();\n'
-            '    doSomething1_2();\n'
+            '  doSomething1();\n'
+            '  doSomething1_2();\n'
             '} else if (condition2)\n'
-            '    doSomething2();\n'
+            '  doSomething2();\n'
             'else {\n'
-            '    doSomething3();\n'
-            '    doSomething3_2();\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]')
 
         self.assert_multi_line_lint(
             'if (condition1)\n'
-            '    doSomething1();\n'
+            '  doSomething1();\n'
             'else if (condition2) {\n'
-            '    doSomething2();\n'
-            '    doSomething2_2();\n'
+            '  doSomething2();\n'
+            '  doSomething2_2();\n'
             '} else {\n'
-            '    doSomething3();\n'
-            '    doSomething3_2();\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; current = current->next);\n',
             'Semicolon defining empty statement for this loop. Use { } instead.  [whitespace/semicolon] [5]')
@@ skipping 626 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)