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