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