maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/unittests/Format/SortIncludesTest.cpp

232 lines
7.3 KiB
C++
Raw Normal View History

clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
//===- unittest/Format/SortIncludesTest.cpp - Include sort unit tests -----===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "FormatTestUtils.h"
#include "clang/Format/Format.h"
#include "llvm/Support/Debug.h"
#include "gtest/gtest.h"
#define DEBUG_TYPE "format-test"
namespace clang {
namespace format {
namespace {
class SortIncludesTest : public ::testing::Test {
protected:
clang-format: Extend #include sorting functionality Recognize the main module header as well as different #include categories. This should now mimic the behavior of llvm/utils/sort_includes.py as well as clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp very closely. llvm-svn: 248782
2015-09-29 15:53:08 +08:00
std::string sort(llvm::StringRef Code, StringRef FileName = "input.cpp") {
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
clang-format: Extend #include sorting functionality Recognize the main module header as well as different #include categories. This should now mimic the behavior of llvm/utils/sort_includes.py as well as clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp very closely. llvm-svn: 248782
2015-09-29 15:53:08 +08:00
std::string Sorted =
applyAllReplacements(Code, sortIncludes(Style, Code, Ranges, FileName));
return applyAllReplacements(Sorted,
reformat(Style, Sorted, Ranges, FileName));
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
}
clang-format: Extend #include sorting functionality Recognize the main module header as well as different #include categories. This should now mimic the behavior of llvm/utils/sort_includes.py as well as clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp very closely. llvm-svn: 248782
2015-09-29 15:53:08 +08:00
clang-format: Make moving of the Cursor work properly when sorting #includes. llvm-svn: 253860
2015-11-23 16:36:35 +08:00
unsigned newCursor(llvm::StringRef Code, unsigned Cursor) {
std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
sortIncludes(Style, Code, Ranges, "input.cpp", &Cursor);
return Cursor;
}
clang-format: Extend #include sorting functionality Recognize the main module header as well as different #include categories. This should now mimic the behavior of llvm/utils/sort_includes.py as well as clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp very closely. llvm-svn: 248782
2015-09-29 15:53:08 +08:00
FormatStyle Style = getLLVMStyle();
clang-format: Make moving of the Cursor work properly when sorting #includes. llvm-svn: 253860
2015-11-23 16:36:35 +08:00
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
};
TEST_F(SortIncludesTest, BasicSorting) {
EXPECT_EQ("#include \"a.h\"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n",
sort("#include \"a.h\"\n"
"#include \"c.h\"\n"
"#include \"b.h\"\n"));
}
clang-format: Make sorting includes respect // clang-format off llvm-svn: 253772
2015-11-21 17:17:08 +08:00
TEST_F(SortIncludesTest, SupportClangFormatOff) {
EXPECT_EQ("#include <a>\n"
"#include <b>\n"
"#include <c>\n"
"// clang-format off\n"
"#include <b>\n"
"#include <a>\n"
"#include <c>\n"
"// clang-format on\n",
sort("#include <b>\n"
"#include <a>\n"
"#include <c>\n"
"// clang-format off\n"
"#include <b>\n"
"#include <a>\n"
"#include <c>\n"
"// clang-format on\n"));
}
clang-format: Enable #include sorting by default. This has seen quite some usage and I am not aware of any issues. Also add a style option to enable/disable include sorting. The existing command line flag can from now on be used to override whatever is set in the style. llvm-svn: 253202
2015-11-16 20:38:56 +08:00
TEST_F(SortIncludesTest, IncludeSortingCanBeDisabled) {
Style.SortIncludes = false;
EXPECT_EQ("#include \"a.h\"\n"
"#include \"c.h\"\n"
"#include \"b.h\"\n",
sort("#include \"a.h\"\n"
"#include \"c.h\"\n"
"#include \"b.h\"\n"));
}
clang-format: Teach --sort-includes to interleave #include and #import. clang accepts both #include and #import for includes (the latter having an implicit header guard). Let clang-format interleave both types if --sort-includes is passed. #import is used frequently in Objective-C code. http://reviews.llvm.org/D13853 llvm-svn: 250909
2015-10-22 01:13:45 +08:00
TEST_F(SortIncludesTest, MixIncludeAndImport) {
EXPECT_EQ("#include \"a.h\"\n"
"#import \"b.h\"\n"
"#include \"c.h\"\n",
sort("#include \"a.h\"\n"
"#include \"c.h\"\n"
"#import \"b.h\"\n"));
}
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
TEST_F(SortIncludesTest, FixTrailingComments) {
EXPECT_EQ("#include \"a.h\" // comment\n"
"#include \"bb.h\" // comment\n"
"#include \"ccc.h\"\n",
sort("#include \"a.h\" // comment\n"
"#include \"ccc.h\"\n"
"#include \"bb.h\" // comment\n"));
}
TEST_F(SortIncludesTest, LeadingWhitespace) {
EXPECT_EQ("#include \"a.h\"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n",
sort(" #include \"a.h\"\n"
" #include \"c.h\"\n"
" #include \"b.h\"\n"));
EXPECT_EQ("#include \"a.h\"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n",
sort("# include \"a.h\"\n"
"# include \"c.h\"\n"
"# include \"b.h\"\n"));
}
TEST_F(SortIncludesTest, GreaterInComment) {
EXPECT_EQ("#include \"a.h\"\n"
"#include \"b.h\" // >\n"
"#include \"c.h\"\n",
sort("#include \"a.h\"\n"
"#include \"c.h\"\n"
"#include \"b.h\" // >\n"));
}
TEST_F(SortIncludesTest, SortsLocallyInEachBlock) {
EXPECT_EQ("#include \"a.h\"\n"
"#include \"c.h\"\n"
"\n"
"#include \"b.h\"\n",
clang-format: Extend #include sorting functionality Recognize the main module header as well as different #include categories. This should now mimic the behavior of llvm/utils/sort_includes.py as well as clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp very closely. llvm-svn: 248782
2015-09-29 15:53:08 +08:00
sort("#include \"a.h\"\n"
"#include \"c.h\"\n"
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
"\n"
"#include \"b.h\"\n"));
}
TEST_F(SortIncludesTest, HandlesAngledIncludesAsSeparateBlocks) {
clang-format: Extend #include sorting functionality Recognize the main module header as well as different #include categories. This should now mimic the behavior of llvm/utils/sort_includes.py as well as clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp very closely. llvm-svn: 248782
2015-09-29 15:53:08 +08:00
EXPECT_EQ("#include \"a.h\"\n"
"#include \"c.h\"\n"
"#include <b.h>\n"
"#include <d.h>\n",
sort("#include <d.h>\n"
"#include <b.h>\n"
"#include \"c.h\"\n"
"#include \"a.h\"\n"));
Style = getGoogleStyle(FormatStyle::LK_Cpp);
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
EXPECT_EQ("#include <b.h>\n"
"#include <d.h>\n"
"#include \"a.h\"\n"
"#include \"c.h\"\n",
sort("#include <d.h>\n"
"#include <b.h>\n"
"#include \"c.h\"\n"
"#include \"a.h\"\n"));
}
TEST_F(SortIncludesTest, HandlesMultilineIncludes) {
EXPECT_EQ("#include \"a.h\"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n",
sort("#include \"a.h\"\n"
"#include \\\n"
"\"c.h\"\n"
"#include \"b.h\"\n"));
}
clang-format: Extend #include sorting functionality Recognize the main module header as well as different #include categories. This should now mimic the behavior of llvm/utils/sort_includes.py as well as clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp very closely. llvm-svn: 248782
2015-09-29 15:53:08 +08:00
TEST_F(SortIncludesTest, LeavesMainHeaderFirst) {
EXPECT_EQ("#include \"llvm/a.h\"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n",
sort("#include \"llvm/a.h\"\n"
"#include \"c.h\"\n"
clang-format: Extend detection of the "main" #include to use the filename Before, the first (non-system) header in a file was considered to be the main include. This is conservative as it makes clang-format change the #include order less often. Instead implement some basic usage of the filename itself. With this patch, clang-format considers every header to be a main include if the header file's basename is a prefix to the filename the #include is in. llvm-svn: 256148
2015-12-21 20:14:17 +08:00
"#include \"b.h\"\n",
"a.cc"));
clang-format: Extend main header include sorting heuristic to Objective-C files. llvm-svn: 250675
2015-10-19 09:36:09 +08:00
EXPECT_EQ("#include \"llvm/a.h\"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n",
sort("#include \"llvm/a.h\"\n"
clang-format: Extend detection of the "main" #include to use the filename Before, the first (non-system) header in a file was considered to be the main include. This is conservative as it makes clang-format change the #include order less often. Instead implement some basic usage of the filename itself. With this patch, clang-format considers every header to be a main include if the header file's basename is a prefix to the filename the #include is in. llvm-svn: 256148
2015-12-21 20:14:17 +08:00
"#include \"c.h\"\n"
"#include \"b.h\"\n",
"a_main.cc"));
EXPECT_EQ("#include \"llvm/input.h\"\n"
"#include \"b.h\"\n"
"#include \"c.h\"\n",
sort("#include \"llvm/input.h\"\n"
clang-format: Extend main header include sorting heuristic to Objective-C files. llvm-svn: 250675
2015-10-19 09:36:09 +08:00
"#include \"c.h\"\n"
"#include \"b.h\"\n",
"input.mm"));
clang-format: Extend #include sorting functionality Recognize the main module header as well as different #include categories. This should now mimic the behavior of llvm/utils/sort_includes.py as well as clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp very closely. llvm-svn: 248782
2015-09-29 15:53:08 +08:00
// Don't do this in headers.
EXPECT_EQ("#include \"b.h\"\n"
"#include \"c.h\"\n"
"#include \"llvm/a.h\"\n",
sort("#include \"llvm/a.h\"\n"
"#include \"c.h\"\n"
"#include \"b.h\"\n",
clang-format: Extend detection of the "main" #include to use the filename Before, the first (non-system) header in a file was considered to be the main include. This is conservative as it makes clang-format change the #include order less often. Instead implement some basic usage of the filename itself. With this patch, clang-format considers every header to be a main include if the header file's basename is a prefix to the filename the #include is in. llvm-svn: 256148
2015-12-21 20:14:17 +08:00
"a.h"));
clang-format: Extend #include sorting functionality Recognize the main module header as well as different #include categories. This should now mimic the behavior of llvm/utils/sort_includes.py as well as clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp very closely. llvm-svn: 248782
2015-09-29 15:53:08 +08:00
}
clang-format: Extend header sort category implementation. Specifically, it is sometimes necessary to keep certain #includes as the first #include, even before the main #include for a .cc file. Switching the category to be signed instead of unsigned isn't ideal, but it seems as good of an option as any and is fully backwards compatible. llvm-svn: 255757
2015-12-16 18:10:16 +08:00
TEST_F(SortIncludesTest, NegativePriorities) {
Style.IncludeCategories = {{".*important_os_header.*", -1}, {".*", 1}};
EXPECT_EQ("#include \"important_os_header.h\"\n"
clang-format: Extend detection of the "main" #include to use the filename Before, the first (non-system) header in a file was considered to be the main include. This is conservative as it makes clang-format change the #include order less often. Instead implement some basic usage of the filename itself. With this patch, clang-format considers every header to be a main include if the header file's basename is a prefix to the filename the #include is in. llvm-svn: 256148
2015-12-21 20:14:17 +08:00
"#include \"c_main.h\"\n"
"#include \"a_other.h\"\n",
sort("#include \"c_main.h\"\n"
"#include \"a_other.h\"\n"
"#include \"important_os_header.h\"\n",
"c_main.cc"));
// check stable when re-run
EXPECT_EQ("#include \"important_os_header.h\"\n"
"#include \"c_main.h\"\n"
"#include \"a_other.h\"\n",
sort("#include \"important_os_header.h\"\n"
"#include \"c_main.h\"\n"
"#include \"a_other.h\"\n",
"c_main.cc"));
clang-format: Extend header sort category implementation. Specifically, it is sometimes necessary to keep certain #includes as the first #include, even before the main #include for a .cc file. Switching the category to be signed instead of unsigned isn't ideal, but it seems as good of an option as any and is fully backwards compatible. llvm-svn: 255757
2015-12-16 18:10:16 +08:00
}
clang-format: Make moving of the Cursor work properly when sorting #includes. llvm-svn: 253860
2015-11-23 16:36:35 +08:00
TEST_F(SortIncludesTest, CalculatesCorrectCursorPosition) {
std::string Code = "#include <ccc>\n" // Start of line: 0
"#include <bbbbbb>\n" // Start of line: 15
"#include <a>\n"; // Start of line: 33
EXPECT_EQ(31u, newCursor(Code, 0));
EXPECT_EQ(13u, newCursor(Code, 15));
EXPECT_EQ(0u, newCursor(Code, 33));
EXPECT_EQ(41u, newCursor(Code, 10));
EXPECT_EQ(23u, newCursor(Code, 25));
EXPECT_EQ(10u, newCursor(Code, 43));
}
clang-format: Add initial #include sorting capabilities. To implement this nicely, add a function that merges two sets of replacements that are meant to be done in sequence. This functionality will also be useful for other applications, e.g. formatting the result of clang-tidy fixes. llvm-svn: 248367
2015-09-23 16:30:47 +08:00
} // end namespace
} // end namespace format
} // end namespace clang