[clang] 617277e - [clang-format][NFC] Moved configuration parsing tests in own file
Björn Schäpers via cfe-commits
cfe-commits at lists.llvm.org
Tue Nov 15 22:02:38 PST 2022
Author: Björn Schäpers
Date: 2022-11-16T07:02:09+01:00
New Revision: 617277e7cbdaea6881425c7a1a5b1cf4b1d4b507
URL: https://github.com/llvm/llvm-project/commit/617277e7cbdaea6881425c7a1a5b1cf4b1d4b507
DIFF: https://github.com/llvm/llvm-project/commit/617277e7cbdaea6881425c7a1a5b1cf4b1d4b507.diff
LOG: [clang-format][NFC] Moved configuration parsing tests in own file
I want to reduce the size of ForatTest.cpp with its still wopping 25k
lines it is a burden on the compiler and editor (mine is clangd
powered).
This are tests which are really serving a different purpose than
formatting.
I've copied the code and made the following changes:
- Dropped the ; at the end of some macros, all macro "invocations"
already have their own ;.
- Dropped the _F, we don't need a fxiture here.
Differential Revisison: https://reviews.llvm.org/D137823
Added:
clang/unittests/Format/ConfigParseTest.cpp
Modified:
clang/unittests/Format/CMakeLists.txt
clang/unittests/Format/FormatTest.cpp
Removed:
################################################################################
diff --git a/clang/unittests/Format/CMakeLists.txt b/clang/unittests/Format/CMakeLists.txt
index 8514d1b0f817d..26ecd355d531d 100644
--- a/clang/unittests/Format/CMakeLists.txt
+++ b/clang/unittests/Format/CMakeLists.txt
@@ -6,6 +6,7 @@ add_clang_unittest(FormatTests
BracesInserterTest.cpp
BracesRemoverTest.cpp
CleanupTest.cpp
+ ConfigParseTest.cpp
DefinitionBlockSeparatorTest.cpp
FormatTest.cpp
FormatTestComments.cpp
diff --git a/clang/unittests/Format/ConfigParseTest.cpp b/clang/unittests/Format/ConfigParseTest.cpp
new file mode 100644
index 0000000000000..a65fffc7b57f2
--- /dev/null
+++ b/clang/unittests/Format/ConfigParseTest.cpp
@@ -0,0 +1,1278 @@
+//===- unittest/Format/ConfigParseTest.cpp - Config parsing unit tests ----===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Format/Format.h"
+
+#include "llvm/Support/VirtualFileSystem.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace format {
+namespace {
+
+FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); }
+
+#define EXPECT_ALL_STYLES_EQUAL(Styles) \
+ for (size_t i = 1; i < Styles.size(); ++i) \
+ EXPECT_EQ(Styles[0], Styles[i]) \
+ << "Style #" << i << " of " << Styles.size() << "
diff ers from Style #0"
+
+TEST(ConfigParseTest, GetsPredefinedStyleByName) {
+ SmallVector<FormatStyle, 3> Styles;
+ Styles.resize(3);
+
+ Styles[0] = getLLVMStyle();
+ EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
+ EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
+ EXPECT_ALL_STYLES_EQUAL(Styles);
+
+ Styles[0] = getGoogleStyle();
+ EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
+ EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
+ EXPECT_ALL_STYLES_EQUAL(Styles);
+
+ Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
+ EXPECT_TRUE(
+ getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
+ EXPECT_TRUE(
+ getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
+ EXPECT_ALL_STYLES_EQUAL(Styles);
+
+ Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
+ EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
+ EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
+ EXPECT_ALL_STYLES_EQUAL(Styles);
+
+ Styles[0] = getMozillaStyle();
+ EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
+ EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
+ EXPECT_ALL_STYLES_EQUAL(Styles);
+
+ Styles[0] = getWebKitStyle();
+ EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
+ EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
+ EXPECT_ALL_STYLES_EQUAL(Styles);
+
+ Styles[0] = getGNUStyle();
+ EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
+ EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
+ EXPECT_ALL_STYLES_EQUAL(Styles);
+
+ EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
+}
+
+TEST(ConfigParseTest, GetsCorrectBasedOnStyle) {
+ SmallVector<FormatStyle, 8> Styles;
+ Styles.resize(2);
+
+ Styles[0] = getGoogleStyle();
+ Styles[1] = getLLVMStyle();
+ EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
+ EXPECT_ALL_STYLES_EQUAL(Styles);
+
+ Styles.resize(5);
+ Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
+ Styles[1] = getLLVMStyle();
+ Styles[1].Language = FormatStyle::LK_JavaScript;
+ EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
+
+ Styles[2] = getLLVMStyle();
+ Styles[2].Language = FormatStyle::LK_JavaScript;
+ EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
+ "BasedOnStyle: Google",
+ &Styles[2])
+ .value());
+
+ Styles[3] = getLLVMStyle();
+ Styles[3].Language = FormatStyle::LK_JavaScript;
+ EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
+ "Language: JavaScript",
+ &Styles[3])
+ .value());
+
+ Styles[4] = getLLVMStyle();
+ Styles[4].Language = FormatStyle::LK_JavaScript;
+ EXPECT_EQ(0, parseConfiguration("---\n"
+ "BasedOnStyle: LLVM\n"
+ "IndentWidth: 123\n"
+ "---\n"
+ "BasedOnStyle: Google\n"
+ "Language: JavaScript",
+ &Styles[4])
+ .value());
+ EXPECT_ALL_STYLES_EQUAL(Styles);
+}
+
+#define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \
+ Style.FIELD = false; \
+ EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \
+ EXPECT_TRUE(Style.FIELD); \
+ EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \
+ EXPECT_FALSE(Style.FIELD)
+
+#define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
+
+#define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \
+ Style.STRUCT.FIELD = false; \
+ EXPECT_EQ(0, \
+ parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \
+ .value()); \
+ EXPECT_TRUE(Style.STRUCT.FIELD); \
+ EXPECT_EQ(0, \
+ parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \
+ .value()); \
+ EXPECT_FALSE(Style.STRUCT.FIELD)
+
+#define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \
+ CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
+
+#define CHECK_PARSE(TEXT, FIELD, VALUE) \
+ EXPECT_NE(VALUE, Style.FIELD) << "Initial value already the same!"; \
+ EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \
+ EXPECT_EQ(VALUE, Style.FIELD) << "Unexpected value after parsing!"
+
+#define CHECK_PARSE_NESTED_VALUE(TEXT, STRUCT, FIELD, VALUE) \
+ EXPECT_NE(VALUE, Style.STRUCT.FIELD) << "Initial value already the same!"; \
+ EXPECT_EQ(0, parseConfiguration(#STRUCT ":\n " TEXT, &Style).value()); \
+ EXPECT_EQ(VALUE, Style.STRUCT.FIELD) << "Unexpected value after parsing!"
+
+TEST(ConfigParseTest, ParsesConfigurationBools) {
+ FormatStyle Style = {};
+ Style.Language = FormatStyle::LK_Cpp;
+ CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
+ CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
+ CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
+ CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
+ CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
+ CHECK_PARSE_BOOL(BinPackArguments);
+ CHECK_PARSE_BOOL(BinPackParameters);
+ CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
+ CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
+ CHECK_PARSE_BOOL(BreakStringLiterals);
+ CHECK_PARSE_BOOL(CompactNamespaces);
+ CHECK_PARSE_BOOL(DeriveLineEnding);
+ CHECK_PARSE_BOOL(DerivePointerAlignment);
+ CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
+ CHECK_PARSE_BOOL(DisableFormat);
+ CHECK_PARSE_BOOL(IndentAccessModifiers);
+ CHECK_PARSE_BOOL(IndentCaseLabels);
+ CHECK_PARSE_BOOL(IndentCaseBlocks);
+ CHECK_PARSE_BOOL(IndentGotoLabels);
+ CHECK_PARSE_BOOL_FIELD(IndentRequiresClause, "IndentRequires");
+ CHECK_PARSE_BOOL(IndentRequiresClause);
+ CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
+ CHECK_PARSE_BOOL(InsertBraces);
+ CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
+ CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
+ CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
+ CHECK_PARSE_BOOL(Cpp11BracedListStyle);
+ CHECK_PARSE_BOOL(ReflowComments);
+ CHECK_PARSE_BOOL(RemoveBracesLLVM);
+ CHECK_PARSE_BOOL(RemoveSemicolon);
+ CHECK_PARSE_BOOL(SortUsingDeclarations);
+ CHECK_PARSE_BOOL(SpacesInParentheses);
+ CHECK_PARSE_BOOL(SpacesInSquareBrackets);
+ CHECK_PARSE_BOOL(SpacesInConditionalStatement);
+ CHECK_PARSE_BOOL(SpaceInEmptyBlock);
+ CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
+ CHECK_PARSE_BOOL(SpacesInContainerLiterals);
+ CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
+ CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
+ CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
+ CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
+ CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
+ CHECK_PARSE_BOOL(SpaceBeforeCaseColon);
+ CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
+ CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
+ CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
+ CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon);
+ CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets);
+ CHECK_PARSE_BOOL(UseCRLF);
+
+ CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel);
+ CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
+ CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
+ CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
+ CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
+ CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
+ CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
+ CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
+ CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
+ CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
+ CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
+ CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody);
+ CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeWhile);
+ CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
+ CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
+ CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
+ CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
+ CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterControlStatements);
+ CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterForeachMacros);
+ CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions,
+ AfterFunctionDeclarationName);
+ CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions,
+ AfterFunctionDefinitionName);
+ CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterIfMacros);
+ CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterOverloadedOperator);
+ CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, BeforeNonEmptyParentheses);
+}
+
+#undef CHECK_PARSE_BOOL
+
+TEST(ConfigParseTest, ParsesConfiguration) {
+ FormatStyle Style = {};
+ Style.Language = FormatStyle::LK_Cpp;
+ CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
+ CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
+ ConstructorInitializerIndentWidth, 1234u);
+ CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
+ CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
+ CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
+ CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u);
+ CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
+ PenaltyBreakBeforeFirstCallParameter, 1234u);
+ CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234",
+ PenaltyBreakTemplateDeclaration, 1234u);
+ CHECK_PARSE("PenaltyBreakOpenParenthesis: 1234", PenaltyBreakOpenParenthesis,
+ 1234u);
+ CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
+ CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
+ PenaltyReturnTypeOnItsOwnLine, 1234u);
+ CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
+ SpacesBeforeTrailingComments, 1234u);
+ CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
+ CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
+ CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
+
+ Style.QualifierAlignment = FormatStyle::QAS_Right;
+ CHECK_PARSE("QualifierAlignment: Leave", QualifierAlignment,
+ FormatStyle::QAS_Leave);
+ CHECK_PARSE("QualifierAlignment: Right", QualifierAlignment,
+ FormatStyle::QAS_Right);
+ CHECK_PARSE("QualifierAlignment: Left", QualifierAlignment,
+ FormatStyle::QAS_Left);
+ CHECK_PARSE("QualifierAlignment: Custom", QualifierAlignment,
+ FormatStyle::QAS_Custom);
+
+ Style.QualifierOrder.clear();
+ CHECK_PARSE("QualifierOrder: [ const, volatile, type ]", QualifierOrder,
+ std::vector<std::string>({"const", "volatile", "type"}));
+ Style.QualifierOrder.clear();
+ CHECK_PARSE("QualifierOrder: [const, type]", QualifierOrder,
+ std::vector<std::string>({"const", "type"}));
+ Style.QualifierOrder.clear();
+ CHECK_PARSE("QualifierOrder: [volatile, type]", QualifierOrder,
+ std::vector<std::string>({"volatile", "type"}));
+
+#define CHECK_ALIGN_CONSECUTIVE(FIELD) \
+ do { \
+ Style.FIELD.Enabled = true; \
+ CHECK_PARSE(#FIELD ": None", FIELD, \
+ FormatStyle::AlignConsecutiveStyle( \
+ {/*Enabled=*/false, /*AcrossEmptyLines=*/false, \
+ /*AcrossComments=*/false, /*AlignCompound=*/false, \
+ /*PadOperators=*/true})); \
+ CHECK_PARSE(#FIELD ": Consecutive", FIELD, \
+ FormatStyle::AlignConsecutiveStyle( \
+ {/*Enabled=*/true, /*AcrossEmptyLines=*/false, \
+ /*AcrossComments=*/false, /*AlignCompound=*/false, \
+ /*PadOperators=*/true})); \
+ CHECK_PARSE(#FIELD ": AcrossEmptyLines", FIELD, \
+ FormatStyle::AlignConsecutiveStyle( \
+ {/*Enabled=*/true, /*AcrossEmptyLines=*/true, \
+ /*AcrossComments=*/false, /*AlignCompound=*/false, \
+ /*PadOperators=*/true})); \
+ CHECK_PARSE(#FIELD ": AcrossEmptyLinesAndComments", FIELD, \
+ FormatStyle::AlignConsecutiveStyle( \
+ {/*Enabled=*/true, /*AcrossEmptyLines=*/true, \
+ /*AcrossComments=*/true, /*AlignCompound=*/false, \
+ /*PadOperators=*/true})); \
+ /* For backwards compability, false / true should still parse */ \
+ CHECK_PARSE(#FIELD ": false", FIELD, \
+ FormatStyle::AlignConsecutiveStyle( \
+ {/*Enabled=*/false, /*AcrossEmptyLines=*/false, \
+ /*AcrossComments=*/false, /*AlignCompound=*/false, \
+ /*PadOperators=*/true})); \
+ CHECK_PARSE(#FIELD ": true", FIELD, \
+ FormatStyle::AlignConsecutiveStyle( \
+ {/*Enabled=*/true, /*AcrossEmptyLines=*/false, \
+ /*AcrossComments=*/false, /*AlignCompound=*/false, \
+ /*PadOperators=*/true})); \
+ \
+ CHECK_PARSE_NESTED_BOOL(FIELD, Enabled); \
+ CHECK_PARSE_NESTED_BOOL(FIELD, AcrossEmptyLines); \
+ CHECK_PARSE_NESTED_BOOL(FIELD, AcrossComments); \
+ CHECK_PARSE_NESTED_BOOL(FIELD, AlignCompound); \
+ CHECK_PARSE_NESTED_BOOL(FIELD, PadOperators); \
+ } while (false)
+
+ CHECK_ALIGN_CONSECUTIVE(AlignConsecutiveAssignments);
+ CHECK_ALIGN_CONSECUTIVE(AlignConsecutiveBitFields);
+ CHECK_ALIGN_CONSECUTIVE(AlignConsecutiveMacros);
+ CHECK_ALIGN_CONSECUTIVE(AlignConsecutiveDeclarations);
+
+#undef CHECK_ALIGN_CONSECUTIVE
+
+ Style.PointerAlignment = FormatStyle::PAS_Middle;
+ CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
+ FormatStyle::PAS_Left);
+ CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
+ FormatStyle::PAS_Right);
+ CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
+ FormatStyle::PAS_Middle);
+ Style.ReferenceAlignment = FormatStyle::RAS_Middle;
+ CHECK_PARSE("ReferenceAlignment: Pointer", ReferenceAlignment,
+ FormatStyle::RAS_Pointer);
+ CHECK_PARSE("ReferenceAlignment: Left", ReferenceAlignment,
+ FormatStyle::RAS_Left);
+ CHECK_PARSE("ReferenceAlignment: Right", ReferenceAlignment,
+ FormatStyle::RAS_Right);
+ CHECK_PARSE("ReferenceAlignment: Middle", ReferenceAlignment,
+ FormatStyle::RAS_Middle);
+ // For backward compatibility:
+ CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
+ FormatStyle::PAS_Left);
+ CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
+ FormatStyle::PAS_Right);
+ CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
+ FormatStyle::PAS_Middle);
+
+ Style.Standard = FormatStyle::LS_Auto;
+ CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03);
+ CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11);
+ CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14);
+ CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17);
+ CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20);
+ CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
+ CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest);
+ // Legacy aliases:
+ CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
+ CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest);
+ CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
+ CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
+
+ Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
+ CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
+ BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
+ CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
+ FormatStyle::BOS_None);
+ CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
+ FormatStyle::BOS_All);
+ // For backward compatibility:
+ CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
+ FormatStyle::BOS_None);
+ CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
+ FormatStyle::BOS_All);
+
+ Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
+ CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
+ BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
+ CHECK_PARSE("BreakConstructorInitializers: AfterColon",
+ BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
+ CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
+ BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
+ // For backward compatibility:
+ CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
+ BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
+
+ Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
+ CHECK_PARSE("BreakInheritanceList: AfterComma", BreakInheritanceList,
+ FormatStyle::BILS_AfterComma);
+ CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList,
+ FormatStyle::BILS_BeforeComma);
+ CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList,
+ FormatStyle::BILS_AfterColon);
+ CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList,
+ FormatStyle::BILS_BeforeColon);
+ // For backward compatibility:
+ CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
+ FormatStyle::BILS_BeforeComma);
+
+ Style.PackConstructorInitializers = FormatStyle::PCIS_BinPack;
+ CHECK_PARSE("PackConstructorInitializers: Never", PackConstructorInitializers,
+ FormatStyle::PCIS_Never);
+ CHECK_PARSE("PackConstructorInitializers: BinPack",
+ PackConstructorInitializers, FormatStyle::PCIS_BinPack);
+ CHECK_PARSE("PackConstructorInitializers: CurrentLine",
+ PackConstructorInitializers, FormatStyle::PCIS_CurrentLine);
+ CHECK_PARSE("PackConstructorInitializers: NextLine",
+ PackConstructorInitializers, FormatStyle::PCIS_NextLine);
+ // For backward compatibility:
+ CHECK_PARSE("BasedOnStyle: Google\n"
+ "ConstructorInitializerAllOnOneLineOrOnePerLine: true\n"
+ "AllowAllConstructorInitializersOnNextLine: false",
+ PackConstructorInitializers, FormatStyle::PCIS_CurrentLine);
+ Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine;
+ CHECK_PARSE("BasedOnStyle: Google\n"
+ "ConstructorInitializerAllOnOneLineOrOnePerLine: false",
+ PackConstructorInitializers, FormatStyle::PCIS_BinPack);
+ CHECK_PARSE("ConstructorInitializerAllOnOneLineOrOnePerLine: true\n"
+ "AllowAllConstructorInitializersOnNextLine: true",
+ PackConstructorInitializers, FormatStyle::PCIS_NextLine);
+ Style.PackConstructorInitializers = FormatStyle::PCIS_BinPack;
+ CHECK_PARSE("ConstructorInitializerAllOnOneLineOrOnePerLine: true\n"
+ "AllowAllConstructorInitializersOnNextLine: false",
+ PackConstructorInitializers, FormatStyle::PCIS_CurrentLine);
+
+ Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_LogicalBlock;
+ CHECK_PARSE("EmptyLineBeforeAccessModifier: Never",
+ EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_Never);
+ CHECK_PARSE("EmptyLineBeforeAccessModifier: Leave",
+ EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_Leave);
+ CHECK_PARSE("EmptyLineBeforeAccessModifier: LogicalBlock",
+ EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_LogicalBlock);
+ CHECK_PARSE("EmptyLineBeforeAccessModifier: Always",
+ EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_Always);
+
+ Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
+ CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
+ FormatStyle::BAS_Align);
+ CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
+ FormatStyle::BAS_DontAlign);
+ CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
+ FormatStyle::BAS_AlwaysBreak);
+ CHECK_PARSE("AlignAfterOpenBracket: BlockIndent", AlignAfterOpenBracket,
+ FormatStyle::BAS_BlockIndent);
+ // For backward compatibility:
+ CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
+ FormatStyle::BAS_DontAlign);
+ CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
+ FormatStyle::BAS_Align);
+
+ Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
+ CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
+ FormatStyle::ENAS_DontAlign);
+ CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
+ FormatStyle::ENAS_Left);
+ CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
+ FormatStyle::ENAS_Right);
+ // For backward compatibility:
+ CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
+ FormatStyle::ENAS_Left);
+ CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
+ FormatStyle::ENAS_Right);
+
+ Style.AlignOperands = FormatStyle::OAS_Align;
+ CHECK_PARSE("AlignOperands: DontAlign", AlignOperands,
+ FormatStyle::OAS_DontAlign);
+ CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align);
+ CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands,
+ FormatStyle::OAS_AlignAfterOperator);
+ // For backward compatibility:
+ CHECK_PARSE("AlignOperands: false", AlignOperands,
+ FormatStyle::OAS_DontAlign);
+ CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align);
+
+ CHECK_PARSE("AlignTrailingComments: Leave", AlignTrailingComments,
+ FormatStyle::TrailingCommentsAlignmentStyle(
+ {FormatStyle::TCAS_Leave, 1}));
+ CHECK_PARSE("AlignTrailingComments: Always", AlignTrailingComments,
+ FormatStyle::TrailingCommentsAlignmentStyle(
+ {FormatStyle::TCAS_Always, 1}));
+ CHECK_PARSE("AlignTrailingComments: Never", AlignTrailingComments,
+ FormatStyle::TrailingCommentsAlignmentStyle(
+ {FormatStyle::TCAS_Never, 1}));
+ // For backwards compatibility
+ CHECK_PARSE("AlignTrailingComments: true", AlignTrailingComments,
+ FormatStyle::TrailingCommentsAlignmentStyle(
+ {FormatStyle::TCAS_Always, 1}));
+ CHECK_PARSE("AlignTrailingComments: false", AlignTrailingComments,
+ FormatStyle::TrailingCommentsAlignmentStyle(
+ {FormatStyle::TCAS_Never, 1}));
+ CHECK_PARSE_NESTED_VALUE("Kind: Always", AlignTrailingComments, Kind,
+ FormatStyle::TCAS_Always);
+ CHECK_PARSE_NESTED_VALUE("Kind: Never", AlignTrailingComments, Kind,
+ FormatStyle::TCAS_Never);
+ CHECK_PARSE_NESTED_VALUE("Kind: Leave", AlignTrailingComments, Kind,
+ FormatStyle::TCAS_Leave);
+ CHECK_PARSE_NESTED_VALUE("OverEmptyLines: 1234", AlignTrailingComments,
+ OverEmptyLines, 1234u);
+
+ Style.UseTab = FormatStyle::UT_ForIndentation;
+ CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
+ CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
+ CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
+ CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
+ FormatStyle::UT_ForContinuationAndIndentation);
+ CHECK_PARSE("UseTab: AlignWithSpaces", UseTab,
+ FormatStyle::UT_AlignWithSpaces);
+ // For backward compatibility:
+ CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
+ CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
+
+ Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
+ CHECK_PARSE("AllowShortBlocksOnASingleLine: Never",
+ AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
+ CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty",
+ AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty);
+ CHECK_PARSE("AllowShortBlocksOnASingleLine: Always",
+ AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
+ // For backward compatibility:
+ CHECK_PARSE("AllowShortBlocksOnASingleLine: false",
+ AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
+ CHECK_PARSE("AllowShortBlocksOnASingleLine: true",
+ AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
+
+ Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
+ CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
+ AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
+ CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
+ AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
+ CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
+ AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
+ CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
+ AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
+ // For backward compatibility:
+ CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
+ AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
+ CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
+ AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
+
+ Style.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Both;
+ CHECK_PARSE("SpaceAroundPointerQualifiers: Default",
+ SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Default);
+ CHECK_PARSE("SpaceAroundPointerQualifiers: Before",
+ SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Before);
+ CHECK_PARSE("SpaceAroundPointerQualifiers: After",
+ SpaceAroundPointerQualifiers, FormatStyle::SAPQ_After);
+ CHECK_PARSE("SpaceAroundPointerQualifiers: Both",
+ SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Both);
+
+ Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
+ CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
+ FormatStyle::SBPO_Never);
+ CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
+ FormatStyle::SBPO_Always);
+ CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
+ FormatStyle::SBPO_ControlStatements);
+ CHECK_PARSE("SpaceBeforeParens: ControlStatementsExceptControlMacros",
+ SpaceBeforeParens,
+ FormatStyle::SBPO_ControlStatementsExceptControlMacros);
+ CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens,
+ FormatStyle::SBPO_NonEmptyParentheses);
+ CHECK_PARSE("SpaceBeforeParens: Custom", SpaceBeforeParens,
+ FormatStyle::SBPO_Custom);
+ // For backward compatibility:
+ CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
+ FormatStyle::SBPO_Never);
+ CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
+ FormatStyle::SBPO_ControlStatements);
+ CHECK_PARSE("SpaceBeforeParens: ControlStatementsExceptForEachMacros",
+ SpaceBeforeParens,
+ FormatStyle::SBPO_ControlStatementsExceptControlMacros);
+
+ Style.ColumnLimit = 123;
+ FormatStyle BaseStyle = getLLVMStyle();
+ CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
+ CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
+
+ Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
+ CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
+ FormatStyle::BS_Attach);
+ CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
+ FormatStyle::BS_Linux);
+ CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
+ FormatStyle::BS_Mozilla);
+ CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
+ FormatStyle::BS_Stroustrup);
+ CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
+ FormatStyle::BS_Allman);
+ CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces,
+ FormatStyle::BS_Whitesmiths);
+ CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
+ CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
+ FormatStyle::BS_WebKit);
+ CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
+ FormatStyle::BS_Custom);
+
+ Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
+ CHECK_PARSE("BraceWrapping:\n"
+ " AfterControlStatement: MultiLine",
+ BraceWrapping.AfterControlStatement,
+ FormatStyle::BWACS_MultiLine);
+ CHECK_PARSE("BraceWrapping:\n"
+ " AfterControlStatement: Always",
+ BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
+ CHECK_PARSE("BraceWrapping:\n"
+ " AfterControlStatement: Never",
+ BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
+ // For backward compatibility:
+ CHECK_PARSE("BraceWrapping:\n"
+ " AfterControlStatement: true",
+ BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
+ CHECK_PARSE("BraceWrapping:\n"
+ " AfterControlStatement: false",
+ BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
+
+ Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
+ CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
+ FormatStyle::RTBS_None);
+ CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
+ FormatStyle::RTBS_All);
+ CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
+ AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
+ CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
+ AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
+ CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
+ AlwaysBreakAfterReturnType,
+ FormatStyle::RTBS_TopLevelDefinitions);
+
+ Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
+ CHECK_PARSE("AlwaysBreakTemplateDeclarations: No",
+ AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No);
+ CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine",
+ AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
+ CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes",
+ AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
+ CHECK_PARSE("AlwaysBreakTemplateDeclarations: false",
+ AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
+ CHECK_PARSE("AlwaysBreakTemplateDeclarations: true",
+ AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
+
+ Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
+ CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
+ AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
+ CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
+ AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
+ CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
+ AlwaysBreakAfterDefinitionReturnType,
+ FormatStyle::DRTBS_TopLevel);
+
+ Style.NamespaceIndentation = FormatStyle::NI_All;
+ CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
+ FormatStyle::NI_None);
+ CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
+ FormatStyle::NI_Inner);
+ CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
+ FormatStyle::NI_All);
+
+ Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_OnlyFirstIf;
+ CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never",
+ AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
+ CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse",
+ AllowShortIfStatementsOnASingleLine,
+ FormatStyle::SIS_WithoutElse);
+ CHECK_PARSE("AllowShortIfStatementsOnASingleLine: OnlyFirstIf",
+ AllowShortIfStatementsOnASingleLine,
+ FormatStyle::SIS_OnlyFirstIf);
+ CHECK_PARSE("AllowShortIfStatementsOnASingleLine: AllIfsAndElse",
+ AllowShortIfStatementsOnASingleLine,
+ FormatStyle::SIS_AllIfsAndElse);
+ CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always",
+ AllowShortIfStatementsOnASingleLine,
+ FormatStyle::SIS_OnlyFirstIf);
+ CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false",
+ AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
+ CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true",
+ AllowShortIfStatementsOnASingleLine,
+ FormatStyle::SIS_WithoutElse);
+
+ Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
+ CHECK_PARSE("IndentExternBlock: AfterExternBlock", IndentExternBlock,
+ FormatStyle::IEBS_AfterExternBlock);
+ CHECK_PARSE("IndentExternBlock: Indent", IndentExternBlock,
+ FormatStyle::IEBS_Indent);
+ CHECK_PARSE("IndentExternBlock: NoIndent", IndentExternBlock,
+ FormatStyle::IEBS_NoIndent);
+ CHECK_PARSE("IndentExternBlock: true", IndentExternBlock,
+ FormatStyle::IEBS_Indent);
+ CHECK_PARSE("IndentExternBlock: false", IndentExternBlock,
+ FormatStyle::IEBS_NoIndent);
+
+ Style.BitFieldColonSpacing = FormatStyle::BFCS_None;
+ CHECK_PARSE("BitFieldColonSpacing: Both", BitFieldColonSpacing,
+ FormatStyle::BFCS_Both);
+ CHECK_PARSE("BitFieldColonSpacing: None", BitFieldColonSpacing,
+ FormatStyle::BFCS_None);
+ CHECK_PARSE("BitFieldColonSpacing: Before", BitFieldColonSpacing,
+ FormatStyle::BFCS_Before);
+ CHECK_PARSE("BitFieldColonSpacing: After", BitFieldColonSpacing,
+ FormatStyle::BFCS_After);
+
+ Style.SortJavaStaticImport = FormatStyle::SJSIO_Before;
+ CHECK_PARSE("SortJavaStaticImport: After", SortJavaStaticImport,
+ FormatStyle::SJSIO_After);
+ CHECK_PARSE("SortJavaStaticImport: Before", SortJavaStaticImport,
+ FormatStyle::SJSIO_Before);
+
+ // FIXME: This is required because parsing a configuration simply overwrites
+ // the first N elements of the list instead of resetting it.
+ Style.ForEachMacros.clear();
+ std::vector<std::string> BoostForeach;
+ BoostForeach.push_back("BOOST_FOREACH");
+ CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
+ std::vector<std::string> BoostAndQForeach;
+ BoostAndQForeach.push_back("BOOST_FOREACH");
+ BoostAndQForeach.push_back("Q_FOREACH");
+ CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
+ BoostAndQForeach);
+
+ Style.IfMacros.clear();
+ std::vector<std::string> CustomIfs;
+ CustomIfs.push_back("MYIF");
+ CHECK_PARSE("IfMacros: [MYIF]", IfMacros, CustomIfs);
+
+ Style.AttributeMacros.clear();
+ CHECK_PARSE("BasedOnStyle: LLVM", AttributeMacros,
+ std::vector<std::string>{"__capability"});
+ CHECK_PARSE("AttributeMacros: [attr1, attr2]", AttributeMacros,
+ std::vector<std::string>({"attr1", "attr2"}));
+
+ Style.StatementAttributeLikeMacros.clear();
+ CHECK_PARSE("StatementAttributeLikeMacros: [emit,Q_EMIT]",
+ StatementAttributeLikeMacros,
+ std::vector<std::string>({"emit", "Q_EMIT"}));
+
+ Style.StatementMacros.clear();
+ CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
+ std::vector<std::string>{"QUNUSED"});
+ CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
+ std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
+
+ Style.NamespaceMacros.clear();
+ CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
+ std::vector<std::string>{"TESTSUITE"});
+ CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
+ std::vector<std::string>({"TESTSUITE", "SUITE"}));
+
+ Style.WhitespaceSensitiveMacros.clear();
+ CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE]",
+ WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
+ CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE, ASSERT]",
+ WhitespaceSensitiveMacros,
+ std::vector<std::string>({"STRINGIZE", "ASSERT"}));
+ Style.WhitespaceSensitiveMacros.clear();
+ CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE']",
+ WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
+ CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE', 'ASSERT']",
+ WhitespaceSensitiveMacros,
+ std::vector<std::string>({"STRINGIZE", "ASSERT"}));
+
+ Style.IncludeStyle.IncludeCategories.clear();
+ std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
+ {"abc/.*", 2, 0, false}, {".*", 1, 0, true}};
+ CHECK_PARSE("IncludeCategories:\n"
+ " - Regex: abc/.*\n"
+ " Priority: 2\n"
+ " - Regex: .*\n"
+ " Priority: 1\n"
+ " CaseSensitive: true\n",
+ IncludeStyle.IncludeCategories, ExpectedCategories);
+ CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
+ "abc$");
+ CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'",
+ IncludeStyle.IncludeIsMainSourceRegex, "abc$");
+
+ Style.SortIncludes = FormatStyle::SI_Never;
+ CHECK_PARSE("SortIncludes: true", SortIncludes,
+ FormatStyle::SI_CaseSensitive);
+ CHECK_PARSE("SortIncludes: false", SortIncludes, FormatStyle::SI_Never);
+ CHECK_PARSE("SortIncludes: CaseInsensitive", SortIncludes,
+ FormatStyle::SI_CaseInsensitive);
+ CHECK_PARSE("SortIncludes: CaseSensitive", SortIncludes,
+ FormatStyle::SI_CaseSensitive);
+ CHECK_PARSE("SortIncludes: Never", SortIncludes, FormatStyle::SI_Never);
+
+ Style.RawStringFormats.clear();
+ std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
+ {
+ FormatStyle::LK_TextProto,
+ {"pb", "proto"},
+ {"PARSE_TEXT_PROTO"},
+ /*CanonicalDelimiter=*/"",
+ "llvm",
+ },
+ {
+ FormatStyle::LK_Cpp,
+ {"cc", "cpp"},
+ {"C_CODEBLOCK", "CPPEVAL"},
+ /*CanonicalDelimiter=*/"cc",
+ /*BasedOnStyle=*/"",
+ },
+ };
+
+ CHECK_PARSE("RawStringFormats:\n"
+ " - Language: TextProto\n"
+ " Delimiters:\n"
+ " - 'pb'\n"
+ " - 'proto'\n"
+ " EnclosingFunctions:\n"
+ " - 'PARSE_TEXT_PROTO'\n"
+ " BasedOnStyle: llvm\n"
+ " - Language: Cpp\n"
+ " Delimiters:\n"
+ " - 'cc'\n"
+ " - 'cpp'\n"
+ " EnclosingFunctions:\n"
+ " - 'C_CODEBLOCK'\n"
+ " - 'CPPEVAL'\n"
+ " CanonicalDelimiter: 'cc'",
+ RawStringFormats, ExpectedRawStringFormats);
+
+ CHECK_PARSE("SpacesInLineCommentPrefix:\n"
+ " Minimum: 0\n"
+ " Maximum: 0",
+ SpacesInLineCommentPrefix.Minimum, 0u);
+ EXPECT_EQ(Style.SpacesInLineCommentPrefix.Maximum, 0u);
+ Style.SpacesInLineCommentPrefix.Minimum = 1;
+ CHECK_PARSE("SpacesInLineCommentPrefix:\n"
+ " Minimum: 2",
+ SpacesInLineCommentPrefix.Minimum, 0u);
+ CHECK_PARSE("SpacesInLineCommentPrefix:\n"
+ " Maximum: -1",
+ SpacesInLineCommentPrefix.Maximum, -1u);
+ CHECK_PARSE("SpacesInLineCommentPrefix:\n"
+ " Minimum: 2",
+ SpacesInLineCommentPrefix.Minimum, 2u);
+ CHECK_PARSE("SpacesInLineCommentPrefix:\n"
+ " Maximum: 1",
+ SpacesInLineCommentPrefix.Maximum, 1u);
+ EXPECT_EQ(Style.SpacesInLineCommentPrefix.Minimum, 1u);
+
+ Style.SpacesInAngles = FormatStyle::SIAS_Always;
+ CHECK_PARSE("SpacesInAngles: Never", SpacesInAngles, FormatStyle::SIAS_Never);
+ CHECK_PARSE("SpacesInAngles: Always", SpacesInAngles,
+ FormatStyle::SIAS_Always);
+ CHECK_PARSE("SpacesInAngles: Leave", SpacesInAngles, FormatStyle::SIAS_Leave);
+ // For backward compatibility:
+ CHECK_PARSE("SpacesInAngles: false", SpacesInAngles, FormatStyle::SIAS_Never);
+ CHECK_PARSE("SpacesInAngles: true", SpacesInAngles, FormatStyle::SIAS_Always);
+
+ CHECK_PARSE("RequiresClausePosition: WithPreceding", RequiresClausePosition,
+ FormatStyle::RCPS_WithPreceding);
+ CHECK_PARSE("RequiresClausePosition: WithFollowing", RequiresClausePosition,
+ FormatStyle::RCPS_WithFollowing);
+ CHECK_PARSE("RequiresClausePosition: SingleLine", RequiresClausePosition,
+ FormatStyle::RCPS_SingleLine);
+ CHECK_PARSE("RequiresClausePosition: OwnLine", RequiresClausePosition,
+ FormatStyle::RCPS_OwnLine);
+
+ CHECK_PARSE("BreakBeforeConceptDeclarations: Never",
+ BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Never);
+ CHECK_PARSE("BreakBeforeConceptDeclarations: Always",
+ BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Always);
+ CHECK_PARSE("BreakBeforeConceptDeclarations: Allowed",
+ BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Allowed);
+ // For backward compatibility:
+ CHECK_PARSE("BreakBeforeConceptDeclarations: true",
+ BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Always);
+ CHECK_PARSE("BreakBeforeConceptDeclarations: false",
+ BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Allowed);
+}
+
+TEST(ConfigParseTest, ParsesConfigurationWithLanguages) {
+ FormatStyle Style = {};
+ Style.Language = FormatStyle::LK_Cpp;
+ CHECK_PARSE("Language: Cpp\n"
+ "IndentWidth: 12",
+ IndentWidth, 12u);
+ EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
+ "IndentWidth: 34",
+ &Style),
+ ParseError::Unsuitable);
+ FormatStyle BinPackedTCS = {};
+ BinPackedTCS.Language = FormatStyle::LK_JavaScript;
+ EXPECT_EQ(parseConfiguration("BinPackArguments: true\n"
+ "InsertTrailingCommas: Wrapped",
+ &BinPackedTCS),
+ ParseError::BinPackTrailingCommaConflict);
+ EXPECT_EQ(12u, Style.IndentWidth);
+ CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
+ EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
+
+ Style.Language = FormatStyle::LK_JavaScript;
+ CHECK_PARSE("Language: JavaScript\n"
+ "IndentWidth: 12",
+ IndentWidth, 12u);
+ CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
+ EXPECT_EQ(parseConfiguration("Language: Cpp\n"
+ "IndentWidth: 34",
+ &Style),
+ ParseError::Unsuitable);
+ EXPECT_EQ(23u, Style.IndentWidth);
+ CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
+ EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
+
+ CHECK_PARSE("BasedOnStyle: LLVM\n"
+ "IndentWidth: 67",
+ IndentWidth, 67u);
+
+ CHECK_PARSE("---\n"
+ "Language: JavaScript\n"
+ "IndentWidth: 12\n"
+ "---\n"
+ "Language: Cpp\n"
+ "IndentWidth: 34\n"
+ "...\n",
+ IndentWidth, 12u);
+
+ Style.Language = FormatStyle::LK_Cpp;
+ CHECK_PARSE("---\n"
+ "Language: JavaScript\n"
+ "IndentWidth: 12\n"
+ "---\n"
+ "Language: Cpp\n"
+ "IndentWidth: 34\n"
+ "...\n",
+ IndentWidth, 34u);
+ CHECK_PARSE("---\n"
+ "IndentWidth: 78\n"
+ "---\n"
+ "Language: JavaScript\n"
+ "IndentWidth: 56\n"
+ "...\n",
+ IndentWidth, 78u);
+
+ Style.ColumnLimit = 123;
+ Style.IndentWidth = 234;
+ Style.BreakBeforeBraces = FormatStyle::BS_Linux;
+ Style.TabWidth = 345;
+ EXPECT_FALSE(parseConfiguration("---\n"
+ "IndentWidth: 456\n"
+ "BreakBeforeBraces: Allman\n"
+ "---\n"
+ "Language: JavaScript\n"
+ "IndentWidth: 111\n"
+ "TabWidth: 111\n"
+ "---\n"
+ "Language: Cpp\n"
+ "BreakBeforeBraces: Stroustrup\n"
+ "TabWidth: 789\n"
+ "...\n",
+ &Style));
+ EXPECT_EQ(123u, Style.ColumnLimit);
+ EXPECT_EQ(456u, Style.IndentWidth);
+ EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
+ EXPECT_EQ(789u, Style.TabWidth);
+
+ EXPECT_EQ(parseConfiguration("---\n"
+ "Language: JavaScript\n"
+ "IndentWidth: 56\n"
+ "---\n"
+ "IndentWidth: 78\n"
+ "...\n",
+ &Style),
+ ParseError::Error);
+ EXPECT_EQ(parseConfiguration("---\n"
+ "Language: JavaScript\n"
+ "IndentWidth: 56\n"
+ "---\n"
+ "Language: JavaScript\n"
+ "IndentWidth: 78\n"
+ "...\n",
+ &Style),
+ ParseError::Error);
+
+ EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
+}
+
+TEST(ConfigParseTest, UsesLanguageForBasedOnStyle) {
+ FormatStyle Style = {};
+ Style.Language = FormatStyle::LK_JavaScript;
+ Style.BreakBeforeTernaryOperators = true;
+ EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
+ EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
+
+ Style.BreakBeforeTernaryOperators = true;
+ EXPECT_EQ(0, parseConfiguration("---\n"
+ "BasedOnStyle: Google\n"
+ "---\n"
+ "Language: JavaScript\n"
+ "IndentWidth: 76\n"
+ "...\n",
+ &Style)
+ .value());
+ EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
+ EXPECT_EQ(76u, Style.IndentWidth);
+ EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
+}
+
+TEST(ConfigParseTest, ConfigurationRoundTripTest) {
+ FormatStyle Style = getLLVMStyle();
+ std::string YAML = configurationAsText(Style);
+ FormatStyle ParsedStyle = {};
+ ParsedStyle.Language = FormatStyle::LK_Cpp;
+ EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
+ EXPECT_EQ(Style, ParsedStyle);
+}
+
+TEST(ConfigParseTest, GetStyleWithEmptyFileName) {
+ llvm::vfs::InMemoryFileSystem FS;
+ auto Style1 = getStyle("file", "", "Google", "", &FS);
+ ASSERT_TRUE((bool)Style1);
+ ASSERT_EQ(*Style1, getGoogleStyle());
+}
+
+TEST(ConfigParseTest, GetStyleOfFile) {
+ llvm::vfs::InMemoryFileSystem FS;
+ // Test 1: format file in the same directory.
+ ASSERT_TRUE(
+ FS.addFile("/a/.clang-format", 0,
+ llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
+ ASSERT_TRUE(
+ FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
+ auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
+ ASSERT_TRUE((bool)Style1);
+ ASSERT_EQ(*Style1, getLLVMStyle());
+
+ // Test 2.1: fallback to default.
+ ASSERT_TRUE(
+ FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
+ auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
+ ASSERT_TRUE((bool)Style2);
+ ASSERT_EQ(*Style2, getMozillaStyle());
+
+ // Test 2.2: no format on 'none' fallback style.
+ Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
+ ASSERT_TRUE((bool)Style2);
+ ASSERT_EQ(*Style2, getNoStyle());
+
+ // Test 2.3: format if config is found with no based style while fallback is
+ // 'none'.
+ ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
+ llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
+ Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
+ ASSERT_TRUE((bool)Style2);
+ ASSERT_EQ(*Style2, getLLVMStyle());
+
+ // Test 2.4: format if yaml with no based style, while fallback is 'none'.
+ Style2 = getStyle("{}", "a.h", "none", "", &FS);
+ ASSERT_TRUE((bool)Style2);
+ ASSERT_EQ(*Style2, getLLVMStyle());
+
+ // Test 3: format file in parent directory.
+ ASSERT_TRUE(
+ FS.addFile("/c/.clang-format", 0,
+ llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
+ ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
+ llvm::MemoryBuffer::getMemBuffer("int i;")));
+ auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
+ ASSERT_TRUE((bool)Style3);
+ ASSERT_EQ(*Style3, getGoogleStyle());
+
+ // Test 4: error on invalid fallback style
+ auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
+ ASSERT_FALSE((bool)Style4);
+ llvm::consumeError(Style4.takeError());
+
+ // Test 5: error on invalid yaml on command line
+ auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
+ ASSERT_FALSE((bool)Style5);
+ llvm::consumeError(Style5.takeError());
+
+ // Test 6: error on invalid style
+ auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
+ ASSERT_FALSE((bool)Style6);
+ llvm::consumeError(Style6.takeError());
+
+ // Test 7: found config file, error on parsing it
+ ASSERT_TRUE(
+ FS.addFile("/d/.clang-format", 0,
+ llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
+ "InvalidKey: InvalidValue")));
+ ASSERT_TRUE(
+ FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
+ auto Style7a = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
+ ASSERT_FALSE((bool)Style7a);
+ llvm::consumeError(Style7a.takeError());
+
+ auto Style7b = getStyle("file", "/d/.clang-format", "LLVM", "", &FS, true);
+ ASSERT_TRUE((bool)Style7b);
+
+ // Test 8: inferred per-language defaults apply.
+ auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
+ ASSERT_TRUE((bool)StyleTd);
+ ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
+
+ // Test 9.1.1: overwriting a file style, when no parent file exists with no
+ // fallback style.
+ ASSERT_TRUE(FS.addFile(
+ "/e/sub/.clang-format", 0,
+ llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: InheritParentConfig\n"
+ "ColumnLimit: 20")));
+ ASSERT_TRUE(FS.addFile("/e/sub/code.cpp", 0,
+ llvm::MemoryBuffer::getMemBuffer("int i;")));
+ auto Style9 = getStyle("file", "/e/sub/code.cpp", "none", "", &FS);
+ ASSERT_TRUE(static_cast<bool>(Style9));
+ ASSERT_EQ(*Style9, [] {
+ auto Style = getNoStyle();
+ Style.ColumnLimit = 20;
+ return Style;
+ }());
+
+ // Test 9.1.2: propagate more than one level with no parent file.
+ ASSERT_TRUE(FS.addFile("/e/sub/sub/code.cpp", 0,
+ llvm::MemoryBuffer::getMemBuffer("int i;")));
+ ASSERT_TRUE(FS.addFile("/e/sub/sub/.clang-format", 0,
+ llvm::MemoryBuffer::getMemBuffer(
+ "BasedOnStyle: InheritParentConfig\n"
+ "WhitespaceSensitiveMacros: ['FOO', 'BAR']")));
+ std::vector<std::string> NonDefaultWhiteSpaceMacros =
+ Style9->WhitespaceSensitiveMacros;
+ NonDefaultWhiteSpaceMacros[0] = "FOO";
+ NonDefaultWhiteSpaceMacros[1] = "BAR";
+
+ ASSERT_NE(Style9->WhitespaceSensitiveMacros, NonDefaultWhiteSpaceMacros);
+ Style9 = getStyle("file", "/e/sub/sub/code.cpp", "none", "", &FS);
+ ASSERT_TRUE(static_cast<bool>(Style9));
+ ASSERT_EQ(*Style9, [&NonDefaultWhiteSpaceMacros] {
+ auto Style = getNoStyle();
+ Style.ColumnLimit = 20;
+ Style.WhitespaceSensitiveMacros = NonDefaultWhiteSpaceMacros;
+ return Style;
+ }());
+
+ // Test 9.2: with LLVM fallback style
+ Style9 = getStyle("file", "/e/sub/code.cpp", "LLVM", "", &FS);
+ ASSERT_TRUE(static_cast<bool>(Style9));
+ ASSERT_EQ(*Style9, [] {
+ auto Style = getLLVMStyle();
+ Style.ColumnLimit = 20;
+ return Style;
+ }());
+
+ // Test 9.3: with a parent file
+ ASSERT_TRUE(
+ FS.addFile("/e/.clang-format", 0,
+ llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google\n"
+ "UseTab: Always")));
+ Style9 = getStyle("file", "/e/sub/code.cpp", "none", "", &FS);
+ ASSERT_TRUE(static_cast<bool>(Style9));
+ ASSERT_EQ(*Style9, [] {
+ auto Style = getGoogleStyle();
+ Style.ColumnLimit = 20;
+ Style.UseTab = FormatStyle::UT_Always;
+ return Style;
+ }());
+
+ // Test 9.4: propagate more than one level with a parent file.
+ const auto SubSubStyle = [&NonDefaultWhiteSpaceMacros] {
+ auto Style = getGoogleStyle();
+ Style.ColumnLimit = 20;
+ Style.UseTab = FormatStyle::UT_Always;
+ Style.WhitespaceSensitiveMacros = NonDefaultWhiteSpaceMacros;
+ return Style;
+ }();
+
+ ASSERT_NE(Style9->WhitespaceSensitiveMacros, NonDefaultWhiteSpaceMacros);
+ Style9 = getStyle("file", "/e/sub/sub/code.cpp", "none", "", &FS);
+ ASSERT_TRUE(static_cast<bool>(Style9));
+ ASSERT_EQ(*Style9, SubSubStyle);
+
+ // Test 9.5: use InheritParentConfig as style name
+ Style9 =
+ getStyle("inheritparentconfig", "/e/sub/sub/code.cpp", "none", "", &FS);
+ ASSERT_TRUE(static_cast<bool>(Style9));
+ ASSERT_EQ(*Style9, SubSubStyle);
+
+ // Test 9.6: use command line style with inheritance
+ Style9 = getStyle("{BasedOnStyle: InheritParentConfig}",
+ "/e/sub/sub/code.cpp", "none", "", &FS);
+ ASSERT_TRUE(static_cast<bool>(Style9));
+ ASSERT_EQ(*Style9, SubSubStyle);
+
+ // Test 9.7: use command line style with inheritance and own config
+ Style9 = getStyle("{BasedOnStyle: InheritParentConfig, "
+ "WhitespaceSensitiveMacros: ['FOO', 'BAR']}",
+ "/e/sub/code.cpp", "none", "", &FS);
+ ASSERT_TRUE(static_cast<bool>(Style9));
+ ASSERT_EQ(*Style9, SubSubStyle);
+
+ // Test 9.8: use inheritance from a file without BasedOnStyle
+ ASSERT_TRUE(FS.addFile("/e/withoutbase/.clang-format", 0,
+ llvm::MemoryBuffer::getMemBuffer("ColumnLimit: 123")));
+ ASSERT_TRUE(
+ FS.addFile("/e/withoutbase/sub/.clang-format", 0,
+ llvm::MemoryBuffer::getMemBuffer(
+ "BasedOnStyle: InheritParentConfig\nIndentWidth: 7")));
+ // Make sure we do not use the fallback style
+ Style9 = getStyle("file", "/e/withoutbase/code.cpp", "google", "", &FS);
+ ASSERT_TRUE(static_cast<bool>(Style9));
+ ASSERT_EQ(*Style9, [] {
+ auto Style = getLLVMStyle();
+ Style.ColumnLimit = 123;
+ return Style;
+ }());
+
+ Style9 = getStyle("file", "/e/withoutbase/sub/code.cpp", "google", "", &FS);
+ ASSERT_TRUE(static_cast<bool>(Style9));
+ ASSERT_EQ(*Style9, [] {
+ auto Style = getLLVMStyle();
+ Style.ColumnLimit = 123;
+ Style.IndentWidth = 7;
+ return Style;
+ }());
+
+ // Test 9.9: use inheritance from a specific config file.
+ Style9 = getStyle("file:/e/sub/sub/.clang-format", "/e/sub/sub/code.cpp",
+ "none", "", &FS);
+ ASSERT_TRUE(static_cast<bool>(Style9));
+ ASSERT_EQ(*Style9, SubSubStyle);
+}
+
+TEST(ConfigParseTest, GetStyleOfSpecificFile) {
+ llvm::vfs::InMemoryFileSystem FS;
+ // Specify absolute path to a format file in a parent directory.
+ ASSERT_TRUE(
+ FS.addFile("/e/.clang-format", 0,
+ llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
+ ASSERT_TRUE(
+ FS.addFile("/e/explicit.clang-format", 0,
+ llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
+ ASSERT_TRUE(FS.addFile("/e/sub/sub/sub/test.cpp", 0,
+ llvm::MemoryBuffer::getMemBuffer("int i;")));
+ auto Style = getStyle("file:/e/explicit.clang-format",
+ "/e/sub/sub/sub/test.cpp", "LLVM", "", &FS);
+ ASSERT_TRUE(static_cast<bool>(Style));
+ ASSERT_EQ(*Style, getGoogleStyle());
+
+ // Specify relative path to a format file.
+ ASSERT_TRUE(
+ FS.addFile("../../e/explicit.clang-format", 0,
+ llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
+ Style = getStyle("file:../../e/explicit.clang-format",
+ "/e/sub/sub/sub/test.cpp", "LLVM", "", &FS);
+ ASSERT_TRUE(static_cast<bool>(Style));
+ ASSERT_EQ(*Style, getGoogleStyle());
+
+ // Specify path to a format file that does not exist.
+ Style = getStyle("file:/e/missing.clang-format", "/e/sub/sub/sub/test.cpp",
+ "LLVM", "", &FS);
+ ASSERT_FALSE(static_cast<bool>(Style));
+ llvm::consumeError(Style.takeError());
+
+ // Specify path to a file on the filesystem.
+ SmallString<128> FormatFilePath;
+ std::error_code ECF = llvm::sys::fs::createTemporaryFile(
+ "FormatFileTest", "tpl", FormatFilePath);
+ EXPECT_FALSE((bool)ECF);
+ llvm::raw_fd_ostream FormatFileTest(FormatFilePath, ECF);
+ EXPECT_FALSE((bool)ECF);
+ FormatFileTest << "BasedOnStyle: Google\n";
+ FormatFileTest.close();
+
+ SmallString<128> TestFilePath;
+ std::error_code ECT =
+ llvm::sys::fs::createTemporaryFile("CodeFileTest", "cc", TestFilePath);
+ EXPECT_FALSE((bool)ECT);
+ llvm::raw_fd_ostream CodeFileTest(TestFilePath, ECT);
+ CodeFileTest << "int i;\n";
+ CodeFileTest.close();
+
+ std::string format_file_arg = std::string("file:") + FormatFilePath.c_str();
+ Style = getStyle(format_file_arg, TestFilePath, "LLVM", "", nullptr);
+
+ llvm::sys::fs::remove(FormatFilePath.c_str());
+ llvm::sys::fs::remove(TestFilePath.c_str());
+ ASSERT_TRUE(static_cast<bool>(Style));
+ ASSERT_EQ(*Style, getGoogleStyle());
+}
+
+} // namespace
+} // namespace format
+} // namespace clang
diff --git a/clang/unittests/Format/FormatTest.cpp b/clang/unittests/Format/FormatTest.cpp
index 0ff08d4d446da..628cb82c863b7 100644
--- a/clang/unittests/Format/FormatTest.cpp
+++ b/clang/unittests/Format/FormatTest.cpp
@@ -12,7 +12,6 @@
#include "FormatTestUtils.h"
#include "llvm/Support/Debug.h"
-#include "llvm/Support/MemoryBuffer.h"
#include "gtest/gtest.h"
#define DEBUG_TYPE "format-test"
@@ -20289,990 +20288,6 @@ TEST_F(FormatTest, BreakPenaltyAfterForLoopLParen) {
Style));
}
-#define EXPECT_ALL_STYLES_EQUAL(Styles) \
- for (size_t i = 1; i < Styles.size(); ++i) \
- EXPECT_EQ(Styles[0], Styles[i]) \
- << "Style #" << i << " of " << Styles.size() << "
diff ers from Style #0"
-
-TEST_F(FormatTest, GetsPredefinedStyleByName) {
- SmallVector<FormatStyle, 3> Styles;
- Styles.resize(3);
-
- Styles[0] = getLLVMStyle();
- EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
- EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
- EXPECT_ALL_STYLES_EQUAL(Styles);
-
- Styles[0] = getGoogleStyle();
- EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
- EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
- EXPECT_ALL_STYLES_EQUAL(Styles);
-
- Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
- EXPECT_TRUE(
- getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
- EXPECT_TRUE(
- getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
- EXPECT_ALL_STYLES_EQUAL(Styles);
-
- Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
- EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
- EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
- EXPECT_ALL_STYLES_EQUAL(Styles);
-
- Styles[0] = getMozillaStyle();
- EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
- EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
- EXPECT_ALL_STYLES_EQUAL(Styles);
-
- Styles[0] = getWebKitStyle();
- EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
- EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
- EXPECT_ALL_STYLES_EQUAL(Styles);
-
- Styles[0] = getGNUStyle();
- EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
- EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
- EXPECT_ALL_STYLES_EQUAL(Styles);
-
- EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
-}
-
-TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
- SmallVector<FormatStyle, 8> Styles;
- Styles.resize(2);
-
- Styles[0] = getGoogleStyle();
- Styles[1] = getLLVMStyle();
- EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
- EXPECT_ALL_STYLES_EQUAL(Styles);
-
- Styles.resize(5);
- Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
- Styles[1] = getLLVMStyle();
- Styles[1].Language = FormatStyle::LK_JavaScript;
- EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
-
- Styles[2] = getLLVMStyle();
- Styles[2].Language = FormatStyle::LK_JavaScript;
- EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
- "BasedOnStyle: Google",
- &Styles[2])
- .value());
-
- Styles[3] = getLLVMStyle();
- Styles[3].Language = FormatStyle::LK_JavaScript;
- EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
- "Language: JavaScript",
- &Styles[3])
- .value());
-
- Styles[4] = getLLVMStyle();
- Styles[4].Language = FormatStyle::LK_JavaScript;
- EXPECT_EQ(0, parseConfiguration("---\n"
- "BasedOnStyle: LLVM\n"
- "IndentWidth: 123\n"
- "---\n"
- "BasedOnStyle: Google\n"
- "Language: JavaScript",
- &Styles[4])
- .value());
- EXPECT_ALL_STYLES_EQUAL(Styles);
-}
-
-#define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \
- Style.FIELD = false; \
- EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \
- EXPECT_TRUE(Style.FIELD); \
- EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \
- EXPECT_FALSE(Style.FIELD);
-
-#define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
-
-#define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \
- Style.STRUCT.FIELD = false; \
- EXPECT_EQ(0, \
- parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \
- .value()); \
- EXPECT_TRUE(Style.STRUCT.FIELD); \
- EXPECT_EQ(0, \
- parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \
- .value()); \
- EXPECT_FALSE(Style.STRUCT.FIELD);
-
-#define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \
- CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
-
-#define CHECK_PARSE(TEXT, FIELD, VALUE) \
- EXPECT_NE(VALUE, Style.FIELD) << "Initial value already the same!"; \
- EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \
- EXPECT_EQ(VALUE, Style.FIELD) << "Unexpected value after parsing!"
-
-#define CHECK_PARSE_NESTED_VALUE(TEXT, STRUCT, FIELD, VALUE) \
- EXPECT_NE(VALUE, Style.STRUCT.FIELD) << "Initial value already the same!"; \
- EXPECT_EQ(0, parseConfiguration(#STRUCT ":\n " TEXT, &Style).value()); \
- EXPECT_EQ(VALUE, Style.STRUCT.FIELD) << "Unexpected value after parsing!";
-
-TEST_F(FormatTest, ParsesConfigurationBools) {
- FormatStyle Style = {};
- Style.Language = FormatStyle::LK_Cpp;
- CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
- CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
- CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
- CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
- CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
- CHECK_PARSE_BOOL(BinPackArguments);
- CHECK_PARSE_BOOL(BinPackParameters);
- CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
- CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
- CHECK_PARSE_BOOL(BreakStringLiterals);
- CHECK_PARSE_BOOL(CompactNamespaces);
- CHECK_PARSE_BOOL(DeriveLineEnding);
- CHECK_PARSE_BOOL(DerivePointerAlignment);
- CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
- CHECK_PARSE_BOOL(DisableFormat);
- CHECK_PARSE_BOOL(IndentAccessModifiers);
- CHECK_PARSE_BOOL(IndentCaseLabels);
- CHECK_PARSE_BOOL(IndentCaseBlocks);
- CHECK_PARSE_BOOL(IndentGotoLabels);
- CHECK_PARSE_BOOL_FIELD(IndentRequiresClause, "IndentRequires");
- CHECK_PARSE_BOOL(IndentRequiresClause);
- CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
- CHECK_PARSE_BOOL(InsertBraces);
- CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
- CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
- CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
- CHECK_PARSE_BOOL(Cpp11BracedListStyle);
- CHECK_PARSE_BOOL(ReflowComments);
- CHECK_PARSE_BOOL(RemoveBracesLLVM);
- CHECK_PARSE_BOOL(RemoveSemicolon);
- CHECK_PARSE_BOOL(SortUsingDeclarations);
- CHECK_PARSE_BOOL(SpacesInParentheses);
- CHECK_PARSE_BOOL(SpacesInSquareBrackets);
- CHECK_PARSE_BOOL(SpacesInConditionalStatement);
- CHECK_PARSE_BOOL(SpaceInEmptyBlock);
- CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
- CHECK_PARSE_BOOL(SpacesInContainerLiterals);
- CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
- CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
- CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
- CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
- CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
- CHECK_PARSE_BOOL(SpaceBeforeCaseColon);
- CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
- CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
- CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
- CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon);
- CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets);
- CHECK_PARSE_BOOL(UseCRLF);
-
- CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel);
- CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
- CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
- CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
- CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
- CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
- CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
- CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
- CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
- CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
- CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
- CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody);
- CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeWhile);
- CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
- CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
- CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
- CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
- CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterControlStatements);
- CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterForeachMacros);
- CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions,
- AfterFunctionDeclarationName);
- CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions,
- AfterFunctionDefinitionName);
- CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterIfMacros);
- CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterOverloadedOperator);
- CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, BeforeNonEmptyParentheses);
-}
-
-#undef CHECK_PARSE_BOOL
-
-TEST_F(FormatTest, ParsesConfiguration) {
- FormatStyle Style = {};
- Style.Language = FormatStyle::LK_Cpp;
- CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
- CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
- ConstructorInitializerIndentWidth, 1234u);
- CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
- CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
- CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
- CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u);
- CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
- PenaltyBreakBeforeFirstCallParameter, 1234u);
- CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234",
- PenaltyBreakTemplateDeclaration, 1234u);
- CHECK_PARSE("PenaltyBreakOpenParenthesis: 1234", PenaltyBreakOpenParenthesis,
- 1234u);
- CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
- CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
- PenaltyReturnTypeOnItsOwnLine, 1234u);
- CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
- SpacesBeforeTrailingComments, 1234u);
- CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
- CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
- CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
-
- Style.QualifierAlignment = FormatStyle::QAS_Right;
- CHECK_PARSE("QualifierAlignment: Leave", QualifierAlignment,
- FormatStyle::QAS_Leave);
- CHECK_PARSE("QualifierAlignment: Right", QualifierAlignment,
- FormatStyle::QAS_Right);
- CHECK_PARSE("QualifierAlignment: Left", QualifierAlignment,
- FormatStyle::QAS_Left);
- CHECK_PARSE("QualifierAlignment: Custom", QualifierAlignment,
- FormatStyle::QAS_Custom);
-
- Style.QualifierOrder.clear();
- CHECK_PARSE("QualifierOrder: [ const, volatile, type ]", QualifierOrder,
- std::vector<std::string>({"const", "volatile", "type"}));
- Style.QualifierOrder.clear();
- CHECK_PARSE("QualifierOrder: [const, type]", QualifierOrder,
- std::vector<std::string>({"const", "type"}));
- Style.QualifierOrder.clear();
- CHECK_PARSE("QualifierOrder: [volatile, type]", QualifierOrder,
- std::vector<std::string>({"volatile", "type"}));
-
-#define CHECK_ALIGN_CONSECUTIVE(FIELD) \
- do { \
- Style.FIELD.Enabled = true; \
- CHECK_PARSE(#FIELD ": None", FIELD, \
- FormatStyle::AlignConsecutiveStyle( \
- {/*Enabled=*/false, /*AcrossEmptyLines=*/false, \
- /*AcrossComments=*/false, /*AlignCompound=*/false, \
- /*PadOperators=*/true})); \
- CHECK_PARSE(#FIELD ": Consecutive", FIELD, \
- FormatStyle::AlignConsecutiveStyle( \
- {/*Enabled=*/true, /*AcrossEmptyLines=*/false, \
- /*AcrossComments=*/false, /*AlignCompound=*/false, \
- /*PadOperators=*/true})); \
- CHECK_PARSE(#FIELD ": AcrossEmptyLines", FIELD, \
- FormatStyle::AlignConsecutiveStyle( \
- {/*Enabled=*/true, /*AcrossEmptyLines=*/true, \
- /*AcrossComments=*/false, /*AlignCompound=*/false, \
- /*PadOperators=*/true})); \
- CHECK_PARSE(#FIELD ": AcrossEmptyLinesAndComments", FIELD, \
- FormatStyle::AlignConsecutiveStyle( \
- {/*Enabled=*/true, /*AcrossEmptyLines=*/true, \
- /*AcrossComments=*/true, /*AlignCompound=*/false, \
- /*PadOperators=*/true})); \
- /* For backwards compability, false / true should still parse */ \
- CHECK_PARSE(#FIELD ": false", FIELD, \
- FormatStyle::AlignConsecutiveStyle( \
- {/*Enabled=*/false, /*AcrossEmptyLines=*/false, \
- /*AcrossComments=*/false, /*AlignCompound=*/false, \
- /*PadOperators=*/true})); \
- CHECK_PARSE(#FIELD ": true", FIELD, \
- FormatStyle::AlignConsecutiveStyle( \
- {/*Enabled=*/true, /*AcrossEmptyLines=*/false, \
- /*AcrossComments=*/false, /*AlignCompound=*/false, \
- /*PadOperators=*/true})); \
- \
- CHECK_PARSE_NESTED_BOOL(FIELD, Enabled); \
- CHECK_PARSE_NESTED_BOOL(FIELD, AcrossEmptyLines); \
- CHECK_PARSE_NESTED_BOOL(FIELD, AcrossComments); \
- CHECK_PARSE_NESTED_BOOL(FIELD, AlignCompound); \
- CHECK_PARSE_NESTED_BOOL(FIELD, PadOperators); \
- } while (false)
-
- CHECK_ALIGN_CONSECUTIVE(AlignConsecutiveAssignments);
- CHECK_ALIGN_CONSECUTIVE(AlignConsecutiveBitFields);
- CHECK_ALIGN_CONSECUTIVE(AlignConsecutiveMacros);
- CHECK_ALIGN_CONSECUTIVE(AlignConsecutiveDeclarations);
-
-#undef CHECK_ALIGN_CONSECUTIVE
-
- Style.PointerAlignment = FormatStyle::PAS_Middle;
- CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
- FormatStyle::PAS_Left);
- CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
- FormatStyle::PAS_Right);
- CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
- FormatStyle::PAS_Middle);
- Style.ReferenceAlignment = FormatStyle::RAS_Middle;
- CHECK_PARSE("ReferenceAlignment: Pointer", ReferenceAlignment,
- FormatStyle::RAS_Pointer);
- CHECK_PARSE("ReferenceAlignment: Left", ReferenceAlignment,
- FormatStyle::RAS_Left);
- CHECK_PARSE("ReferenceAlignment: Right", ReferenceAlignment,
- FormatStyle::RAS_Right);
- CHECK_PARSE("ReferenceAlignment: Middle", ReferenceAlignment,
- FormatStyle::RAS_Middle);
- // For backward compatibility:
- CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
- FormatStyle::PAS_Left);
- CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
- FormatStyle::PAS_Right);
- CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
- FormatStyle::PAS_Middle);
-
- Style.Standard = FormatStyle::LS_Auto;
- CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03);
- CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11);
- CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14);
- CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17);
- CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20);
- CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
- CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest);
- // Legacy aliases:
- CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
- CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest);
- CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
- CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
-
- Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
- CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
- BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
- CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
- FormatStyle::BOS_None);
- CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
- FormatStyle::BOS_All);
- // For backward compatibility:
- CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
- FormatStyle::BOS_None);
- CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
- FormatStyle::BOS_All);
-
- Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
- CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
- BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
- CHECK_PARSE("BreakConstructorInitializers: AfterColon",
- BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
- CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
- BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
- // For backward compatibility:
- CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
- BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
-
- Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
- CHECK_PARSE("BreakInheritanceList: AfterComma", BreakInheritanceList,
- FormatStyle::BILS_AfterComma);
- CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList,
- FormatStyle::BILS_BeforeComma);
- CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList,
- FormatStyle::BILS_AfterColon);
- CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList,
- FormatStyle::BILS_BeforeColon);
- // For backward compatibility:
- CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
- FormatStyle::BILS_BeforeComma);
-
- Style.PackConstructorInitializers = FormatStyle::PCIS_BinPack;
- CHECK_PARSE("PackConstructorInitializers: Never", PackConstructorInitializers,
- FormatStyle::PCIS_Never);
- CHECK_PARSE("PackConstructorInitializers: BinPack",
- PackConstructorInitializers, FormatStyle::PCIS_BinPack);
- CHECK_PARSE("PackConstructorInitializers: CurrentLine",
- PackConstructorInitializers, FormatStyle::PCIS_CurrentLine);
- CHECK_PARSE("PackConstructorInitializers: NextLine",
- PackConstructorInitializers, FormatStyle::PCIS_NextLine);
- // For backward compatibility:
- CHECK_PARSE("BasedOnStyle: Google\n"
- "ConstructorInitializerAllOnOneLineOrOnePerLine: true\n"
- "AllowAllConstructorInitializersOnNextLine: false",
- PackConstructorInitializers, FormatStyle::PCIS_CurrentLine);
- Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine;
- CHECK_PARSE("BasedOnStyle: Google\n"
- "ConstructorInitializerAllOnOneLineOrOnePerLine: false",
- PackConstructorInitializers, FormatStyle::PCIS_BinPack);
- CHECK_PARSE("ConstructorInitializerAllOnOneLineOrOnePerLine: true\n"
- "AllowAllConstructorInitializersOnNextLine: true",
- PackConstructorInitializers, FormatStyle::PCIS_NextLine);
- Style.PackConstructorInitializers = FormatStyle::PCIS_BinPack;
- CHECK_PARSE("ConstructorInitializerAllOnOneLineOrOnePerLine: true\n"
- "AllowAllConstructorInitializersOnNextLine: false",
- PackConstructorInitializers, FormatStyle::PCIS_CurrentLine);
-
- Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_LogicalBlock;
- CHECK_PARSE("EmptyLineBeforeAccessModifier: Never",
- EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_Never);
- CHECK_PARSE("EmptyLineBeforeAccessModifier: Leave",
- EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_Leave);
- CHECK_PARSE("EmptyLineBeforeAccessModifier: LogicalBlock",
- EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_LogicalBlock);
- CHECK_PARSE("EmptyLineBeforeAccessModifier: Always",
- EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_Always);
-
- Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
- CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
- FormatStyle::BAS_Align);
- CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
- FormatStyle::BAS_DontAlign);
- CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
- FormatStyle::BAS_AlwaysBreak);
- CHECK_PARSE("AlignAfterOpenBracket: BlockIndent", AlignAfterOpenBracket,
- FormatStyle::BAS_BlockIndent);
- // For backward compatibility:
- CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
- FormatStyle::BAS_DontAlign);
- CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
- FormatStyle::BAS_Align);
-
- Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
- CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
- FormatStyle::ENAS_DontAlign);
- CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
- FormatStyle::ENAS_Left);
- CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
- FormatStyle::ENAS_Right);
- // For backward compatibility:
- CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
- FormatStyle::ENAS_Left);
- CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
- FormatStyle::ENAS_Right);
-
- Style.AlignOperands = FormatStyle::OAS_Align;
- CHECK_PARSE("AlignOperands: DontAlign", AlignOperands,
- FormatStyle::OAS_DontAlign);
- CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align);
- CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands,
- FormatStyle::OAS_AlignAfterOperator);
- // For backward compatibility:
- CHECK_PARSE("AlignOperands: false", AlignOperands,
- FormatStyle::OAS_DontAlign);
- CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align);
-
- CHECK_PARSE("AlignTrailingComments: Leave", AlignTrailingComments,
- FormatStyle::TrailingCommentsAlignmentStyle(
- {FormatStyle::TCAS_Leave, 1}));
- CHECK_PARSE("AlignTrailingComments: Always", AlignTrailingComments,
- FormatStyle::TrailingCommentsAlignmentStyle(
- {FormatStyle::TCAS_Always, 1}));
- CHECK_PARSE("AlignTrailingComments: Never", AlignTrailingComments,
- FormatStyle::TrailingCommentsAlignmentStyle(
- {FormatStyle::TCAS_Never, 1}));
- // For backwards compatibility
- CHECK_PARSE("AlignTrailingComments: true", AlignTrailingComments,
- FormatStyle::TrailingCommentsAlignmentStyle(
- {FormatStyle::TCAS_Always, 1}));
- CHECK_PARSE("AlignTrailingComments: false", AlignTrailingComments,
- FormatStyle::TrailingCommentsAlignmentStyle(
- {FormatStyle::TCAS_Never, 1}));
- CHECK_PARSE_NESTED_VALUE("Kind: Always", AlignTrailingComments, Kind,
- FormatStyle::TCAS_Always);
- CHECK_PARSE_NESTED_VALUE("Kind: Never", AlignTrailingComments, Kind,
- FormatStyle::TCAS_Never);
- CHECK_PARSE_NESTED_VALUE("Kind: Leave", AlignTrailingComments, Kind,
- FormatStyle::TCAS_Leave);
- CHECK_PARSE_NESTED_VALUE("OverEmptyLines: 1234", AlignTrailingComments,
- OverEmptyLines, 1234u);
-
- Style.UseTab = FormatStyle::UT_ForIndentation;
- CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
- CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
- CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
- CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
- FormatStyle::UT_ForContinuationAndIndentation);
- CHECK_PARSE("UseTab: AlignWithSpaces", UseTab,
- FormatStyle::UT_AlignWithSpaces);
- // For backward compatibility:
- CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
- CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
-
- Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
- CHECK_PARSE("AllowShortBlocksOnASingleLine: Never",
- AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
- CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty",
- AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty);
- CHECK_PARSE("AllowShortBlocksOnASingleLine: Always",
- AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
- // For backward compatibility:
- CHECK_PARSE("AllowShortBlocksOnASingleLine: false",
- AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
- CHECK_PARSE("AllowShortBlocksOnASingleLine: true",
- AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
-
- Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
- CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
- AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
- CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
- AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
- CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
- AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
- CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
- AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
- // For backward compatibility:
- CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
- AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
- CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
- AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
-
- Style.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Both;
- CHECK_PARSE("SpaceAroundPointerQualifiers: Default",
- SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Default);
- CHECK_PARSE("SpaceAroundPointerQualifiers: Before",
- SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Before);
- CHECK_PARSE("SpaceAroundPointerQualifiers: After",
- SpaceAroundPointerQualifiers, FormatStyle::SAPQ_After);
- CHECK_PARSE("SpaceAroundPointerQualifiers: Both",
- SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Both);
-
- Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
- CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
- FormatStyle::SBPO_Never);
- CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
- FormatStyle::SBPO_Always);
- CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
- FormatStyle::SBPO_ControlStatements);
- CHECK_PARSE("SpaceBeforeParens: ControlStatementsExceptControlMacros",
- SpaceBeforeParens,
- FormatStyle::SBPO_ControlStatementsExceptControlMacros);
- CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens,
- FormatStyle::SBPO_NonEmptyParentheses);
- CHECK_PARSE("SpaceBeforeParens: Custom", SpaceBeforeParens,
- FormatStyle::SBPO_Custom);
- // For backward compatibility:
- CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
- FormatStyle::SBPO_Never);
- CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
- FormatStyle::SBPO_ControlStatements);
- CHECK_PARSE("SpaceBeforeParens: ControlStatementsExceptForEachMacros",
- SpaceBeforeParens,
- FormatStyle::SBPO_ControlStatementsExceptControlMacros);
-
- Style.ColumnLimit = 123;
- FormatStyle BaseStyle = getLLVMStyle();
- CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
- CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
-
- Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
- CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
- FormatStyle::BS_Attach);
- CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
- FormatStyle::BS_Linux);
- CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
- FormatStyle::BS_Mozilla);
- CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
- FormatStyle::BS_Stroustrup);
- CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
- FormatStyle::BS_Allman);
- CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces,
- FormatStyle::BS_Whitesmiths);
- CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
- CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
- FormatStyle::BS_WebKit);
- CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
- FormatStyle::BS_Custom);
-
- Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
- CHECK_PARSE("BraceWrapping:\n"
- " AfterControlStatement: MultiLine",
- BraceWrapping.AfterControlStatement,
- FormatStyle::BWACS_MultiLine);
- CHECK_PARSE("BraceWrapping:\n"
- " AfterControlStatement: Always",
- BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
- CHECK_PARSE("BraceWrapping:\n"
- " AfterControlStatement: Never",
- BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
- // For backward compatibility:
- CHECK_PARSE("BraceWrapping:\n"
- " AfterControlStatement: true",
- BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
- CHECK_PARSE("BraceWrapping:\n"
- " AfterControlStatement: false",
- BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
-
- Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
- CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
- FormatStyle::RTBS_None);
- CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
- FormatStyle::RTBS_All);
- CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
- AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
- CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
- AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
- CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
- AlwaysBreakAfterReturnType,
- FormatStyle::RTBS_TopLevelDefinitions);
-
- Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
- CHECK_PARSE("AlwaysBreakTemplateDeclarations: No",
- AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No);
- CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine",
- AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
- CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes",
- AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
- CHECK_PARSE("AlwaysBreakTemplateDeclarations: false",
- AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
- CHECK_PARSE("AlwaysBreakTemplateDeclarations: true",
- AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
-
- Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
- CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
- AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
- CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
- AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
- CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
- AlwaysBreakAfterDefinitionReturnType,
- FormatStyle::DRTBS_TopLevel);
-
- Style.NamespaceIndentation = FormatStyle::NI_All;
- CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
- FormatStyle::NI_None);
- CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
- FormatStyle::NI_Inner);
- CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
- FormatStyle::NI_All);
-
- Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_OnlyFirstIf;
- CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never",
- AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
- CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse",
- AllowShortIfStatementsOnASingleLine,
- FormatStyle::SIS_WithoutElse);
- CHECK_PARSE("AllowShortIfStatementsOnASingleLine: OnlyFirstIf",
- AllowShortIfStatementsOnASingleLine,
- FormatStyle::SIS_OnlyFirstIf);
- CHECK_PARSE("AllowShortIfStatementsOnASingleLine: AllIfsAndElse",
- AllowShortIfStatementsOnASingleLine,
- FormatStyle::SIS_AllIfsAndElse);
- CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always",
- AllowShortIfStatementsOnASingleLine,
- FormatStyle::SIS_OnlyFirstIf);
- CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false",
- AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
- CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true",
- AllowShortIfStatementsOnASingleLine,
- FormatStyle::SIS_WithoutElse);
-
- Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
- CHECK_PARSE("IndentExternBlock: AfterExternBlock", IndentExternBlock,
- FormatStyle::IEBS_AfterExternBlock);
- CHECK_PARSE("IndentExternBlock: Indent", IndentExternBlock,
- FormatStyle::IEBS_Indent);
- CHECK_PARSE("IndentExternBlock: NoIndent", IndentExternBlock,
- FormatStyle::IEBS_NoIndent);
- CHECK_PARSE("IndentExternBlock: true", IndentExternBlock,
- FormatStyle::IEBS_Indent);
- CHECK_PARSE("IndentExternBlock: false", IndentExternBlock,
- FormatStyle::IEBS_NoIndent);
-
- Style.BitFieldColonSpacing = FormatStyle::BFCS_None;
- CHECK_PARSE("BitFieldColonSpacing: Both", BitFieldColonSpacing,
- FormatStyle::BFCS_Both);
- CHECK_PARSE("BitFieldColonSpacing: None", BitFieldColonSpacing,
- FormatStyle::BFCS_None);
- CHECK_PARSE("BitFieldColonSpacing: Before", BitFieldColonSpacing,
- FormatStyle::BFCS_Before);
- CHECK_PARSE("BitFieldColonSpacing: After", BitFieldColonSpacing,
- FormatStyle::BFCS_After);
-
- Style.SortJavaStaticImport = FormatStyle::SJSIO_Before;
- CHECK_PARSE("SortJavaStaticImport: After", SortJavaStaticImport,
- FormatStyle::SJSIO_After);
- CHECK_PARSE("SortJavaStaticImport: Before", SortJavaStaticImport,
- FormatStyle::SJSIO_Before);
-
- // FIXME: This is required because parsing a configuration simply overwrites
- // the first N elements of the list instead of resetting it.
- Style.ForEachMacros.clear();
- std::vector<std::string> BoostForeach;
- BoostForeach.push_back("BOOST_FOREACH");
- CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
- std::vector<std::string> BoostAndQForeach;
- BoostAndQForeach.push_back("BOOST_FOREACH");
- BoostAndQForeach.push_back("Q_FOREACH");
- CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
- BoostAndQForeach);
-
- Style.IfMacros.clear();
- std::vector<std::string> CustomIfs;
- CustomIfs.push_back("MYIF");
- CHECK_PARSE("IfMacros: [MYIF]", IfMacros, CustomIfs);
-
- Style.AttributeMacros.clear();
- CHECK_PARSE("BasedOnStyle: LLVM", AttributeMacros,
- std::vector<std::string>{"__capability"});
- CHECK_PARSE("AttributeMacros: [attr1, attr2]", AttributeMacros,
- std::vector<std::string>({"attr1", "attr2"}));
-
- Style.StatementAttributeLikeMacros.clear();
- CHECK_PARSE("StatementAttributeLikeMacros: [emit,Q_EMIT]",
- StatementAttributeLikeMacros,
- std::vector<std::string>({"emit", "Q_EMIT"}));
-
- Style.StatementMacros.clear();
- CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
- std::vector<std::string>{"QUNUSED"});
- CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
- std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
-
- Style.NamespaceMacros.clear();
- CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
- std::vector<std::string>{"TESTSUITE"});
- CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
- std::vector<std::string>({"TESTSUITE", "SUITE"}));
-
- Style.WhitespaceSensitiveMacros.clear();
- CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE]",
- WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
- CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE, ASSERT]",
- WhitespaceSensitiveMacros,
- std::vector<std::string>({"STRINGIZE", "ASSERT"}));
- Style.WhitespaceSensitiveMacros.clear();
- CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE']",
- WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
- CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE', 'ASSERT']",
- WhitespaceSensitiveMacros,
- std::vector<std::string>({"STRINGIZE", "ASSERT"}));
-
- Style.IncludeStyle.IncludeCategories.clear();
- std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
- {"abc/.*", 2, 0, false}, {".*", 1, 0, true}};
- CHECK_PARSE("IncludeCategories:\n"
- " - Regex: abc/.*\n"
- " Priority: 2\n"
- " - Regex: .*\n"
- " Priority: 1\n"
- " CaseSensitive: true\n",
- IncludeStyle.IncludeCategories, ExpectedCategories);
- CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
- "abc$");
- CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'",
- IncludeStyle.IncludeIsMainSourceRegex, "abc$");
-
- Style.SortIncludes = FormatStyle::SI_Never;
- CHECK_PARSE("SortIncludes: true", SortIncludes,
- FormatStyle::SI_CaseSensitive);
- CHECK_PARSE("SortIncludes: false", SortIncludes, FormatStyle::SI_Never);
- CHECK_PARSE("SortIncludes: CaseInsensitive", SortIncludes,
- FormatStyle::SI_CaseInsensitive);
- CHECK_PARSE("SortIncludes: CaseSensitive", SortIncludes,
- FormatStyle::SI_CaseSensitive);
- CHECK_PARSE("SortIncludes: Never", SortIncludes, FormatStyle::SI_Never);
-
- Style.RawStringFormats.clear();
- std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
- {
- FormatStyle::LK_TextProto,
- {"pb", "proto"},
- {"PARSE_TEXT_PROTO"},
- /*CanonicalDelimiter=*/"",
- "llvm",
- },
- {
- FormatStyle::LK_Cpp,
- {"cc", "cpp"},
- {"C_CODEBLOCK", "CPPEVAL"},
- /*CanonicalDelimiter=*/"cc",
- /*BasedOnStyle=*/"",
- },
- };
-
- CHECK_PARSE("RawStringFormats:\n"
- " - Language: TextProto\n"
- " Delimiters:\n"
- " - 'pb'\n"
- " - 'proto'\n"
- " EnclosingFunctions:\n"
- " - 'PARSE_TEXT_PROTO'\n"
- " BasedOnStyle: llvm\n"
- " - Language: Cpp\n"
- " Delimiters:\n"
- " - 'cc'\n"
- " - 'cpp'\n"
- " EnclosingFunctions:\n"
- " - 'C_CODEBLOCK'\n"
- " - 'CPPEVAL'\n"
- " CanonicalDelimiter: 'cc'",
- RawStringFormats, ExpectedRawStringFormats);
-
- CHECK_PARSE("SpacesInLineCommentPrefix:\n"
- " Minimum: 0\n"
- " Maximum: 0",
- SpacesInLineCommentPrefix.Minimum, 0u);
- EXPECT_EQ(Style.SpacesInLineCommentPrefix.Maximum, 0u);
- Style.SpacesInLineCommentPrefix.Minimum = 1;
- CHECK_PARSE("SpacesInLineCommentPrefix:\n"
- " Minimum: 2",
- SpacesInLineCommentPrefix.Minimum, 0u);
- CHECK_PARSE("SpacesInLineCommentPrefix:\n"
- " Maximum: -1",
- SpacesInLineCommentPrefix.Maximum, -1u);
- CHECK_PARSE("SpacesInLineCommentPrefix:\n"
- " Minimum: 2",
- SpacesInLineCommentPrefix.Minimum, 2u);
- CHECK_PARSE("SpacesInLineCommentPrefix:\n"
- " Maximum: 1",
- SpacesInLineCommentPrefix.Maximum, 1u);
- EXPECT_EQ(Style.SpacesInLineCommentPrefix.Minimum, 1u);
-
- Style.SpacesInAngles = FormatStyle::SIAS_Always;
- CHECK_PARSE("SpacesInAngles: Never", SpacesInAngles, FormatStyle::SIAS_Never);
- CHECK_PARSE("SpacesInAngles: Always", SpacesInAngles,
- FormatStyle::SIAS_Always);
- CHECK_PARSE("SpacesInAngles: Leave", SpacesInAngles, FormatStyle::SIAS_Leave);
- // For backward compatibility:
- CHECK_PARSE("SpacesInAngles: false", SpacesInAngles, FormatStyle::SIAS_Never);
- CHECK_PARSE("SpacesInAngles: true", SpacesInAngles, FormatStyle::SIAS_Always);
-
- CHECK_PARSE("RequiresClausePosition: WithPreceding", RequiresClausePosition,
- FormatStyle::RCPS_WithPreceding);
- CHECK_PARSE("RequiresClausePosition: WithFollowing", RequiresClausePosition,
- FormatStyle::RCPS_WithFollowing);
- CHECK_PARSE("RequiresClausePosition: SingleLine", RequiresClausePosition,
- FormatStyle::RCPS_SingleLine);
- CHECK_PARSE("RequiresClausePosition: OwnLine", RequiresClausePosition,
- FormatStyle::RCPS_OwnLine);
-
- CHECK_PARSE("BreakBeforeConceptDeclarations: Never",
- BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Never);
- CHECK_PARSE("BreakBeforeConceptDeclarations: Always",
- BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Always);
- CHECK_PARSE("BreakBeforeConceptDeclarations: Allowed",
- BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Allowed);
- // For backward compatibility:
- CHECK_PARSE("BreakBeforeConceptDeclarations: true",
- BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Always);
- CHECK_PARSE("BreakBeforeConceptDeclarations: false",
- BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Allowed);
-}
-
-TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
- FormatStyle Style = {};
- Style.Language = FormatStyle::LK_Cpp;
- CHECK_PARSE("Language: Cpp\n"
- "IndentWidth: 12",
- IndentWidth, 12u);
- EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
- "IndentWidth: 34",
- &Style),
- ParseError::Unsuitable);
- FormatStyle BinPackedTCS = {};
- BinPackedTCS.Language = FormatStyle::LK_JavaScript;
- EXPECT_EQ(parseConfiguration("BinPackArguments: true\n"
- "InsertTrailingCommas: Wrapped",
- &BinPackedTCS),
- ParseError::BinPackTrailingCommaConflict);
- EXPECT_EQ(12u, Style.IndentWidth);
- CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
- EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
-
- Style.Language = FormatStyle::LK_JavaScript;
- CHECK_PARSE("Language: JavaScript\n"
- "IndentWidth: 12",
- IndentWidth, 12u);
- CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
- EXPECT_EQ(parseConfiguration("Language: Cpp\n"
- "IndentWidth: 34",
- &Style),
- ParseError::Unsuitable);
- EXPECT_EQ(23u, Style.IndentWidth);
- CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
- EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
-
- CHECK_PARSE("BasedOnStyle: LLVM\n"
- "IndentWidth: 67",
- IndentWidth, 67u);
-
- CHECK_PARSE("---\n"
- "Language: JavaScript\n"
- "IndentWidth: 12\n"
- "---\n"
- "Language: Cpp\n"
- "IndentWidth: 34\n"
- "...\n",
- IndentWidth, 12u);
-
- Style.Language = FormatStyle::LK_Cpp;
- CHECK_PARSE("---\n"
- "Language: JavaScript\n"
- "IndentWidth: 12\n"
- "---\n"
- "Language: Cpp\n"
- "IndentWidth: 34\n"
- "...\n",
- IndentWidth, 34u);
- CHECK_PARSE("---\n"
- "IndentWidth: 78\n"
- "---\n"
- "Language: JavaScript\n"
- "IndentWidth: 56\n"
- "...\n",
- IndentWidth, 78u);
-
- Style.ColumnLimit = 123;
- Style.IndentWidth = 234;
- Style.BreakBeforeBraces = FormatStyle::BS_Linux;
- Style.TabWidth = 345;
- EXPECT_FALSE(parseConfiguration("---\n"
- "IndentWidth: 456\n"
- "BreakBeforeBraces: Allman\n"
- "---\n"
- "Language: JavaScript\n"
- "IndentWidth: 111\n"
- "TabWidth: 111\n"
- "---\n"
- "Language: Cpp\n"
- "BreakBeforeBraces: Stroustrup\n"
- "TabWidth: 789\n"
- "...\n",
- &Style));
- EXPECT_EQ(123u, Style.ColumnLimit);
- EXPECT_EQ(456u, Style.IndentWidth);
- EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
- EXPECT_EQ(789u, Style.TabWidth);
-
- EXPECT_EQ(parseConfiguration("---\n"
- "Language: JavaScript\n"
- "IndentWidth: 56\n"
- "---\n"
- "IndentWidth: 78\n"
- "...\n",
- &Style),
- ParseError::Error);
- EXPECT_EQ(parseConfiguration("---\n"
- "Language: JavaScript\n"
- "IndentWidth: 56\n"
- "---\n"
- "Language: JavaScript\n"
- "IndentWidth: 78\n"
- "...\n",
- &Style),
- ParseError::Error);
-
- EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
-}
-
-TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
- FormatStyle Style = {};
- Style.Language = FormatStyle::LK_JavaScript;
- Style.BreakBeforeTernaryOperators = true;
- EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
- EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
-
- Style.BreakBeforeTernaryOperators = true;
- EXPECT_EQ(0, parseConfiguration("---\n"
- "BasedOnStyle: Google\n"
- "---\n"
- "Language: JavaScript\n"
- "IndentWidth: 76\n"
- "...\n",
- &Style)
- .value());
- EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
- EXPECT_EQ(76u, Style.IndentWidth);
- EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
-}
-
-TEST_F(FormatTest, ConfigurationRoundTripTest) {
- FormatStyle Style = getLLVMStyle();
- std::string YAML = configurationAsText(Style);
- FormatStyle ParsedStyle = {};
- ParsedStyle.Language = FormatStyle::LK_Cpp;
- EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
- EXPECT_EQ(Style, ParsedStyle);
-}
-
TEST_F(FormatTest, WorksFor8bitEncodings) {
EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
"\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
@@ -23282,278 +22297,6 @@ TEST_F(FormatTest, ArrayAsTemplateType) {
TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }
-TEST(FormatStyle, GetStyleWithEmptyFileName) {
- llvm::vfs::InMemoryFileSystem FS;
- auto Style1 = getStyle("file", "", "Google", "", &FS);
- ASSERT_TRUE((bool)Style1);
- ASSERT_EQ(*Style1, getGoogleStyle());
-}
-
-TEST(FormatStyle, GetStyleOfFile) {
- llvm::vfs::InMemoryFileSystem FS;
- // Test 1: format file in the same directory.
- ASSERT_TRUE(
- FS.addFile("/a/.clang-format", 0,
- llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
- ASSERT_TRUE(
- FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
- auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
- ASSERT_TRUE((bool)Style1);
- ASSERT_EQ(*Style1, getLLVMStyle());
-
- // Test 2.1: fallback to default.
- ASSERT_TRUE(
- FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
- auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
- ASSERT_TRUE((bool)Style2);
- ASSERT_EQ(*Style2, getMozillaStyle());
-
- // Test 2.2: no format on 'none' fallback style.
- Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
- ASSERT_TRUE((bool)Style2);
- ASSERT_EQ(*Style2, getNoStyle());
-
- // Test 2.3: format if config is found with no based style while fallback is
- // 'none'.
- ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
- llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
- Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
- ASSERT_TRUE((bool)Style2);
- ASSERT_EQ(*Style2, getLLVMStyle());
-
- // Test 2.4: format if yaml with no based style, while fallback is 'none'.
- Style2 = getStyle("{}", "a.h", "none", "", &FS);
- ASSERT_TRUE((bool)Style2);
- ASSERT_EQ(*Style2, getLLVMStyle());
-
- // Test 3: format file in parent directory.
- ASSERT_TRUE(
- FS.addFile("/c/.clang-format", 0,
- llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
- ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
- llvm::MemoryBuffer::getMemBuffer("int i;")));
- auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
- ASSERT_TRUE((bool)Style3);
- ASSERT_EQ(*Style3, getGoogleStyle());
-
- // Test 4: error on invalid fallback style
- auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
- ASSERT_FALSE((bool)Style4);
- llvm::consumeError(Style4.takeError());
-
- // Test 5: error on invalid yaml on command line
- auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
- ASSERT_FALSE((bool)Style5);
- llvm::consumeError(Style5.takeError());
-
- // Test 6: error on invalid style
- auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
- ASSERT_FALSE((bool)Style6);
- llvm::consumeError(Style6.takeError());
-
- // Test 7: found config file, error on parsing it
- ASSERT_TRUE(
- FS.addFile("/d/.clang-format", 0,
- llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
- "InvalidKey: InvalidValue")));
- ASSERT_TRUE(
- FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
- auto Style7a = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
- ASSERT_FALSE((bool)Style7a);
- llvm::consumeError(Style7a.takeError());
-
- auto Style7b = getStyle("file", "/d/.clang-format", "LLVM", "", &FS, true);
- ASSERT_TRUE((bool)Style7b);
-
- // Test 8: inferred per-language defaults apply.
- auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
- ASSERT_TRUE((bool)StyleTd);
- ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
-
- // Test 9.1.1: overwriting a file style, when no parent file exists with no
- // fallback style.
- ASSERT_TRUE(FS.addFile(
- "/e/sub/.clang-format", 0,
- llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: InheritParentConfig\n"
- "ColumnLimit: 20")));
- ASSERT_TRUE(FS.addFile("/e/sub/code.cpp", 0,
- llvm::MemoryBuffer::getMemBuffer("int i;")));
- auto Style9 = getStyle("file", "/e/sub/code.cpp", "none", "", &FS);
- ASSERT_TRUE(static_cast<bool>(Style9));
- ASSERT_EQ(*Style9, [] {
- auto Style = getNoStyle();
- Style.ColumnLimit = 20;
- return Style;
- }());
-
- // Test 9.1.2: propagate more than one level with no parent file.
- ASSERT_TRUE(FS.addFile("/e/sub/sub/code.cpp", 0,
- llvm::MemoryBuffer::getMemBuffer("int i;")));
- ASSERT_TRUE(FS.addFile("/e/sub/sub/.clang-format", 0,
- llvm::MemoryBuffer::getMemBuffer(
- "BasedOnStyle: InheritParentConfig\n"
- "WhitespaceSensitiveMacros: ['FOO', 'BAR']")));
- std::vector<std::string> NonDefaultWhiteSpaceMacros =
- Style9->WhitespaceSensitiveMacros;
- NonDefaultWhiteSpaceMacros[0] = "FOO";
- NonDefaultWhiteSpaceMacros[1] = "BAR";
-
- ASSERT_NE(Style9->WhitespaceSensitiveMacros, NonDefaultWhiteSpaceMacros);
- Style9 = getStyle("file", "/e/sub/sub/code.cpp", "none", "", &FS);
- ASSERT_TRUE(static_cast<bool>(Style9));
- ASSERT_EQ(*Style9, [&NonDefaultWhiteSpaceMacros] {
- auto Style = getNoStyle();
- Style.ColumnLimit = 20;
- Style.WhitespaceSensitiveMacros = NonDefaultWhiteSpaceMacros;
- return Style;
- }());
-
- // Test 9.2: with LLVM fallback style
- Style9 = getStyle("file", "/e/sub/code.cpp", "LLVM", "", &FS);
- ASSERT_TRUE(static_cast<bool>(Style9));
- ASSERT_EQ(*Style9, [] {
- auto Style = getLLVMStyle();
- Style.ColumnLimit = 20;
- return Style;
- }());
-
- // Test 9.3: with a parent file
- ASSERT_TRUE(
- FS.addFile("/e/.clang-format", 0,
- llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google\n"
- "UseTab: Always")));
- Style9 = getStyle("file", "/e/sub/code.cpp", "none", "", &FS);
- ASSERT_TRUE(static_cast<bool>(Style9));
- ASSERT_EQ(*Style9, [] {
- auto Style = getGoogleStyle();
- Style.ColumnLimit = 20;
- Style.UseTab = FormatStyle::UT_Always;
- return Style;
- }());
-
- // Test 9.4: propagate more than one level with a parent file.
- const auto SubSubStyle = [&NonDefaultWhiteSpaceMacros] {
- auto Style = getGoogleStyle();
- Style.ColumnLimit = 20;
- Style.UseTab = FormatStyle::UT_Always;
- Style.WhitespaceSensitiveMacros = NonDefaultWhiteSpaceMacros;
- return Style;
- }();
-
- ASSERT_NE(Style9->WhitespaceSensitiveMacros, NonDefaultWhiteSpaceMacros);
- Style9 = getStyle("file", "/e/sub/sub/code.cpp", "none", "", &FS);
- ASSERT_TRUE(static_cast<bool>(Style9));
- ASSERT_EQ(*Style9, SubSubStyle);
-
- // Test 9.5: use InheritParentConfig as style name
- Style9 =
- getStyle("inheritparentconfig", "/e/sub/sub/code.cpp", "none", "", &FS);
- ASSERT_TRUE(static_cast<bool>(Style9));
- ASSERT_EQ(*Style9, SubSubStyle);
-
- // Test 9.6: use command line style with inheritance
- Style9 = getStyle("{BasedOnStyle: InheritParentConfig}",
- "/e/sub/sub/code.cpp", "none", "", &FS);
- ASSERT_TRUE(static_cast<bool>(Style9));
- ASSERT_EQ(*Style9, SubSubStyle);
-
- // Test 9.7: use command line style with inheritance and own config
- Style9 = getStyle("{BasedOnStyle: InheritParentConfig, "
- "WhitespaceSensitiveMacros: ['FOO', 'BAR']}",
- "/e/sub/code.cpp", "none", "", &FS);
- ASSERT_TRUE(static_cast<bool>(Style9));
- ASSERT_EQ(*Style9, SubSubStyle);
-
- // Test 9.8: use inheritance from a file without BasedOnStyle
- ASSERT_TRUE(FS.addFile("/e/withoutbase/.clang-format", 0,
- llvm::MemoryBuffer::getMemBuffer("ColumnLimit: 123")));
- ASSERT_TRUE(
- FS.addFile("/e/withoutbase/sub/.clang-format", 0,
- llvm::MemoryBuffer::getMemBuffer(
- "BasedOnStyle: InheritParentConfig\nIndentWidth: 7")));
- // Make sure we do not use the fallback style
- Style9 = getStyle("file", "/e/withoutbase/code.cpp", "google", "", &FS);
- ASSERT_TRUE(static_cast<bool>(Style9));
- ASSERT_EQ(*Style9, [] {
- auto Style = getLLVMStyle();
- Style.ColumnLimit = 123;
- return Style;
- }());
-
- Style9 = getStyle("file", "/e/withoutbase/sub/code.cpp", "google", "", &FS);
- ASSERT_TRUE(static_cast<bool>(Style9));
- ASSERT_EQ(*Style9, [] {
- auto Style = getLLVMStyle();
- Style.ColumnLimit = 123;
- Style.IndentWidth = 7;
- return Style;
- }());
-
- // Test 9.9: use inheritance from a specific config file.
- Style9 = getStyle("file:/e/sub/sub/.clang-format", "/e/sub/sub/code.cpp",
- "none", "", &FS);
- ASSERT_TRUE(static_cast<bool>(Style9));
- ASSERT_EQ(*Style9, SubSubStyle);
-}
-
-TEST(FormatStyle, GetStyleOfSpecificFile) {
- llvm::vfs::InMemoryFileSystem FS;
- // Specify absolute path to a format file in a parent directory.
- ASSERT_TRUE(
- FS.addFile("/e/.clang-format", 0,
- llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
- ASSERT_TRUE(
- FS.addFile("/e/explicit.clang-format", 0,
- llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
- ASSERT_TRUE(FS.addFile("/e/sub/sub/sub/test.cpp", 0,
- llvm::MemoryBuffer::getMemBuffer("int i;")));
- auto Style = getStyle("file:/e/explicit.clang-format",
- "/e/sub/sub/sub/test.cpp", "LLVM", "", &FS);
- ASSERT_TRUE(static_cast<bool>(Style));
- ASSERT_EQ(*Style, getGoogleStyle());
-
- // Specify relative path to a format file.
- ASSERT_TRUE(
- FS.addFile("../../e/explicit.clang-format", 0,
- llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
- Style = getStyle("file:../../e/explicit.clang-format",
- "/e/sub/sub/sub/test.cpp", "LLVM", "", &FS);
- ASSERT_TRUE(static_cast<bool>(Style));
- ASSERT_EQ(*Style, getGoogleStyle());
-
- // Specify path to a format file that does not exist.
- Style = getStyle("file:/e/missing.clang-format", "/e/sub/sub/sub/test.cpp",
- "LLVM", "", &FS);
- ASSERT_FALSE(static_cast<bool>(Style));
- llvm::consumeError(Style.takeError());
-
- // Specify path to a file on the filesystem.
- SmallString<128> FormatFilePath;
- std::error_code ECF = llvm::sys::fs::createTemporaryFile(
- "FormatFileTest", "tpl", FormatFilePath);
- EXPECT_FALSE((bool)ECF);
- llvm::raw_fd_ostream FormatFileTest(FormatFilePath, ECF);
- EXPECT_FALSE((bool)ECF);
- FormatFileTest << "BasedOnStyle: Google\n";
- FormatFileTest.close();
-
- SmallString<128> TestFilePath;
- std::error_code ECT =
- llvm::sys::fs::createTemporaryFile("CodeFileTest", "cc", TestFilePath);
- EXPECT_FALSE((bool)ECT);
- llvm::raw_fd_ostream CodeFileTest(TestFilePath, ECT);
- CodeFileTest << "int i;\n";
- CodeFileTest.close();
-
- std::string format_file_arg = std::string("file:") + FormatFilePath.c_str();
- Style = getStyle(format_file_arg, TestFilePath, "LLVM", "", nullptr);
-
- llvm::sys::fs::remove(FormatFilePath.c_str());
- llvm::sys::fs::remove(TestFilePath.c_str());
- ASSERT_TRUE(static_cast<bool>(Style));
- ASSERT_EQ(*Style, getGoogleStyle());
-}
-
TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
// Column limit is 20.
std::string Code = "Type *a =\n"
More information about the cfe-commits
mailing list