blink: Remove include ordering checks, clang-format does this now.

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 2253 matching lines @@
     def test_check_next_include_order__other_then_config(self):
         self.assertEqual('Found other header before a header this file implements.',
                          self.include_state.check_next_include_order(cpp_style._OTHER_HEADER, False, True))
 
     def test_check_next_include_order__config_then_other_then_likely(self):
         self.assertEqual('Found other header before a header this file implements.',
                          self.include_state.check_next_include_order(cpp_style._OTHER_HEADER, False, True))
         self.assertEqual('Found header this file implements after other header.',
                          self.include_state.check_next_include_order(cpp_style._PRIMARY_HEADER, False, True))
 
-    def test_check_alphabetical_include_order(self):
-        self.assert_language_rules_check('foo.h',
-                                         '#include "a.h"\n'
-                                         '#include "c.h"\n'
-                                         '#include "b.h"\n',
-                                         'Alphabetical sorting problem.  [build/include_order] [4]')
-
-        self.assert_language_rules_check('foo.h',
-                                         '#include "a.h"\n'
-                                         '#include "b.h"\n'
-                                         '#include "c.h"\n',
-                                         '')
-
-        self.assert_language_rules_check('foo.h',
-                                         '#include <assert.h>\n'
-                                         '#include "bar.h"\n',
-                                         'Alphabetical sorting problem.  [build/include_order] [4]')
-
-        self.assert_language_rules_check('foo.h',
-                                         '#include "bar.h"\n'
-                                         '#include <assert.h>\n',
-                                         '')
-
-    def test_check_alphabetical_include_order_errors_reported_for_both_lines(self):
-        # If one of the two lines of out of order headers are filtered, the error should be
-        # reported on the other line.
-        self.assert_language_rules_check('foo.h',
-                                         '#include "a.h"\n'
-                                         '#include "c.h"\n'
-                                         '#include "b.h"\n',
-                                         'Alphabetical sorting problem.  [build/include_order] [4]',
-                                         lines_to_check=[2])
-
-        self.assert_language_rules_check('foo.h',
-                                         '#include "a.h"\n'
-                                         '#include "c.h"\n'
-                                         '#include "b.h"\n',
-                                         'Alphabetical sorting problem.  [build/include_order] [4]',
-                                         lines_to_check=[3])
-
-        # If no lines are filtered, the error should be reported only once.
-        self.assert_language_rules_check('foo.h',
-                                         '#include "a.h"\n'
-                                         '#include "c.h"\n'
-                                         '#include "b.h"\n',
-                                         'Alphabetical sorting problem.  [build/include_order] [4]')
-
     def test_check_line_break_after_own_header(self):
         self.assert_language_rules_check('foo.cpp',
                                          '#include "foo.h"\n'
                                          '#include "bar.h"\n',
                                          ('You should add a blank line after implementation file\'s own header.'
                                           '  [build/include_order] [4]'))
 
         self.assert_language_rules_check('foo.cpp',
                                          '#include "foo.h"\n'
                                          '\n'
                                          '#include "bar.h"\n',
                                          '')
 
     def test_check_preprocessor_in_include_section(self):
         self.assert_language_rules_check('foo.cpp',
                                          '#include "foo.h"\n'
                                          '\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
                                          '')
 
-        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.
-                                         '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
-                                         '#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.
-                                         '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]')
 
     def test_primary_header(self):
         # File with non-existing primary header should not produce errors.
@@ skipping 23 matching lines @@
                                           'alphabetically sorted.  [build/include_order] [4]'])
         # Having include for existing primary header -> no error.
         self.assert_language_rules_check('foo.cpp',
                                          '#include "foo.h"\n'
                                          '\n'
                                          '#include "bar.h"\n',
                                          '')
 
         os.path.isfile = self.os_path_isfile_orig
 
-    def test_public_primary_header(self):
-        # System header is not considered a primary header.
-        self.assert_language_rules_check('foo.cpp',
-                                         '#include "config.h"\n'
-                                         '#include <other/foo.h>\n'
-                                         '\n'
-                                         '#include "a.h"\n',
-                                         'Alphabetical sorting problem.  [build/include_order] [4]')
-
-        # ...except that it starts with public/.
-        self.assert_language_rules_check('foo.cpp',
-                                         '#include <public/foo.h>\n'
-                                         '\n'
-                                         '#include "a.h"\n',
-                                         '')
-
-        # Even if it starts with public/ its base part must match with the source file name.
-        self.assert_language_rules_check('foo.cpp',
-                                         '#include "config.h"\n'
-                                         '#include <public/foop.h>\n'
-                                         '\n'
-                                         '#include "a.h"\n',
-                                         'Alphabetical sorting problem.  [build/include_order] [4]')
-
     def test_check_wtf_includes(self):
         self.assert_language_rules_check('foo.cpp',
                                          '#include "foo.h"\n'
                                          '\n'
                                          '#include <wtf/Assertions.h>\n',
                                          'wtf includes should be "wtf/file.h" instead of <wtf/file.h>.'
                                          '  [build/include] [4]')
         self.assert_language_rules_check('foo.cpp',
                                          '#include "foo.h"\n'
                                          '\n'
@@ skipping 32 matching lines @@
                                           'string',
                                           True, include_state))
         self.assertEqual(cpp_style._PRIMARY_HEADER,
                          classify_include('fooCustom.cpp',
                                           'foo.h',
                                           False, include_state))
         self.assertEqual(cpp_style._PRIMARY_HEADER,
                          classify_include('PrefixFooCustom.cpp',
                                           'Foo.h',
                                           False, include_state))
-        self.assertEqual(cpp_style._MOC_HEADER,
-                         classify_include('foo.cpp',
-                                          'foo.moc',
-                                          False, include_state))
-        self.assertEqual(cpp_style._MOC_HEADER,
-                         classify_include('foo.cpp',
-                                          'moc_foo.cpp',
-                                          False, include_state))
         # <public/foo.h> must be considered as primary even if is_system is True.
         self.assertEqual(cpp_style._PRIMARY_HEADER,
                          classify_include('foo/foo.cpp',
                                           'public/foo.h',
                                           True, include_state))
         self.assertEqual(cpp_style._OTHER_HEADER,
                          classify_include('foo.cpp',
                                           'foo.h',
                                           True, include_state))
         self.assertEqual(cpp_style._OTHER_HEADER,
                          classify_include('foo.cpp',
                                           'public/foop.h',
                                           True, include_state))
-        # Qt private APIs use _p.h suffix.
-        self.assertEqual(cpp_style._PRIMARY_HEADER,
-                         classify_include('foo.cpp',
-                                          'foo_p.h',
-                                          False, include_state))
         # Tricky example where both includes might be classified as primary.
         self.assert_language_rules_check('ScrollbarThemeWince.cpp',
                                          '#include "ScrollbarThemeWince.h"\n'
                                          '\n'
                                          '#include "Scrollbar.h"\n',
                                          '')
         self.assert_language_rules_check('ScrollbarThemeWince.cpp',
                                          '#include "Scrollbar.h"\n'
                                          '\n'
                                          '#include "ScrollbarThemeWince.h"\n',
                                          'Found header this file implements after a header this file implements.'
                                          ' Should be: primary header, blank line, and then alphabetically sorted.'
                                          '  [build/include_order] [4]')
-        self.assert_language_rules_check('ResourceHandleWin.cpp',
-                                         '#include "ResourceHandle.h"\n'
-                                         '\n'
-                                         '#include "ResourceHandleWin.h"\n',
-                                         '')
 
     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'))
@@ skipping 1705 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)