xref: /llvm-project/clang/unittests/Format/ConfigParseTest.cpp (revision 256200732111afd03bb7437564f3a3d77c0ec3f5)
1 //===- unittest/Format/ConfigParseTest.cpp - Config parsing unit tests ----===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "clang/Format/Format.h"
10 
11 #include "llvm/Support/VirtualFileSystem.h"
12 #include "gtest/gtest.h"
13 
14 namespace clang {
15 namespace format {
16 namespace {
17 
18 FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); }
19 
20 #define EXPECT_ALL_STYLES_EQUAL(Styles)                                        \
21   for (size_t i = 1; i < Styles.size(); ++i)                                   \
22   EXPECT_EQ(Styles[0], Styles[i])                                              \
23       << "Style #" << i << " of " << Styles.size() << " differs from Style #0"
24 
25 TEST(ConfigParseTest, GetsPredefinedStyleByName) {
26   SmallVector<FormatStyle, 3> Styles;
27   Styles.resize(3);
28 
29   Styles[0] = getLLVMStyle();
30   EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
31   EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
32   EXPECT_ALL_STYLES_EQUAL(Styles);
33 
34   Styles[0] = getGoogleStyle();
35   EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
36   EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
37   EXPECT_ALL_STYLES_EQUAL(Styles);
38 
39   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
40   EXPECT_TRUE(
41       getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
42   EXPECT_TRUE(
43       getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
44   EXPECT_ALL_STYLES_EQUAL(Styles);
45 
46   Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
47   EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
48   EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
49   EXPECT_ALL_STYLES_EQUAL(Styles);
50 
51   Styles[0] = getMozillaStyle();
52   EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
53   EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
54   EXPECT_ALL_STYLES_EQUAL(Styles);
55 
56   Styles[0] = getWebKitStyle();
57   EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
58   EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
59   EXPECT_ALL_STYLES_EQUAL(Styles);
60 
61   Styles[0] = getGNUStyle();
62   EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
63   EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
64   EXPECT_ALL_STYLES_EQUAL(Styles);
65 
66   Styles[0] = getClangFormatStyle();
67   EXPECT_TRUE(
68       getPredefinedStyle("clang-format", FormatStyle::LK_Cpp, &Styles[1]));
69   EXPECT_TRUE(
70       getPredefinedStyle("Clang-format", FormatStyle::LK_Cpp, &Styles[2]));
71   EXPECT_ALL_STYLES_EQUAL(Styles);
72 
73   EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
74 }
75 
76 TEST(ConfigParseTest, GetsCorrectBasedOnStyle) {
77   SmallVector<FormatStyle, 8> Styles;
78   Styles.resize(2);
79 
80   Styles[0] = getGoogleStyle();
81   Styles[1] = getLLVMStyle();
82   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
83   EXPECT_ALL_STYLES_EQUAL(Styles);
84 
85   Styles.resize(5);
86   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
87   Styles[1] = getLLVMStyle();
88   Styles[1].Language = FormatStyle::LK_JavaScript;
89   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
90 
91   Styles[2] = getLLVMStyle();
92   Styles[2].Language = FormatStyle::LK_JavaScript;
93   EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
94                                   "BasedOnStyle: Google",
95                                   &Styles[2])
96                    .value());
97 
98   Styles[3] = getLLVMStyle();
99   Styles[3].Language = FormatStyle::LK_JavaScript;
100   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
101                                   "Language: JavaScript",
102                                   &Styles[3])
103                    .value());
104 
105   Styles[4] = getLLVMStyle();
106   Styles[4].Language = FormatStyle::LK_JavaScript;
107   EXPECT_EQ(0, parseConfiguration("---\n"
108                                   "BasedOnStyle: LLVM\n"
109                                   "IndentWidth: 123\n"
110                                   "---\n"
111                                   "BasedOnStyle: Google\n"
112                                   "Language: JavaScript",
113                                   &Styles[4])
114                    .value());
115   EXPECT_ALL_STYLES_EQUAL(Styles);
116 }
117 
118 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME)                             \
119   Style.FIELD = false;                                                         \
120   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value());      \
121   EXPECT_TRUE(Style.FIELD);                                                    \
122   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value());     \
123   EXPECT_FALSE(Style.FIELD)
124 
125 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
126 
127 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME)              \
128   Style.STRUCT.FIELD = false;                                                  \
129   EXPECT_EQ(0,                                                                 \
130             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": true", &Style)   \
131                 .value());                                                     \
132   EXPECT_TRUE(Style.STRUCT.FIELD);                                             \
133   EXPECT_EQ(0,                                                                 \
134             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": false", &Style)  \
135                 .value());                                                     \
136   EXPECT_FALSE(Style.STRUCT.FIELD)
137 
138 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD)                                 \
139   CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
140 
141 #define CHECK_PARSE(TEXT, FIELD, VALUE)                                        \
142   EXPECT_NE(VALUE, Style.FIELD) << "Initial value already the same!";          \
143   EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value());                      \
144   EXPECT_EQ(VALUE, Style.FIELD) << "Unexpected value after parsing!"
145 
146 #define CHECK_PARSE_NESTED_VALUE(TEXT, STRUCT, FIELD, VALUE)                   \
147   EXPECT_NE(VALUE, Style.STRUCT.FIELD) << "Initial value already the same!";   \
148   EXPECT_EQ(0, parseConfiguration(#STRUCT ":\n  " TEXT, &Style).value());      \
149   EXPECT_EQ(VALUE, Style.STRUCT.FIELD) << "Unexpected value after parsing!"
150 
151 TEST(ConfigParseTest, ParsesConfigurationBools) {
152   FormatStyle Style = {};
153   Style.Language = FormatStyle::LK_Cpp;
154   CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
155   CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
156   CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
157   CHECK_PARSE_BOOL(AllowShortCompoundRequirementOnASingleLine);
158   CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
159   CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
160   CHECK_PARSE_BOOL(BinPackArguments);
161   CHECK_PARSE_BOOL(BinPackParameters);
162   CHECK_PARSE_BOOL(BreakAdjacentStringLiterals);
163   CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
164   CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
165   CHECK_PARSE_BOOL(BreakStringLiterals);
166   CHECK_PARSE_BOOL(CompactNamespaces);
167   CHECK_PARSE_BOOL(DerivePointerAlignment);
168   CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
169   CHECK_PARSE_BOOL(DisableFormat);
170   CHECK_PARSE_BOOL(IndentAccessModifiers);
171   CHECK_PARSE_BOOL(IndentCaseLabels);
172   CHECK_PARSE_BOOL(IndentCaseBlocks);
173   CHECK_PARSE_BOOL(IndentGotoLabels);
174   CHECK_PARSE_BOOL_FIELD(IndentRequiresClause, "IndentRequires");
175   CHECK_PARSE_BOOL(IndentRequiresClause);
176   CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
177   CHECK_PARSE_BOOL(InsertBraces);
178   CHECK_PARSE_BOOL(InsertNewlineAtEOF);
179   CHECK_PARSE_BOOL(KeepEmptyLinesAtEOF);
180   CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
181   CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
182   CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
183   CHECK_PARSE_BOOL(Cpp11BracedListStyle);
184   CHECK_PARSE_BOOL(ReflowComments);
185   CHECK_PARSE_BOOL(RemoveBracesLLVM);
186   CHECK_PARSE_BOOL(RemoveSemicolon);
187   CHECK_PARSE_BOOL(SkipMacroDefinitionBody);
188   CHECK_PARSE_BOOL(SpacesInSquareBrackets);
189   CHECK_PARSE_BOOL(SpaceInEmptyBlock);
190   CHECK_PARSE_BOOL(SpacesInContainerLiterals);
191   CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
192   CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
193   CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
194   CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
195   CHECK_PARSE_BOOL(SpaceBeforeCaseColon);
196   CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
197   CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
198   CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
199   CHECK_PARSE_BOOL(SpaceBeforeJsonColon);
200   CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon);
201   CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets);
202   CHECK_PARSE_BOOL(VerilogBreakBetweenInstancePorts);
203 
204   CHECK_PARSE_NESTED_BOOL(AlignConsecutiveShortCaseStatements, Enabled);
205   CHECK_PARSE_NESTED_BOOL(AlignConsecutiveShortCaseStatements,
206                           AcrossEmptyLines);
207   CHECK_PARSE_NESTED_BOOL(AlignConsecutiveShortCaseStatements, AcrossComments);
208   CHECK_PARSE_NESTED_BOOL(AlignConsecutiveShortCaseStatements, AlignCaseColons);
209   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel);
210   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
211   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
212   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
213   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
214   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
215   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
216   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
217   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
218   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
219   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
220   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody);
221   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeWhile);
222   CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
223   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
224   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
225   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
226   CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterControlStatements);
227   CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterForeachMacros);
228   CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions,
229                           AfterFunctionDeclarationName);
230   CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions,
231                           AfterFunctionDefinitionName);
232   CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterIfMacros);
233   CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterOverloadedOperator);
234   CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterPlacementOperator);
235   CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, BeforeNonEmptyParentheses);
236   CHECK_PARSE_NESTED_BOOL(SpacesInParensOptions, InCStyleCasts);
237   CHECK_PARSE_NESTED_BOOL(SpacesInParensOptions, InConditionalStatements);
238   CHECK_PARSE_NESTED_BOOL(SpacesInParensOptions, InEmptyParentheses);
239   CHECK_PARSE_NESTED_BOOL(SpacesInParensOptions, Other);
240 }
241 
242 #undef CHECK_PARSE_BOOL
243 
244 TEST(ConfigParseTest, ParsesConfiguration) {
245   FormatStyle Style = {};
246   Style.Language = FormatStyle::LK_Cpp;
247   CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
248   CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
249               ConstructorInitializerIndentWidth, 1234u);
250   CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
251   CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
252   CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
253   CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u);
254   CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
255               PenaltyBreakBeforeFirstCallParameter, 1234u);
256   CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234",
257               PenaltyBreakTemplateDeclaration, 1234u);
258   CHECK_PARSE("PenaltyBreakOpenParenthesis: 1234", PenaltyBreakOpenParenthesis,
259               1234u);
260   CHECK_PARSE("PenaltyBreakScopeResolution: 1234", PenaltyBreakScopeResolution,
261               1234u);
262   CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
263   CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
264               PenaltyReturnTypeOnItsOwnLine, 1234u);
265   CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
266               SpacesBeforeTrailingComments, 1234u);
267   CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
268   CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
269   CHECK_PARSE("BracedInitializerIndentWidth: 34", BracedInitializerIndentWidth,
270               34);
271   CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
272 
273   Style.QualifierAlignment = FormatStyle::QAS_Right;
274   CHECK_PARSE("QualifierAlignment: Leave", QualifierAlignment,
275               FormatStyle::QAS_Leave);
276   CHECK_PARSE("QualifierAlignment: Right", QualifierAlignment,
277               FormatStyle::QAS_Right);
278   CHECK_PARSE("QualifierAlignment: Left", QualifierAlignment,
279               FormatStyle::QAS_Left);
280   CHECK_PARSE("QualifierAlignment: Custom", QualifierAlignment,
281               FormatStyle::QAS_Custom);
282 
283   Style.QualifierOrder.clear();
284   CHECK_PARSE("QualifierOrder: [ const, volatile, type ]", QualifierOrder,
285               std::vector<std::string>({"const", "volatile", "type"}));
286   Style.QualifierOrder.clear();
287   CHECK_PARSE("QualifierOrder: [const, type]", QualifierOrder,
288               std::vector<std::string>({"const", "type"}));
289   Style.QualifierOrder.clear();
290   CHECK_PARSE("QualifierOrder: [volatile, type]", QualifierOrder,
291               std::vector<std::string>({"volatile", "type"}));
292 
293 #define CHECK_ALIGN_CONSECUTIVE(FIELD)                                         \
294   do {                                                                         \
295     Style.FIELD.Enabled = true;                                                \
296     CHECK_PARSE(                                                               \
297         #FIELD ": None", FIELD,                                                \
298         FormatStyle::AlignConsecutiveStyle(                                    \
299             {/*Enabled=*/false, /*AcrossEmptyLines=*/false,                    \
300              /*AcrossComments=*/false, /*AlignCompound=*/false,                \
301              /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));        \
302     CHECK_PARSE(                                                               \
303         #FIELD ": Consecutive", FIELD,                                         \
304         FormatStyle::AlignConsecutiveStyle(                                    \
305             {/*Enabled=*/true, /*AcrossEmptyLines=*/false,                     \
306              /*AcrossComments=*/false, /*AlignCompound=*/false,                \
307              /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));        \
308     CHECK_PARSE(                                                               \
309         #FIELD ": AcrossEmptyLines", FIELD,                                    \
310         FormatStyle::AlignConsecutiveStyle(                                    \
311             {/*Enabled=*/true, /*AcrossEmptyLines=*/true,                      \
312              /*AcrossComments=*/false, /*AlignCompound=*/false,                \
313              /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));        \
314     CHECK_PARSE(                                                               \
315         #FIELD ": AcrossEmptyLinesAndComments", FIELD,                         \
316         FormatStyle::AlignConsecutiveStyle(                                    \
317             {/*Enabled=*/true, /*AcrossEmptyLines=*/true,                      \
318              /*AcrossComments=*/true, /*AlignCompound=*/false,                 \
319              /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));        \
320     /* For backwards compability, false / true should still parse */           \
321     CHECK_PARSE(                                                               \
322         #FIELD ": false", FIELD,                                               \
323         FormatStyle::AlignConsecutiveStyle(                                    \
324             {/*Enabled=*/false, /*AcrossEmptyLines=*/false,                    \
325              /*AcrossComments=*/false, /*AlignCompound=*/false,                \
326              /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));        \
327     CHECK_PARSE(                                                               \
328         #FIELD ": true", FIELD,                                                \
329         FormatStyle::AlignConsecutiveStyle(                                    \
330             {/*Enabled=*/true, /*AcrossEmptyLines=*/false,                     \
331              /*AcrossComments=*/false, /*AlignCompound=*/false,                \
332              /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));        \
333                                                                                \
334     CHECK_PARSE_NESTED_BOOL(FIELD, Enabled);                                   \
335     CHECK_PARSE_NESTED_BOOL(FIELD, AcrossEmptyLines);                          \
336     CHECK_PARSE_NESTED_BOOL(FIELD, AcrossComments);                            \
337     CHECK_PARSE_NESTED_BOOL(FIELD, AlignCompound);                             \
338     CHECK_PARSE_NESTED_BOOL(FIELD, PadOperators);                              \
339   } while (false)
340 
341   CHECK_ALIGN_CONSECUTIVE(AlignConsecutiveAssignments);
342   CHECK_ALIGN_CONSECUTIVE(AlignConsecutiveBitFields);
343   CHECK_ALIGN_CONSECUTIVE(AlignConsecutiveMacros);
344   CHECK_ALIGN_CONSECUTIVE(AlignConsecutiveDeclarations);
345 
346 #undef CHECK_ALIGN_CONSECUTIVE
347 
348   Style.PointerAlignment = FormatStyle::PAS_Middle;
349   CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
350               FormatStyle::PAS_Left);
351   CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
352               FormatStyle::PAS_Right);
353   CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
354               FormatStyle::PAS_Middle);
355   Style.ReferenceAlignment = FormatStyle::RAS_Middle;
356   CHECK_PARSE("ReferenceAlignment: Pointer", ReferenceAlignment,
357               FormatStyle::RAS_Pointer);
358   CHECK_PARSE("ReferenceAlignment: Left", ReferenceAlignment,
359               FormatStyle::RAS_Left);
360   CHECK_PARSE("ReferenceAlignment: Right", ReferenceAlignment,
361               FormatStyle::RAS_Right);
362   CHECK_PARSE("ReferenceAlignment: Middle", ReferenceAlignment,
363               FormatStyle::RAS_Middle);
364   // For backward compatibility:
365   CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
366               FormatStyle::PAS_Left);
367   CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
368               FormatStyle::PAS_Right);
369   CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
370               FormatStyle::PAS_Middle);
371 
372   Style.Standard = FormatStyle::LS_Auto;
373   CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03);
374   CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11);
375   CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14);
376   CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17);
377   CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20);
378   CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
379   CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest);
380   // Legacy aliases:
381   CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
382   CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest);
383   CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
384   CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
385 
386   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
387   CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
388               BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
389   CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
390               FormatStyle::BOS_None);
391   CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
392               FormatStyle::BOS_All);
393   // For backward compatibility:
394   CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
395               FormatStyle::BOS_None);
396   CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
397               FormatStyle::BOS_All);
398 
399   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
400   CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
401               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
402   CHECK_PARSE("BreakConstructorInitializers: AfterColon",
403               BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
404   CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
405               BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
406   // For backward compatibility:
407   CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
408               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
409 
410   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
411   CHECK_PARSE("BreakInheritanceList: AfterComma", BreakInheritanceList,
412               FormatStyle::BILS_AfterComma);
413   CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList,
414               FormatStyle::BILS_BeforeComma);
415   CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList,
416               FormatStyle::BILS_AfterColon);
417   CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList,
418               FormatStyle::BILS_BeforeColon);
419   // For backward compatibility:
420   CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
421               FormatStyle::BILS_BeforeComma);
422 
423   Style.PackConstructorInitializers = FormatStyle::PCIS_BinPack;
424   CHECK_PARSE("PackConstructorInitializers: Never", PackConstructorInitializers,
425               FormatStyle::PCIS_Never);
426   CHECK_PARSE("PackConstructorInitializers: BinPack",
427               PackConstructorInitializers, FormatStyle::PCIS_BinPack);
428   CHECK_PARSE("PackConstructorInitializers: CurrentLine",
429               PackConstructorInitializers, FormatStyle::PCIS_CurrentLine);
430   CHECK_PARSE("PackConstructorInitializers: NextLine",
431               PackConstructorInitializers, FormatStyle::PCIS_NextLine);
432   CHECK_PARSE("PackConstructorInitializers: NextLineOnly",
433               PackConstructorInitializers, FormatStyle::PCIS_NextLineOnly);
434   // For backward compatibility:
435   CHECK_PARSE("BasedOnStyle: Google\n"
436               "ConstructorInitializerAllOnOneLineOrOnePerLine: true\n"
437               "AllowAllConstructorInitializersOnNextLine: false",
438               PackConstructorInitializers, FormatStyle::PCIS_CurrentLine);
439   Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine;
440   CHECK_PARSE("BasedOnStyle: Google\n"
441               "ConstructorInitializerAllOnOneLineOrOnePerLine: false",
442               PackConstructorInitializers, FormatStyle::PCIS_BinPack);
443   CHECK_PARSE("ConstructorInitializerAllOnOneLineOrOnePerLine: true\n"
444               "AllowAllConstructorInitializersOnNextLine: true",
445               PackConstructorInitializers, FormatStyle::PCIS_NextLine);
446   Style.PackConstructorInitializers = FormatStyle::PCIS_BinPack;
447   CHECK_PARSE("ConstructorInitializerAllOnOneLineOrOnePerLine: true\n"
448               "AllowAllConstructorInitializersOnNextLine: false",
449               PackConstructorInitializers, FormatStyle::PCIS_CurrentLine);
450 
451   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_LogicalBlock;
452   CHECK_PARSE("EmptyLineBeforeAccessModifier: Never",
453               EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_Never);
454   CHECK_PARSE("EmptyLineBeforeAccessModifier: Leave",
455               EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_Leave);
456   CHECK_PARSE("EmptyLineBeforeAccessModifier: LogicalBlock",
457               EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_LogicalBlock);
458   CHECK_PARSE("EmptyLineBeforeAccessModifier: Always",
459               EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_Always);
460 
461   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
462   CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
463               FormatStyle::BAS_Align);
464   CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
465               FormatStyle::BAS_DontAlign);
466   CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
467               FormatStyle::BAS_AlwaysBreak);
468   CHECK_PARSE("AlignAfterOpenBracket: BlockIndent", AlignAfterOpenBracket,
469               FormatStyle::BAS_BlockIndent);
470   // For backward compatibility:
471   CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
472               FormatStyle::BAS_DontAlign);
473   CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
474               FormatStyle::BAS_Align);
475 
476   Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
477   CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
478               FormatStyle::ENAS_DontAlign);
479   CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
480               FormatStyle::ENAS_Left);
481   CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
482               FormatStyle::ENAS_Right);
483   // For backward compatibility:
484   CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
485               FormatStyle::ENAS_Left);
486   CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
487               FormatStyle::ENAS_Right);
488 
489   Style.AlignOperands = FormatStyle::OAS_Align;
490   CHECK_PARSE("AlignOperands: DontAlign", AlignOperands,
491               FormatStyle::OAS_DontAlign);
492   CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align);
493   CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands,
494               FormatStyle::OAS_AlignAfterOperator);
495   // For backward compatibility:
496   CHECK_PARSE("AlignOperands: false", AlignOperands,
497               FormatStyle::OAS_DontAlign);
498   CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align);
499 
500   CHECK_PARSE("AlignTrailingComments: Leave", AlignTrailingComments,
501               FormatStyle::TrailingCommentsAlignmentStyle(
502                   {FormatStyle::TCAS_Leave, 0}));
503   CHECK_PARSE("AlignTrailingComments: Always", AlignTrailingComments,
504               FormatStyle::TrailingCommentsAlignmentStyle(
505                   {FormatStyle::TCAS_Always, 0}));
506   CHECK_PARSE("AlignTrailingComments: Never", AlignTrailingComments,
507               FormatStyle::TrailingCommentsAlignmentStyle(
508                   {FormatStyle::TCAS_Never, 0}));
509   // For backwards compatibility
510   CHECK_PARSE("AlignTrailingComments: true", AlignTrailingComments,
511               FormatStyle::TrailingCommentsAlignmentStyle(
512                   {FormatStyle::TCAS_Always, 0}));
513   CHECK_PARSE("AlignTrailingComments: false", AlignTrailingComments,
514               FormatStyle::TrailingCommentsAlignmentStyle(
515                   {FormatStyle::TCAS_Never, 0}));
516   CHECK_PARSE_NESTED_VALUE("Kind: Always", AlignTrailingComments, Kind,
517                            FormatStyle::TCAS_Always);
518   CHECK_PARSE_NESTED_VALUE("Kind: Never", AlignTrailingComments, Kind,
519                            FormatStyle::TCAS_Never);
520   CHECK_PARSE_NESTED_VALUE("Kind: Leave", AlignTrailingComments, Kind,
521                            FormatStyle::TCAS_Leave);
522   CHECK_PARSE_NESTED_VALUE("OverEmptyLines: 1234", AlignTrailingComments,
523                            OverEmptyLines, 1234u);
524 
525   Style.UseTab = FormatStyle::UT_ForIndentation;
526   CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
527   CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
528   CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
529   CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
530               FormatStyle::UT_ForContinuationAndIndentation);
531   CHECK_PARSE("UseTab: AlignWithSpaces", UseTab,
532               FormatStyle::UT_AlignWithSpaces);
533   // For backward compatibility:
534   CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
535   CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
536 
537   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
538   CHECK_PARSE("AllowShortBlocksOnASingleLine: Never",
539               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
540   CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty",
541               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty);
542   CHECK_PARSE("AllowShortBlocksOnASingleLine: Always",
543               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
544   // For backward compatibility:
545   CHECK_PARSE("AllowShortBlocksOnASingleLine: false",
546               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
547   CHECK_PARSE("AllowShortBlocksOnASingleLine: true",
548               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
549 
550   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
551   CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
552               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
553   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
554               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
555   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
556               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
557   CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
558               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
559   // For backward compatibility:
560   CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
561               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
562   CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
563               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
564 
565   Style.AllowShortLambdasOnASingleLine = FormatStyle::SLS_All;
566   CHECK_PARSE("AllowShortLambdasOnASingleLine: None",
567               AllowShortLambdasOnASingleLine, FormatStyle::SLS_None);
568   CHECK_PARSE("AllowShortLambdasOnASingleLine: Empty",
569               AllowShortLambdasOnASingleLine, FormatStyle::SLS_Empty);
570   CHECK_PARSE("AllowShortLambdasOnASingleLine: Inline",
571               AllowShortLambdasOnASingleLine, FormatStyle::SLS_Inline);
572   CHECK_PARSE("AllowShortLambdasOnASingleLine: All",
573               AllowShortLambdasOnASingleLine, FormatStyle::SLS_All);
574   // For backward compatibility:
575   CHECK_PARSE("AllowShortLambdasOnASingleLine: false",
576               AllowShortLambdasOnASingleLine, FormatStyle::SLS_None);
577   CHECK_PARSE("AllowShortLambdasOnASingleLine: true",
578               AllowShortLambdasOnASingleLine, FormatStyle::SLS_All);
579 
580   Style.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Both;
581   CHECK_PARSE("SpaceAroundPointerQualifiers: Default",
582               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Default);
583   CHECK_PARSE("SpaceAroundPointerQualifiers: Before",
584               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Before);
585   CHECK_PARSE("SpaceAroundPointerQualifiers: After",
586               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_After);
587   CHECK_PARSE("SpaceAroundPointerQualifiers: Both",
588               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Both);
589 
590   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
591   CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
592               FormatStyle::SBPO_Never);
593   CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
594               FormatStyle::SBPO_Always);
595   CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
596               FormatStyle::SBPO_ControlStatements);
597   CHECK_PARSE("SpaceBeforeParens: ControlStatementsExceptControlMacros",
598               SpaceBeforeParens,
599               FormatStyle::SBPO_ControlStatementsExceptControlMacros);
600   CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens,
601               FormatStyle::SBPO_NonEmptyParentheses);
602   CHECK_PARSE("SpaceBeforeParens: Custom", SpaceBeforeParens,
603               FormatStyle::SBPO_Custom);
604   // For backward compatibility:
605   CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
606               FormatStyle::SBPO_Never);
607   CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
608               FormatStyle::SBPO_ControlStatements);
609   CHECK_PARSE("SpaceBeforeParens: ControlStatementsExceptForEachMacros",
610               SpaceBeforeParens,
611               FormatStyle::SBPO_ControlStatementsExceptControlMacros);
612 
613   // For backward compatibility:
614   Style.SpacesInParens = FormatStyle::SIPO_Never;
615   Style.SpacesInParensOptions = {};
616   CHECK_PARSE("SpacesInParentheses: true", SpacesInParens,
617               FormatStyle::SIPO_Custom);
618   Style.SpacesInParens = FormatStyle::SIPO_Never;
619   Style.SpacesInParensOptions = {};
620   CHECK_PARSE("SpacesInParentheses: true", SpacesInParensOptions,
621               FormatStyle::SpacesInParensCustom(true, false, false, true));
622   Style.SpacesInParens = FormatStyle::SIPO_Never;
623   Style.SpacesInParensOptions = {};
624   CHECK_PARSE("SpacesInConditionalStatement: true", SpacesInParensOptions,
625               FormatStyle::SpacesInParensCustom(true, false, false, false));
626   Style.SpacesInParens = FormatStyle::SIPO_Never;
627   Style.SpacesInParensOptions = {};
628   CHECK_PARSE("SpacesInCStyleCastParentheses: true", SpacesInParensOptions,
629               FormatStyle::SpacesInParensCustom(false, true, false, false));
630   Style.SpacesInParens = FormatStyle::SIPO_Never;
631   Style.SpacesInParensOptions = {};
632   CHECK_PARSE("SpaceInEmptyParentheses: true", SpacesInParensOptions,
633               FormatStyle::SpacesInParensCustom(false, false, true, false));
634   Style.SpacesInParens = FormatStyle::SIPO_Never;
635   Style.SpacesInParensOptions = {};
636 
637   Style.ColumnLimit = 123;
638   FormatStyle BaseStyle = getLLVMStyle();
639   CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
640   CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
641 
642   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
643   CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
644               FormatStyle::BS_Attach);
645   CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
646               FormatStyle::BS_Linux);
647   CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
648               FormatStyle::BS_Mozilla);
649   CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
650               FormatStyle::BS_Stroustrup);
651   CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
652               FormatStyle::BS_Allman);
653   CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces,
654               FormatStyle::BS_Whitesmiths);
655   CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
656   CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
657               FormatStyle::BS_WebKit);
658   CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
659               FormatStyle::BS_Custom);
660 
661   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
662   CHECK_PARSE("BraceWrapping:\n"
663               "  AfterControlStatement: MultiLine",
664               BraceWrapping.AfterControlStatement,
665               FormatStyle::BWACS_MultiLine);
666   CHECK_PARSE("BraceWrapping:\n"
667               "  AfterControlStatement: Always",
668               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
669   CHECK_PARSE("BraceWrapping:\n"
670               "  AfterControlStatement: Never",
671               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
672   // For backward compatibility:
673   CHECK_PARSE("BraceWrapping:\n"
674               "  AfterControlStatement: true",
675               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
676   CHECK_PARSE("BraceWrapping:\n"
677               "  AfterControlStatement: false",
678               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
679 
680   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
681   CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
682               FormatStyle::RTBS_None);
683   CHECK_PARSE("AlwaysBreakAfterReturnType: Automatic",
684               AlwaysBreakAfterReturnType, FormatStyle::RTBS_Automatic);
685   CHECK_PARSE("AlwaysBreakAfterReturnType: ExceptShortType",
686               AlwaysBreakAfterReturnType, FormatStyle::RTBS_ExceptShortType);
687   CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
688               FormatStyle::RTBS_All);
689   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
690               AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
691   CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
692               AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
693   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
694               AlwaysBreakAfterReturnType,
695               FormatStyle::RTBS_TopLevelDefinitions);
696 
697   Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
698   CHECK_PARSE("AlwaysBreakTemplateDeclarations: No",
699               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No);
700   CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine",
701               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
702   CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes",
703               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
704   CHECK_PARSE("AlwaysBreakTemplateDeclarations: false",
705               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
706   CHECK_PARSE("AlwaysBreakTemplateDeclarations: true",
707               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
708 
709   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
710   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
711               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
712   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
713               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
714   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
715               AlwaysBreakAfterDefinitionReturnType,
716               FormatStyle::DRTBS_TopLevel);
717 
718   Style.NamespaceIndentation = FormatStyle::NI_All;
719   CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
720               FormatStyle::NI_None);
721   CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
722               FormatStyle::NI_Inner);
723   CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
724               FormatStyle::NI_All);
725 
726   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_OnlyFirstIf;
727   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never",
728               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
729   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse",
730               AllowShortIfStatementsOnASingleLine,
731               FormatStyle::SIS_WithoutElse);
732   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: OnlyFirstIf",
733               AllowShortIfStatementsOnASingleLine,
734               FormatStyle::SIS_OnlyFirstIf);
735   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: AllIfsAndElse",
736               AllowShortIfStatementsOnASingleLine,
737               FormatStyle::SIS_AllIfsAndElse);
738   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always",
739               AllowShortIfStatementsOnASingleLine,
740               FormatStyle::SIS_OnlyFirstIf);
741   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false",
742               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
743   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true",
744               AllowShortIfStatementsOnASingleLine,
745               FormatStyle::SIS_WithoutElse);
746 
747   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
748   CHECK_PARSE("IndentExternBlock: AfterExternBlock", IndentExternBlock,
749               FormatStyle::IEBS_AfterExternBlock);
750   CHECK_PARSE("IndentExternBlock: Indent", IndentExternBlock,
751               FormatStyle::IEBS_Indent);
752   CHECK_PARSE("IndentExternBlock: NoIndent", IndentExternBlock,
753               FormatStyle::IEBS_NoIndent);
754   CHECK_PARSE("IndentExternBlock: true", IndentExternBlock,
755               FormatStyle::IEBS_Indent);
756   CHECK_PARSE("IndentExternBlock: false", IndentExternBlock,
757               FormatStyle::IEBS_NoIndent);
758 
759   Style.BitFieldColonSpacing = FormatStyle::BFCS_None;
760   CHECK_PARSE("BitFieldColonSpacing: Both", BitFieldColonSpacing,
761               FormatStyle::BFCS_Both);
762   CHECK_PARSE("BitFieldColonSpacing: None", BitFieldColonSpacing,
763               FormatStyle::BFCS_None);
764   CHECK_PARSE("BitFieldColonSpacing: Before", BitFieldColonSpacing,
765               FormatStyle::BFCS_Before);
766   CHECK_PARSE("BitFieldColonSpacing: After", BitFieldColonSpacing,
767               FormatStyle::BFCS_After);
768 
769   Style.SortJavaStaticImport = FormatStyle::SJSIO_Before;
770   CHECK_PARSE("SortJavaStaticImport: After", SortJavaStaticImport,
771               FormatStyle::SJSIO_After);
772   CHECK_PARSE("SortJavaStaticImport: Before", SortJavaStaticImport,
773               FormatStyle::SJSIO_Before);
774 
775   Style.SortUsingDeclarations = FormatStyle::SUD_LexicographicNumeric;
776   CHECK_PARSE("SortUsingDeclarations: Never", SortUsingDeclarations,
777               FormatStyle::SUD_Never);
778   CHECK_PARSE("SortUsingDeclarations: Lexicographic", SortUsingDeclarations,
779               FormatStyle::SUD_Lexicographic);
780   CHECK_PARSE("SortUsingDeclarations: LexicographicNumeric",
781               SortUsingDeclarations, FormatStyle::SUD_LexicographicNumeric);
782   // For backward compatibility:
783   CHECK_PARSE("SortUsingDeclarations: false", SortUsingDeclarations,
784               FormatStyle::SUD_Never);
785   CHECK_PARSE("SortUsingDeclarations: true", SortUsingDeclarations,
786               FormatStyle::SUD_LexicographicNumeric);
787 
788   // FIXME: This is required because parsing a configuration simply overwrites
789   // the first N elements of the list instead of resetting it.
790   Style.ForEachMacros.clear();
791   std::vector<std::string> BoostForeach;
792   BoostForeach.push_back("BOOST_FOREACH");
793   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
794   std::vector<std::string> BoostAndQForeach;
795   BoostAndQForeach.push_back("BOOST_FOREACH");
796   BoostAndQForeach.push_back("Q_FOREACH");
797   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
798               BoostAndQForeach);
799 
800   Style.IfMacros.clear();
801   std::vector<std::string> CustomIfs;
802   CustomIfs.push_back("MYIF");
803   CHECK_PARSE("IfMacros: [MYIF]", IfMacros, CustomIfs);
804 
805   Style.AttributeMacros.clear();
806   CHECK_PARSE("BasedOnStyle: LLVM", AttributeMacros,
807               std::vector<std::string>{"__capability"});
808   CHECK_PARSE("AttributeMacros: [attr1, attr2]", AttributeMacros,
809               std::vector<std::string>({"attr1", "attr2"}));
810 
811   Style.StatementAttributeLikeMacros.clear();
812   CHECK_PARSE("StatementAttributeLikeMacros: [emit,Q_EMIT]",
813               StatementAttributeLikeMacros,
814               std::vector<std::string>({"emit", "Q_EMIT"}));
815 
816   Style.StatementMacros.clear();
817   CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
818               std::vector<std::string>{"QUNUSED"});
819   CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
820               std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
821 
822   Style.NamespaceMacros.clear();
823   CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
824               std::vector<std::string>{"TESTSUITE"});
825   CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
826               std::vector<std::string>({"TESTSUITE", "SUITE"}));
827 
828   Style.WhitespaceSensitiveMacros.clear();
829   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE]",
830               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
831   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE, ASSERT]",
832               WhitespaceSensitiveMacros,
833               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
834   Style.WhitespaceSensitiveMacros.clear();
835   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE']",
836               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
837   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE', 'ASSERT']",
838               WhitespaceSensitiveMacros,
839               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
840 
841   Style.IncludeStyle.IncludeCategories.clear();
842   std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
843       {"abc/.*", 2, 0, false}, {".*", 1, 0, true}};
844   CHECK_PARSE("IncludeCategories:\n"
845               "  - Regex: abc/.*\n"
846               "    Priority: 2\n"
847               "  - Regex: .*\n"
848               "    Priority: 1\n"
849               "    CaseSensitive: true",
850               IncludeStyle.IncludeCategories, ExpectedCategories);
851   CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
852               "abc$");
853   CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'",
854               IncludeStyle.IncludeIsMainSourceRegex, "abc$");
855 
856   Style.SortIncludes = FormatStyle::SI_Never;
857   CHECK_PARSE("SortIncludes: true", SortIncludes,
858               FormatStyle::SI_CaseSensitive);
859   CHECK_PARSE("SortIncludes: false", SortIncludes, FormatStyle::SI_Never);
860   CHECK_PARSE("SortIncludes: CaseInsensitive", SortIncludes,
861               FormatStyle::SI_CaseInsensitive);
862   CHECK_PARSE("SortIncludes: CaseSensitive", SortIncludes,
863               FormatStyle::SI_CaseSensitive);
864   CHECK_PARSE("SortIncludes: Never", SortIncludes, FormatStyle::SI_Never);
865 
866   Style.RawStringFormats.clear();
867   std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
868       {
869           FormatStyle::LK_TextProto,
870           {"pb", "proto"},
871           {"PARSE_TEXT_PROTO"},
872           /*CanonicalDelimiter=*/"",
873           "llvm",
874       },
875       {
876           FormatStyle::LK_Cpp,
877           {"cc", "cpp"},
878           {"C_CODEBLOCK", "CPPEVAL"},
879           /*CanonicalDelimiter=*/"cc",
880           /*BasedOnStyle=*/"",
881       },
882   };
883 
884   CHECK_PARSE("RawStringFormats:\n"
885               "  - Language: TextProto\n"
886               "    Delimiters:\n"
887               "      - 'pb'\n"
888               "      - 'proto'\n"
889               "    EnclosingFunctions:\n"
890               "      - 'PARSE_TEXT_PROTO'\n"
891               "    BasedOnStyle: llvm\n"
892               "  - Language: Cpp\n"
893               "    Delimiters:\n"
894               "      - 'cc'\n"
895               "      - 'cpp'\n"
896               "    EnclosingFunctions:\n"
897               "      - 'C_CODEBLOCK'\n"
898               "      - 'CPPEVAL'\n"
899               "    CanonicalDelimiter: 'cc'",
900               RawStringFormats, ExpectedRawStringFormats);
901 
902   CHECK_PARSE("SpacesInLineCommentPrefix:\n"
903               "  Minimum: 0\n"
904               "  Maximum: 0",
905               SpacesInLineCommentPrefix.Minimum, 0u);
906   EXPECT_EQ(Style.SpacesInLineCommentPrefix.Maximum, 0u);
907   Style.SpacesInLineCommentPrefix.Minimum = 1;
908   CHECK_PARSE("SpacesInLineCommentPrefix:\n"
909               "  Minimum: 2",
910               SpacesInLineCommentPrefix.Minimum, 0u);
911   CHECK_PARSE("SpacesInLineCommentPrefix:\n"
912               "  Maximum: -1",
913               SpacesInLineCommentPrefix.Maximum, -1u);
914   CHECK_PARSE("SpacesInLineCommentPrefix:\n"
915               "  Minimum: 2",
916               SpacesInLineCommentPrefix.Minimum, 2u);
917   CHECK_PARSE("SpacesInLineCommentPrefix:\n"
918               "  Maximum: 1",
919               SpacesInLineCommentPrefix.Maximum, 1u);
920   EXPECT_EQ(Style.SpacesInLineCommentPrefix.Minimum, 1u);
921 
922   Style.SpacesInAngles = FormatStyle::SIAS_Always;
923   CHECK_PARSE("SpacesInAngles: Never", SpacesInAngles, FormatStyle::SIAS_Never);
924   CHECK_PARSE("SpacesInAngles: Always", SpacesInAngles,
925               FormatStyle::SIAS_Always);
926   CHECK_PARSE("SpacesInAngles: Leave", SpacesInAngles, FormatStyle::SIAS_Leave);
927   // For backward compatibility:
928   CHECK_PARSE("SpacesInAngles: false", SpacesInAngles, FormatStyle::SIAS_Never);
929   CHECK_PARSE("SpacesInAngles: true", SpacesInAngles, FormatStyle::SIAS_Always);
930 
931   CHECK_PARSE("RequiresClausePosition: WithPreceding", RequiresClausePosition,
932               FormatStyle::RCPS_WithPreceding);
933   CHECK_PARSE("RequiresClausePosition: WithFollowing", RequiresClausePosition,
934               FormatStyle::RCPS_WithFollowing);
935   CHECK_PARSE("RequiresClausePosition: SingleLine", RequiresClausePosition,
936               FormatStyle::RCPS_SingleLine);
937   CHECK_PARSE("RequiresClausePosition: OwnLine", RequiresClausePosition,
938               FormatStyle::RCPS_OwnLine);
939 
940   CHECK_PARSE("BreakBeforeConceptDeclarations: Never",
941               BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Never);
942   CHECK_PARSE("BreakBeforeConceptDeclarations: Always",
943               BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Always);
944   CHECK_PARSE("BreakBeforeConceptDeclarations: Allowed",
945               BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Allowed);
946   // For backward compatibility:
947   CHECK_PARSE("BreakBeforeConceptDeclarations: true",
948               BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Always);
949   CHECK_PARSE("BreakBeforeConceptDeclarations: false",
950               BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Allowed);
951 
952   CHECK_PARSE("BreakAfterAttributes: Always", BreakAfterAttributes,
953               FormatStyle::ABS_Always);
954   CHECK_PARSE("BreakAfterAttributes: Leave", BreakAfterAttributes,
955               FormatStyle::ABS_Leave);
956   CHECK_PARSE("BreakAfterAttributes: Never", BreakAfterAttributes,
957               FormatStyle::ABS_Never);
958 
959   const auto DefaultLineEnding = FormatStyle::LE_DeriveLF;
960   CHECK_PARSE("LineEnding: LF", LineEnding, FormatStyle::LE_LF);
961   CHECK_PARSE("LineEnding: CRLF", LineEnding, FormatStyle::LE_CRLF);
962   CHECK_PARSE("LineEnding: DeriveCRLF", LineEnding, FormatStyle::LE_DeriveCRLF);
963   CHECK_PARSE("LineEnding: DeriveLF", LineEnding, DefaultLineEnding);
964   // For backward compatibility:
965   CHECK_PARSE("DeriveLineEnding: false", LineEnding, FormatStyle::LE_LF);
966   Style.LineEnding = DefaultLineEnding;
967   CHECK_PARSE("DeriveLineEnding: false\n"
968               "UseCRLF: true",
969               LineEnding, FormatStyle::LE_CRLF);
970   Style.LineEnding = DefaultLineEnding;
971   CHECK_PARSE("UseCRLF: true", LineEnding, FormatStyle::LE_DeriveCRLF);
972 
973   CHECK_PARSE("RemoveParentheses: MultipleParentheses", RemoveParentheses,
974               FormatStyle::RPS_MultipleParentheses);
975   CHECK_PARSE("RemoveParentheses: ReturnStatement", RemoveParentheses,
976               FormatStyle::RPS_ReturnStatement);
977   CHECK_PARSE("RemoveParentheses: Leave", RemoveParentheses,
978               FormatStyle::RPS_Leave);
979 
980   CHECK_PARSE("AllowBreakBeforeNoexceptSpecifier: Always",
981               AllowBreakBeforeNoexceptSpecifier, FormatStyle::BBNSS_Always);
982   CHECK_PARSE("AllowBreakBeforeNoexceptSpecifier: OnlyWithParen",
983               AllowBreakBeforeNoexceptSpecifier,
984               FormatStyle::BBNSS_OnlyWithParen);
985   CHECK_PARSE("AllowBreakBeforeNoexceptSpecifier: Never",
986               AllowBreakBeforeNoexceptSpecifier, FormatStyle::BBNSS_Never);
987 
988   Style.SeparateDefinitionBlocks = FormatStyle::SDS_Never;
989   CHECK_PARSE("SeparateDefinitionBlocks: Always", SeparateDefinitionBlocks,
990               FormatStyle::SDS_Always);
991   CHECK_PARSE("SeparateDefinitionBlocks: Leave", SeparateDefinitionBlocks,
992               FormatStyle::SDS_Leave);
993   CHECK_PARSE("SeparateDefinitionBlocks: Never", SeparateDefinitionBlocks,
994               FormatStyle::SDS_Never);
995 }
996 
997 TEST(ConfigParseTest, ParsesConfigurationWithLanguages) {
998   FormatStyle Style = {};
999   Style.Language = FormatStyle::LK_Cpp;
1000   CHECK_PARSE("Language: Cpp\n"
1001               "IndentWidth: 12",
1002               IndentWidth, 12u);
1003   EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
1004                                "IndentWidth: 34",
1005                                &Style),
1006             ParseError::Unsuitable);
1007   FormatStyle BinPackedTCS = {};
1008   BinPackedTCS.Language = FormatStyle::LK_JavaScript;
1009   EXPECT_EQ(parseConfiguration("BinPackArguments: true\n"
1010                                "InsertTrailingCommas: Wrapped",
1011                                &BinPackedTCS),
1012             ParseError::BinPackTrailingCommaConflict);
1013   EXPECT_EQ(12u, Style.IndentWidth);
1014   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
1015   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
1016 
1017   Style.Language = FormatStyle::LK_JavaScript;
1018   CHECK_PARSE("Language: JavaScript\n"
1019               "IndentWidth: 12",
1020               IndentWidth, 12u);
1021   CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
1022   EXPECT_EQ(parseConfiguration("Language: Cpp\n"
1023                                "IndentWidth: 34",
1024                                &Style),
1025             ParseError::Unsuitable);
1026   EXPECT_EQ(23u, Style.IndentWidth);
1027   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
1028   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
1029 
1030   CHECK_PARSE("BasedOnStyle: LLVM\n"
1031               "IndentWidth: 67",
1032               IndentWidth, 67u);
1033 
1034   CHECK_PARSE("---\n"
1035               "Language: JavaScript\n"
1036               "IndentWidth: 12\n"
1037               "---\n"
1038               "Language: Cpp\n"
1039               "IndentWidth: 34\n"
1040               "...\n",
1041               IndentWidth, 12u);
1042 
1043   Style.Language = FormatStyle::LK_Cpp;
1044   CHECK_PARSE("---\n"
1045               "Language: JavaScript\n"
1046               "IndentWidth: 12\n"
1047               "---\n"
1048               "Language: Cpp\n"
1049               "IndentWidth: 34\n"
1050               "...\n",
1051               IndentWidth, 34u);
1052   CHECK_PARSE("---\n"
1053               "IndentWidth: 78\n"
1054               "---\n"
1055               "Language: JavaScript\n"
1056               "IndentWidth: 56\n"
1057               "...\n",
1058               IndentWidth, 78u);
1059 
1060   Style.ColumnLimit = 123;
1061   Style.IndentWidth = 234;
1062   Style.BreakBeforeBraces = FormatStyle::BS_Linux;
1063   Style.TabWidth = 345;
1064   EXPECT_FALSE(parseConfiguration("---\n"
1065                                   "IndentWidth: 456\n"
1066                                   "BreakBeforeBraces: Allman\n"
1067                                   "---\n"
1068                                   "Language: JavaScript\n"
1069                                   "IndentWidth: 111\n"
1070                                   "TabWidth: 111\n"
1071                                   "---\n"
1072                                   "Language: Cpp\n"
1073                                   "BreakBeforeBraces: Stroustrup\n"
1074                                   "TabWidth: 789\n"
1075                                   "...\n",
1076                                   &Style));
1077   EXPECT_EQ(123u, Style.ColumnLimit);
1078   EXPECT_EQ(456u, Style.IndentWidth);
1079   EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
1080   EXPECT_EQ(789u, Style.TabWidth);
1081 
1082   EXPECT_EQ(parseConfiguration("---\n"
1083                                "Language: JavaScript\n"
1084                                "IndentWidth: 56\n"
1085                                "---\n"
1086                                "IndentWidth: 78\n"
1087                                "...\n",
1088                                &Style),
1089             ParseError::Error);
1090   EXPECT_EQ(parseConfiguration("---\n"
1091                                "Language: JavaScript\n"
1092                                "IndentWidth: 56\n"
1093                                "---\n"
1094                                "Language: JavaScript\n"
1095                                "IndentWidth: 78\n"
1096                                "...\n",
1097                                &Style),
1098             ParseError::Error);
1099 
1100   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
1101 
1102   Style.Language = FormatStyle::LK_Verilog;
1103   CHECK_PARSE("---\n"
1104               "Language: Verilog\n"
1105               "IndentWidth: 12\n"
1106               "---\n"
1107               "Language: Cpp\n"
1108               "IndentWidth: 34\n"
1109               "...\n",
1110               IndentWidth, 12u);
1111   CHECK_PARSE("---\n"
1112               "IndentWidth: 78\n"
1113               "---\n"
1114               "Language: Verilog\n"
1115               "IndentWidth: 56\n"
1116               "...\n",
1117               IndentWidth, 56u);
1118 }
1119 
1120 TEST(ConfigParseTest, UsesLanguageForBasedOnStyle) {
1121   FormatStyle Style = {};
1122   Style.Language = FormatStyle::LK_JavaScript;
1123   Style.BreakBeforeTernaryOperators = true;
1124   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
1125   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
1126 
1127   Style.BreakBeforeTernaryOperators = true;
1128   EXPECT_EQ(0, parseConfiguration("---\n"
1129                                   "BasedOnStyle: Google\n"
1130                                   "---\n"
1131                                   "Language: JavaScript\n"
1132                                   "IndentWidth: 76\n"
1133                                   "...\n",
1134                                   &Style)
1135                    .value());
1136   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
1137   EXPECT_EQ(76u, Style.IndentWidth);
1138   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
1139 }
1140 
1141 TEST(ConfigParseTest, ConfigurationRoundTripTest) {
1142   FormatStyle Style = getLLVMStyle();
1143   std::string YAML = configurationAsText(Style);
1144   FormatStyle ParsedStyle = {};
1145   ParsedStyle.Language = FormatStyle::LK_Cpp;
1146   EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
1147   EXPECT_EQ(Style, ParsedStyle);
1148 }
1149 
1150 TEST(ConfigParseTest, GetStyleWithEmptyFileName) {
1151   llvm::vfs::InMemoryFileSystem FS;
1152   auto Style1 = getStyle("file", "", "Google", "", &FS);
1153   ASSERT_TRUE((bool)Style1);
1154   ASSERT_EQ(*Style1, getGoogleStyle());
1155 }
1156 
1157 TEST(ConfigParseTest, GetStyleOfFile) {
1158   llvm::vfs::InMemoryFileSystem FS;
1159   // Test 1: format file in the same directory.
1160   ASSERT_TRUE(
1161       FS.addFile("/a/.clang-format", 0,
1162                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
1163   ASSERT_TRUE(
1164       FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
1165   auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
1166   ASSERT_TRUE((bool)Style1);
1167   ASSERT_EQ(*Style1, getLLVMStyle());
1168 
1169   // Test 2.1: fallback to default.
1170   ASSERT_TRUE(
1171       FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
1172   auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
1173   ASSERT_TRUE((bool)Style2);
1174   ASSERT_EQ(*Style2, getMozillaStyle());
1175 
1176   // Test 2.2: no format on 'none' fallback style.
1177   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
1178   ASSERT_TRUE((bool)Style2);
1179   ASSERT_EQ(*Style2, getNoStyle());
1180 
1181   // Test 2.3: format if config is found with no based style while fallback is
1182   // 'none'.
1183   ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
1184                          llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
1185   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
1186   ASSERT_TRUE((bool)Style2);
1187   ASSERT_EQ(*Style2, getLLVMStyle());
1188 
1189   // Test 2.4: format if yaml with no based style, while fallback is 'none'.
1190   Style2 = getStyle("{}", "a.h", "none", "", &FS);
1191   ASSERT_TRUE((bool)Style2);
1192   ASSERT_EQ(*Style2, getLLVMStyle());
1193 
1194   // Test 3: format file in parent directory.
1195   ASSERT_TRUE(
1196       FS.addFile("/c/.clang-format", 0,
1197                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
1198   ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
1199                          llvm::MemoryBuffer::getMemBuffer("int i;")));
1200   auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
1201   ASSERT_TRUE((bool)Style3);
1202   ASSERT_EQ(*Style3, getGoogleStyle());
1203 
1204   // Test 4: error on invalid fallback style
1205   auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
1206   ASSERT_FALSE((bool)Style4);
1207   llvm::consumeError(Style4.takeError());
1208 
1209   // Test 5: error on invalid yaml on command line
1210   auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
1211   ASSERT_FALSE((bool)Style5);
1212   llvm::consumeError(Style5.takeError());
1213 
1214   // Test 6: error on invalid style
1215   auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
1216   ASSERT_FALSE((bool)Style6);
1217   llvm::consumeError(Style6.takeError());
1218 
1219   // Test 7: found config file, error on parsing it
1220   ASSERT_TRUE(
1221       FS.addFile("/d/.clang-format", 0,
1222                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
1223                                                   "InvalidKey: InvalidValue")));
1224   ASSERT_TRUE(
1225       FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
1226   auto Style7a = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
1227   ASSERT_FALSE((bool)Style7a);
1228   llvm::consumeError(Style7a.takeError());
1229 
1230   auto Style7b = getStyle("file", "/d/.clang-format", "LLVM", "", &FS, true);
1231   ASSERT_TRUE((bool)Style7b);
1232 
1233   // Test 8: inferred per-language defaults apply.
1234   auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
1235   ASSERT_TRUE((bool)StyleTd);
1236   ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
1237 
1238   // Test 9.1.1: overwriting a file style, when no parent file exists with no
1239   // fallback style.
1240   ASSERT_TRUE(FS.addFile(
1241       "/e/sub/.clang-format", 0,
1242       llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: InheritParentConfig\n"
1243                                        "ColumnLimit: 20")));
1244   ASSERT_TRUE(FS.addFile("/e/sub/code.cpp", 0,
1245                          llvm::MemoryBuffer::getMemBuffer("int i;")));
1246   auto Style9 = getStyle("file", "/e/sub/code.cpp", "none", "", &FS);
1247   ASSERT_TRUE(static_cast<bool>(Style9));
1248   ASSERT_EQ(*Style9, [] {
1249     auto Style = getNoStyle();
1250     Style.ColumnLimit = 20;
1251     return Style;
1252   }());
1253 
1254   // Test 9.1.2: propagate more than one level with no parent file.
1255   ASSERT_TRUE(FS.addFile("/e/sub/sub/code.cpp", 0,
1256                          llvm::MemoryBuffer::getMemBuffer("int i;")));
1257   ASSERT_TRUE(FS.addFile("/e/sub/sub/.clang-format", 0,
1258                          llvm::MemoryBuffer::getMemBuffer(
1259                              "BasedOnStyle: InheritParentConfig\n"
1260                              "WhitespaceSensitiveMacros: ['FOO', 'BAR']")));
1261   std::vector<std::string> NonDefaultWhiteSpaceMacros =
1262       Style9->WhitespaceSensitiveMacros;
1263   NonDefaultWhiteSpaceMacros[0] = "FOO";
1264   NonDefaultWhiteSpaceMacros[1] = "BAR";
1265 
1266   ASSERT_NE(Style9->WhitespaceSensitiveMacros, NonDefaultWhiteSpaceMacros);
1267   Style9 = getStyle("file", "/e/sub/sub/code.cpp", "none", "", &FS);
1268   ASSERT_TRUE(static_cast<bool>(Style9));
1269   ASSERT_EQ(*Style9, [&NonDefaultWhiteSpaceMacros] {
1270     auto Style = getNoStyle();
1271     Style.ColumnLimit = 20;
1272     Style.WhitespaceSensitiveMacros = NonDefaultWhiteSpaceMacros;
1273     return Style;
1274   }());
1275 
1276   // Test 9.2: with LLVM fallback style
1277   Style9 = getStyle("file", "/e/sub/code.cpp", "LLVM", "", &FS);
1278   ASSERT_TRUE(static_cast<bool>(Style9));
1279   ASSERT_EQ(*Style9, [] {
1280     auto Style = getLLVMStyle();
1281     Style.ColumnLimit = 20;
1282     return Style;
1283   }());
1284 
1285   // Test 9.3: with a parent file
1286   ASSERT_TRUE(
1287       FS.addFile("/e/.clang-format", 0,
1288                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google\n"
1289                                                   "UseTab: Always")));
1290   Style9 = getStyle("file", "/e/sub/code.cpp", "none", "", &FS);
1291   ASSERT_TRUE(static_cast<bool>(Style9));
1292   ASSERT_EQ(*Style9, [] {
1293     auto Style = getGoogleStyle();
1294     Style.ColumnLimit = 20;
1295     Style.UseTab = FormatStyle::UT_Always;
1296     return Style;
1297   }());
1298 
1299   // Test 9.4: propagate more than one level with a parent file.
1300   const auto SubSubStyle = [&NonDefaultWhiteSpaceMacros] {
1301     auto Style = getGoogleStyle();
1302     Style.ColumnLimit = 20;
1303     Style.UseTab = FormatStyle::UT_Always;
1304     Style.WhitespaceSensitiveMacros = NonDefaultWhiteSpaceMacros;
1305     return Style;
1306   }();
1307 
1308   ASSERT_NE(Style9->WhitespaceSensitiveMacros, NonDefaultWhiteSpaceMacros);
1309   Style9 = getStyle("file", "/e/sub/sub/code.cpp", "none", "", &FS);
1310   ASSERT_TRUE(static_cast<bool>(Style9));
1311   ASSERT_EQ(*Style9, SubSubStyle);
1312 
1313   // Test 9.5: use InheritParentConfig as style name
1314   Style9 =
1315       getStyle("inheritparentconfig", "/e/sub/sub/code.cpp", "none", "", &FS);
1316   ASSERT_TRUE(static_cast<bool>(Style9));
1317   ASSERT_EQ(*Style9, SubSubStyle);
1318 
1319   // Test 9.6: use command line style with inheritance
1320   Style9 = getStyle("{BasedOnStyle: InheritParentConfig}",
1321                     "/e/sub/sub/code.cpp", "none", "", &FS);
1322   ASSERT_TRUE(static_cast<bool>(Style9));
1323   ASSERT_EQ(*Style9, SubSubStyle);
1324 
1325   // Test 9.7: use command line style with inheritance and own config
1326   Style9 = getStyle("{BasedOnStyle: InheritParentConfig, "
1327                     "WhitespaceSensitiveMacros: ['FOO', 'BAR']}",
1328                     "/e/sub/code.cpp", "none", "", &FS);
1329   ASSERT_TRUE(static_cast<bool>(Style9));
1330   ASSERT_EQ(*Style9, SubSubStyle);
1331 
1332   // Test 9.8: use inheritance from a file without BasedOnStyle
1333   ASSERT_TRUE(FS.addFile("/e/withoutbase/.clang-format", 0,
1334                          llvm::MemoryBuffer::getMemBuffer("ColumnLimit: 123")));
1335   ASSERT_TRUE(
1336       FS.addFile("/e/withoutbase/sub/.clang-format", 0,
1337                  llvm::MemoryBuffer::getMemBuffer(
1338                      "BasedOnStyle: InheritParentConfig\nIndentWidth: 7")));
1339   // Make sure we do not use the fallback style
1340   Style9 = getStyle("file", "/e/withoutbase/code.cpp", "google", "", &FS);
1341   ASSERT_TRUE(static_cast<bool>(Style9));
1342   ASSERT_EQ(*Style9, [] {
1343     auto Style = getLLVMStyle();
1344     Style.ColumnLimit = 123;
1345     return Style;
1346   }());
1347 
1348   Style9 = getStyle("file", "/e/withoutbase/sub/code.cpp", "google", "", &FS);
1349   ASSERT_TRUE(static_cast<bool>(Style9));
1350   ASSERT_EQ(*Style9, [] {
1351     auto Style = getLLVMStyle();
1352     Style.ColumnLimit = 123;
1353     Style.IndentWidth = 7;
1354     return Style;
1355   }());
1356 
1357   // Test 9.9: use inheritance from a specific config file.
1358   Style9 = getStyle("file:/e/sub/sub/.clang-format", "/e/sub/sub/code.cpp",
1359                     "none", "", &FS);
1360   ASSERT_TRUE(static_cast<bool>(Style9));
1361   ASSERT_EQ(*Style9, SubSubStyle);
1362 }
1363 
1364 TEST(ConfigParseTest, GetStyleOfSpecificFile) {
1365   llvm::vfs::InMemoryFileSystem FS;
1366   // Specify absolute path to a format file in a parent directory.
1367   ASSERT_TRUE(
1368       FS.addFile("/e/.clang-format", 0,
1369                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
1370   ASSERT_TRUE(
1371       FS.addFile("/e/explicit.clang-format", 0,
1372                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
1373   ASSERT_TRUE(FS.addFile("/e/sub/sub/sub/test.cpp", 0,
1374                          llvm::MemoryBuffer::getMemBuffer("int i;")));
1375   auto Style = getStyle("file:/e/explicit.clang-format",
1376                         "/e/sub/sub/sub/test.cpp", "LLVM", "", &FS);
1377   ASSERT_TRUE(static_cast<bool>(Style));
1378   ASSERT_EQ(*Style, getGoogleStyle());
1379 
1380   // Specify relative path to a format file.
1381   ASSERT_TRUE(
1382       FS.addFile("../../e/explicit.clang-format", 0,
1383                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
1384   Style = getStyle("file:../../e/explicit.clang-format",
1385                    "/e/sub/sub/sub/test.cpp", "LLVM", "", &FS);
1386   ASSERT_TRUE(static_cast<bool>(Style));
1387   ASSERT_EQ(*Style, getGoogleStyle());
1388 
1389   // Specify path to a format file that does not exist.
1390   Style = getStyle("file:/e/missing.clang-format", "/e/sub/sub/sub/test.cpp",
1391                    "LLVM", "", &FS);
1392   ASSERT_FALSE(static_cast<bool>(Style));
1393   llvm::consumeError(Style.takeError());
1394 
1395   // Specify path to a file on the filesystem.
1396   SmallString<128> FormatFilePath;
1397   std::error_code ECF = llvm::sys::fs::createTemporaryFile(
1398       "FormatFileTest", "tpl", FormatFilePath);
1399   EXPECT_FALSE((bool)ECF);
1400   llvm::raw_fd_ostream FormatFileTest(FormatFilePath, ECF);
1401   EXPECT_FALSE((bool)ECF);
1402   FormatFileTest << "BasedOnStyle: Google\n";
1403   FormatFileTest.close();
1404 
1405   SmallString<128> TestFilePath;
1406   std::error_code ECT =
1407       llvm::sys::fs::createTemporaryFile("CodeFileTest", "cc", TestFilePath);
1408   EXPECT_FALSE((bool)ECT);
1409   llvm::raw_fd_ostream CodeFileTest(TestFilePath, ECT);
1410   CodeFileTest << "int i;\n";
1411   CodeFileTest.close();
1412 
1413   std::string format_file_arg = std::string("file:") + FormatFilePath.c_str();
1414   Style = getStyle(format_file_arg, TestFilePath, "LLVM", "", nullptr);
1415 
1416   llvm::sys::fs::remove(FormatFilePath.c_str());
1417   llvm::sys::fs::remove(TestFilePath.c_str());
1418   ASSERT_TRUE(static_cast<bool>(Style));
1419   ASSERT_EQ(*Style, getGoogleStyle());
1420 }
1421 
1422 } // namespace
1423 } // namespace format
1424 } // namespace clang
1425