1 //===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "clang/Format/Format.h" 11 #include "../Tooling/RewriterTestContext.h" 12 #include "clang/Lex/Lexer.h" 13 #include "gtest/gtest.h" 14 15 namespace clang { 16 namespace format { 17 18 class FormatTest : public ::testing::Test { 19 protected: 20 std::string format(llvm::StringRef Code, unsigned Offset, unsigned Length, 21 const FormatStyle &Style) { 22 RewriterTestContext Context; 23 FileID ID = Context.createInMemoryFile("input.cc", Code); 24 SourceLocation Start = 25 Context.Sources.getLocForStartOfFile(ID).getLocWithOffset(Offset); 26 std::vector<CharSourceRange> Ranges( 27 1, 28 CharSourceRange::getCharRange(Start, Start.getLocWithOffset(Length))); 29 LangOptions LangOpts; 30 LangOpts.CPlusPlus = 1; 31 Lexer Lex(ID, Context.Sources.getBuffer(ID), Context.Sources, LangOpts); 32 tooling::Replacements Replace = 33 reformat(Style, Lex, Context.Sources, Ranges); 34 EXPECT_TRUE(applyAllReplacements(Replace, Context.Rewrite)); 35 return Context.getRewrittenText(ID); 36 } 37 38 std::string format(llvm::StringRef Code, 39 const FormatStyle &Style = getLLVMStyle()) { 40 return format(Code, 0, Code.size(), Style); 41 } 42 43 void verifyFormat(llvm::StringRef Code) { 44 std::string WithoutFormat(Code.str()); 45 for (unsigned i = 0, e = WithoutFormat.size(); i != e; ++i) { 46 if (WithoutFormat[i] == '\n') 47 WithoutFormat[i] = ' '; 48 } 49 EXPECT_EQ(Code.str(), format(WithoutFormat)); 50 } 51 52 void verifyGoogleFormat(llvm::StringRef Code) { 53 std::string WithoutFormat(Code.str()); 54 for (unsigned i = 0, e = WithoutFormat.size(); i != e; ++i) { 55 if (WithoutFormat[i] == '\n') 56 WithoutFormat[i] = ' '; 57 } 58 EXPECT_EQ(Code.str(), format(WithoutFormat, getGoogleStyle())); 59 } 60 }; 61 62 //===----------------------------------------------------------------------===// 63 // Basic function tests. 64 //===----------------------------------------------------------------------===// 65 66 TEST_F(FormatTest, DoesNotChangeCorrectlyFormatedCode) { 67 EXPECT_EQ(";", format(";")); 68 } 69 70 TEST_F(FormatTest, FormatsGlobalStatementsAt0) { 71 EXPECT_EQ("int i;", format(" int i;")); 72 EXPECT_EQ("\nint i;", format(" \n\t \r int i;")); 73 EXPECT_EQ("int i;\nint j;", format(" int i; int j;")); 74 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;")); 75 } 76 77 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { 78 EXPECT_EQ("int i;", format("int\ni;")); 79 } 80 81 TEST_F(FormatTest, FormatsNestedBlockStatements) { 82 EXPECT_EQ("{\n {\n {\n }\n }\n}", format("{{{}}}")); 83 } 84 85 TEST_F(FormatTest, FormatsNestedCall) { 86 verifyFormat("Method(f1, f2(f3));"); 87 verifyFormat("Method(f1(f2, f3()));"); 88 } 89 90 91 //===----------------------------------------------------------------------===// 92 // Tests for control statements. 93 //===----------------------------------------------------------------------===// 94 95 TEST_F(FormatTest, FormatIfWithoutCompountStatement) { 96 verifyFormat("if (true)\n f();\ng();"); 97 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();"); 98 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();"); 99 EXPECT_EQ("if (a)\n // comment\n f();", format("if(a)\n// comment\nf();")); 100 } 101 102 TEST_F(FormatTest, ParseIfElse) { 103 verifyFormat("if (true)\n" 104 " if (true)\n" 105 " if (true)\n" 106 " f();\n" 107 " else\n" 108 " g();\n" 109 " else\n" 110 " h();\n" 111 "else\n" 112 " i();"); 113 verifyFormat("if (true)\n" 114 " if (true)\n" 115 " if (true) {\n" 116 " if (true)\n" 117 " f();\n" 118 " } else {\n" 119 " g();\n" 120 " }\n" 121 " else\n" 122 " h();\n" 123 "else {\n" 124 " i();\n" 125 "}"); 126 } 127 128 TEST_F(FormatTest, ElseIf) { 129 verifyFormat("if (a) {\n" 130 "} else if (b) {\n" 131 "}"); 132 verifyFormat("if (a)\n" 133 " f();\n" 134 "else if (b)\n" 135 " g();\n" 136 "else\n" 137 " h();"); 138 } 139 140 TEST_F(FormatTest, FormatsForLoop) { 141 verifyFormat( 142 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 143 " ++VeryVeryLongLoopVariable)\n" 144 " ;"); 145 verifyFormat("for (;;)\n" 146 " f();"); 147 verifyFormat("for (;;) {\n" 148 "}"); 149 verifyFormat("for (;;) {\n" 150 " f();\n" 151 "}"); 152 } 153 154 TEST_F(FormatTest, FormatsWhileLoop) { 155 verifyFormat("while (true) {\n}"); 156 verifyFormat("while (true)\n" 157 " f();"); 158 verifyFormat("while () {\n" 159 "}"); 160 verifyFormat("while () {\n" 161 " f();\n" 162 "}"); 163 } 164 165 TEST_F(FormatTest, FormatsDoWhile) { 166 verifyFormat("do {\n" 167 " do_something();\n" 168 "} while (something());"); 169 verifyFormat("do\n" 170 " do_something();\n" 171 "while (something());"); 172 } 173 174 TEST_F(FormatTest, FormatsSwitchStatement) { 175 verifyFormat("switch (x) {\n" 176 "case 1:\n" 177 " f();\n" 178 " break;\n" 179 "case kFoo:\n" 180 "case ns::kBar:\n" 181 "case kBaz:\n" 182 " break;\n" 183 "default:\n" 184 " g();\n" 185 " break;\n" 186 "}"); 187 verifyFormat("switch (x) {\n" 188 "case 1: {\n" 189 " f();\n" 190 " break;\n" 191 "}\n" 192 "}"); 193 verifyFormat("switch (test)\n" 194 " ;"); 195 verifyGoogleFormat("switch (x) {\n" 196 " case 1:\n" 197 " f();\n" 198 " break;\n" 199 " case kFoo:\n" 200 " case ns::kBar:\n" 201 " case kBaz:\n" 202 " break;\n" 203 " default:\n" 204 " g();\n" 205 " break;\n" 206 "}"); 207 verifyGoogleFormat("switch (x) {\n" 208 " case 1: {\n" 209 " f();\n" 210 " break;\n" 211 " }\n" 212 "}"); 213 verifyGoogleFormat("switch (test)\n" 214 " ;"); 215 } 216 217 TEST_F(FormatTest, FormatsLabels) { 218 verifyFormat("void f() {\n" 219 " some_code();\n" 220 "test_label:\n" 221 " some_other_code();\n" 222 " {\n" 223 " some_more_code();\n" 224 " another_label:\n" 225 " some_more_code();\n" 226 " }\n" 227 "}"); 228 verifyFormat("some_code();\n" 229 "test_label:\n" 230 "some_other_code();"); 231 } 232 233 234 //===----------------------------------------------------------------------===// 235 // Tests for comments. 236 //===----------------------------------------------------------------------===// 237 238 TEST_F(FormatTest, UnderstandsSingleLineComments) { 239 EXPECT_EQ("// line 1\n// line 2\nvoid f() {\n}\n", 240 format("// line 1\n// line 2\nvoid f() {}\n")); 241 242 EXPECT_EQ("void f() {\n // Doesn't do anything\n}", 243 format("void f() {\n// Doesn't do anything\n}")); 244 245 EXPECT_EQ("int i // This is a fancy variable\n = 5;", 246 format("int i // This is a fancy variable\n= 5;")); 247 248 verifyFormat("f(/*test=*/ true);"); 249 } 250 251 252 //===----------------------------------------------------------------------===// 253 // Tests for classes, namespaces, etc. 254 //===----------------------------------------------------------------------===// 255 256 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 257 verifyFormat("class A {\n};"); 258 } 259 260 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 261 verifyFormat("class A {\n" 262 "public:\n" 263 "protected:\n" 264 "private:\n" 265 " void f() {\n" 266 " }\n" 267 "};"); 268 verifyGoogleFormat("class A {\n" 269 " public:\n" 270 " protected:\n" 271 " private:\n" 272 " void f() {\n" 273 " }\n" 274 "};"); 275 } 276 277 TEST_F(FormatTest, FormatsDerivedClass) { 278 verifyFormat("class A : public B {\n" 279 "};"); 280 } 281 282 TEST_F(FormatTest, FormatsEnum) { 283 verifyFormat("enum {\n" 284 " Zero,\n" 285 " One = 1,\n" 286 " Two = One + 1,\n" 287 " Three = (One + Two),\n" 288 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 289 " Five = (One, Two, Three, Four, 5)\n" 290 "};"); 291 verifyFormat("enum Enum {\n" 292 "};"); 293 verifyFormat("enum {\n" 294 "};"); 295 } 296 297 TEST_F(FormatTest, FormatsNamespaces) { 298 verifyFormat("namespace some_namespace {\n" 299 "class A {\n" 300 "};\n" 301 "void f() {\n" 302 " f();\n" 303 "}\n" 304 "}"); 305 verifyFormat("namespace {\n" 306 "class A {\n" 307 "};\n" 308 "void f() {\n" 309 " f();\n" 310 "}\n" 311 "}"); 312 verifyFormat("using namespace some_namespace;\n" 313 "class A {\n" 314 "};\n" 315 "void f() {\n" 316 " f();\n" 317 "}"); 318 } 319 320 //===----------------------------------------------------------------------===// 321 // Line break tests. 322 //===----------------------------------------------------------------------===// 323 324 TEST_F(FormatTest, FormatsFunctionDefinition) { 325 verifyFormat("void f(int a, int b, int c, int d, int e, int f, int g," 326 " int h, int j, int f,\n" 327 " int c, int ddddddddddddd) {\n" 328 "}"); 329 } 330 331 TEST_F(FormatTest, FormatsAwesomeMethodCall) { 332 verifyFormat( 333 "SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 334 " parameter, parameter, parameter)), SecondLongCall(parameter));"); 335 } 336 337 TEST_F(FormatTest, BreaksAsHighAsPossible) { 338 verifyFormat( 339 "if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 340 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 341 " f();"); 342 } 343 344 TEST_F(FormatTest, BreaksDesireably) { 345 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 346 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 347 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n};"); 348 349 verifyFormat( 350 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 351 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 352 353 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 354 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 355 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 356 357 verifyFormat( 358 "aaaaaaaa(aaaaaaaaaaaaa, aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 359 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 360 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 361 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 362 363 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 364 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 365 366 // This test case breaks on an incorrect memoization, i.e. an optimization not 367 // taking into account the StopAt value. 368 verifyFormat( 369 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 370 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 371 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 372 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 373 } 374 375 TEST_F(FormatTest, AlignsStringLiterals) { 376 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 377 " \"short literal\");"); 378 verifyFormat( 379 "looooooooooooooooooooooooongFunction(\n" 380 " \"short literal\"\n" 381 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 382 } 383 384 TEST_F(FormatTest, AlignsPipes) { 385 verifyFormat( 386 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 387 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 388 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 389 verifyFormat( 390 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 391 " << aaaaaaaaaaaaaaaaaaaa;"); 392 verifyFormat( 393 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 394 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 395 verifyFormat( 396 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 397 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 398 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 399 verifyFormat( 400 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 401 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 402 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 403 } 404 405 TEST_F(FormatTest, UnderstandsEquals) { 406 verifyFormat( 407 "aaaaaaaaaaaaaaaaa =\n" 408 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 409 verifyFormat( 410 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 411 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 412 "}"); 413 verifyFormat( 414 "if (a) {\n" 415 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 416 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 417 "}"); 418 419 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 420 " 100000000 + 100000000) {\n}"); 421 } 422 423 TEST_F(FormatTest, UnderstandsTemplateParameters) { 424 verifyFormat("A<int> a;"); 425 verifyFormat("A<A<A<int> > > a;"); 426 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 427 verifyFormat("bool x = a < 1 || 2 > a;"); 428 verifyFormat("bool x = 5 < f<int>();"); 429 verifyFormat("bool x = f<int>() > 5;"); 430 verifyFormat("bool x = 5 < a<int>::x;"); 431 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 432 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 433 434 verifyGoogleFormat("A<A<int>> a;"); 435 verifyGoogleFormat("A<A<A<int>>> a;"); 436 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 437 438 verifyFormat("test >> a >> b;"); 439 verifyFormat("test << a >> b;"); 440 441 verifyFormat("f<int>();"); 442 verifyFormat("template <typename T> void f() {\n}"); 443 } 444 445 TEST_F(FormatTest, UndestandsUnaryOperators) { 446 verifyFormat("int a = -2;"); 447 verifyFormat("f(-1, -2, -3);"); 448 verifyFormat("a[-1] = 5;"); 449 verifyFormat("int a = 5 + -2;"); 450 verifyFormat("if (i == -1) {\n}"); 451 verifyFormat("if (i != -1) {\n}"); 452 verifyFormat("if (i > -1) {\n}"); 453 verifyFormat("if (i < -1) {\n}"); 454 verifyFormat("++(a->f());"); 455 verifyFormat("--(a->f());"); 456 verifyFormat("if (!(a->f())) {\n}"); 457 } 458 459 TEST_F(FormatTest, UndestandsOverloadedOperators) { 460 verifyFormat("bool operator<() {\n}"); 461 } 462 463 TEST_F(FormatTest, UnderstandsUsesOfStar) { 464 verifyFormat("int *f(int *a) {\n}"); 465 verifyFormat("f(a, *a);"); 466 verifyFormat("f(*a);"); 467 verifyFormat("int a = b * 10;"); 468 verifyFormat("int a = 10 * b;"); 469 verifyFormat("int a = b * c;"); 470 verifyFormat("int a += b * c;"); 471 verifyFormat("int a -= b * c;"); 472 verifyFormat("int a *= b * c;"); 473 verifyFormat("int a /= b * c;"); 474 verifyFormat("int a = *b;"); 475 verifyFormat("int a = *b * c;"); 476 verifyFormat("int a = b * *c;"); 477 } 478 479 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 480 verifyFormat("(a)->b();"); 481 verifyFormat("--a;"); 482 } 483 484 TEST_F(FormatTest, HandlesIncludeDirectives) { 485 EXPECT_EQ("#include <string>\n", format("#include <string>\n")); 486 EXPECT_EQ("#include \"a/b/string\"\n", format("#include \"a/b/string\"\n")); 487 EXPECT_EQ("#include \"string.h\"\n", format("#include \"string.h\"\n")); 488 EXPECT_EQ("#include \"string.h\"\n", format("#include \"string.h\"\n")); 489 } 490 491 492 //===----------------------------------------------------------------------===// 493 // Error recovery tests. 494 //===----------------------------------------------------------------------===// 495 496 //TEST_F(FormatTest, IncorrectDerivedClass) { 497 // verifyFormat("public B {\n" 498 // "};"); 499 //} 500 501 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 502 verifyFormat("{"); 503 } 504 505 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 506 verifyFormat("do {\n" 507 "};"); 508 verifyFormat("do {\n" 509 "};\n" 510 "f();"); 511 verifyFormat("do {\n" 512 "}\n" 513 "wheeee(fun);"); 514 verifyFormat("do {\n" 515 " f();\n" 516 "};"); 517 } 518 519 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 520 EXPECT_EQ("{\n{\n}\n", format("{\n{\n}\n")); 521 EXPECT_EQ("{\n {\n}\n", format("{\n {\n}\n")); 522 EXPECT_EQ("{\n {\n }\n", format("{\n {\n }\n")); 523 EXPECT_EQ("{\n {\n }\n }\n}\n", format("{\n {\n }\n }\n}\n")); 524 525 FormatStyle Style = getLLVMStyle(); 526 Style.ColumnLimit = 10; 527 EXPECT_EQ("{\n" 528 " {\n" 529 " breakme(\n" 530 " qwe);\n" 531 "}\n", format("{\n" 532 " {\n" 533 " breakme(qwe);\n" 534 "}\n", Style)); 535 536 } 537 538 } // end namespace tooling 539 } // end namespace clang 540