1 //===- unittest/Format/FormatTestProto.cpp --------------------------------===// 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 "FormatTestUtils.h" 11 #include "clang/Format/Format.h" 12 #include "llvm/Support/Debug.h" 13 #include "gtest/gtest.h" 14 15 #define DEBUG_TYPE "format-test" 16 17 namespace clang { 18 namespace format { 19 20 class FormatTestTextProto : public ::testing::Test { 21 protected: 22 static std::string format(llvm::StringRef Code, unsigned Offset, 23 unsigned Length, const FormatStyle &Style) { 24 LLVM_DEBUG(llvm::errs() << "---\n"); 25 LLVM_DEBUG(llvm::errs() << Code << "\n\n"); 26 std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length)); 27 tooling::Replacements Replaces = reformat(Style, Code, Ranges); 28 auto Result = applyAllReplacements(Code, Replaces); 29 EXPECT_TRUE(static_cast<bool>(Result)); 30 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n"); 31 return *Result; 32 } 33 34 static std::string format(llvm::StringRef Code, const FormatStyle &Style) { 35 return format(Code, 0, Code.size(), Style); 36 } 37 38 static void verifyFormat(llvm::StringRef Code, const FormatStyle &Style) { 39 EXPECT_EQ(Code.str(), format(Code, Style)) << "Expected code is not stable"; 40 EXPECT_EQ(Code.str(), format(test::messUp(Code), Style)); 41 } 42 43 static void verifyFormat(llvm::StringRef Code) { 44 FormatStyle Style = getGoogleStyle(FormatStyle::LK_TextProto); 45 Style.ColumnLimit = 60; // To make writing tests easier. 46 verifyFormat(Code, Style); 47 } 48 }; 49 50 TEST_F(FormatTestTextProto, KeepsTopLevelEntriesFittingALine) { 51 verifyFormat("field_a: OK field_b: OK field_c: OK field_d: OK field_e: OK"); 52 } 53 54 TEST_F(FormatTestTextProto, SupportsMessageFields) { 55 verifyFormat("msg_field: {}"); 56 57 verifyFormat("msg_field: { field_a: A }"); 58 59 verifyFormat("msg_field: { field_a: \"OK\" field_b: 123 }"); 60 61 verifyFormat("msg_field: {\n" 62 " field_a: 1\n" 63 " field_b: OK\n" 64 " field_c: \"OK\"\n" 65 " field_d: 123\n" 66 " field_e: 23\n" 67 "}"); 68 69 verifyFormat("msg_field {}"); 70 71 verifyFormat("msg_field { field_a: A }"); 72 73 verifyFormat("msg_field { field_a: \"OK\" field_b: 123 }"); 74 75 verifyFormat("msg_field {\n" 76 " field_a: 1\n" 77 " field_b: OK\n" 78 " field_c: \"OK\"\n" 79 " field_d: 123\n" 80 " field_e: 23.0\n" 81 " field_f: false\n" 82 " field_g: 'lala'\n" 83 " field_h: 1234.567e-89\n" 84 "}"); 85 86 verifyFormat("msg_field: { msg_field { field_a: 1 } }"); 87 88 verifyFormat("id: \"ala.bala\"\n" 89 "item { type: ITEM_A rank: 1 score: 90.0 }\n" 90 "item { type: ITEM_B rank: 2 score: 70.5 }\n" 91 "item {\n" 92 " type: ITEM_A\n" 93 " rank: 3\n" 94 " score: 20.0\n" 95 " description: \"the third item has a description\"\n" 96 "}"); 97 } 98 99 TEST_F(FormatTestTextProto, AvoidsTopLevelBinPacking) { 100 verifyFormat("field_a: OK\n" 101 "field_b: OK\n" 102 "field_c: OK\n" 103 "field_d: OK\n" 104 "field_e: OK\n" 105 "field_f: OK"); 106 107 verifyFormat("field_a: OK\n" 108 "field_b: \"OK\"\n" 109 "field_c: \"OK\"\n" 110 "msg_field: { field_d: 123 }\n" 111 "field_e: OK\n" 112 "field_f: OK"); 113 114 verifyFormat("field_a: OK\n" 115 "field_b: \"OK\"\n" 116 "field_c: \"OK\"\n" 117 "msg_field: { field_d: 123 field_e: OK }"); 118 119 verifyFormat("a: {\n" 120 " field_a: OK\n" 121 " field_b { field_c: OK }\n" 122 " field_d: OKOKOK\n" 123 " field_e: OK\n" 124 "}"); 125 126 verifyFormat("field_a: OK,\n" 127 "field_b { field_c: OK },\n" 128 "field_d: OKOKOK,\n" 129 "field_e: OK"); 130 } 131 132 TEST_F(FormatTestTextProto, AddsNewlinesAfterTrailingComments) { 133 verifyFormat("field_a: OK // Comment\n" 134 "field_b: 1"); 135 136 verifyFormat("field_a: OK\n" 137 "msg_field: {\n" 138 " field_b: OK // Comment\n" 139 "}"); 140 141 verifyFormat("field_a: OK\n" 142 "msg_field {\n" 143 " field_b: OK // Comment\n" 144 "}"); 145 } 146 147 TEST_F(FormatTestTextProto, ImplicitStringLiteralConcatenation) { 148 verifyFormat("field_a: 'aaaaa'\n" 149 " 'bbbbb'"); 150 verifyFormat("field_a: \"aaaaa\"\n" 151 " \"bbbbb\""); 152 FormatStyle Style = getGoogleStyle(FormatStyle::LK_TextProto); 153 Style.AlwaysBreakBeforeMultilineStrings = true; 154 verifyFormat("field_a:\n" 155 " 'aaaaa'\n" 156 " 'bbbbb'", 157 Style); 158 verifyFormat("field_a:\n" 159 " \"aaaaa\"\n" 160 " \"bbbbb\"", 161 Style); 162 } 163 164 TEST_F(FormatTestTextProto, SupportsAngleBracketMessageFields) { 165 // Single-line tests 166 verifyFormat("msg_field <>"); 167 verifyFormat("msg_field: <>"); 168 verifyFormat("msg_field < field_a: OK >"); 169 verifyFormat("msg_field: < field_a: 123 >"); 170 verifyFormat("msg_field < field_a <> >"); 171 verifyFormat("msg_field < field_a < field_b <> > >"); 172 verifyFormat("msg_field: < field_a < field_b: <> > >"); 173 verifyFormat("msg_field < field_a: OK, field_b: \"OK\" >"); 174 verifyFormat("msg_field: < field_a: OK, field_b: \"OK\" >"); 175 // Multiple lines tests 176 verifyFormat("msg_field <\n" 177 " field_a: OK\n" 178 " field_b: <>,\n" 179 " field_c: OK\n" 180 ">"); 181 182 verifyFormat("msg_field <\n" 183 " field_a { field_b: 1 },\n" 184 " field_c: < f_d: 2 >\n" 185 ">"); 186 187 verifyFormat("msg_field: <\n" 188 " field_a: OK\n" 189 " field_b: <>,\n" 190 " field_c: OK\n" 191 ">"); 192 193 verifyFormat("msg_field: <\n" 194 " field_a { field_b: 1 },\n" 195 " field_c: < fd_d: 2 >\n" 196 ">"); 197 198 verifyFormat("field_a: \"OK\",\n" 199 "msg_field: < field_b: 123 >,\n" 200 "field_c: {}"); 201 202 verifyFormat("field_a < field_b: 1 >,\n" 203 "msg_fid: < fiel_b: 123 >,\n" 204 "field_c <>"); 205 206 verifyFormat("field_a < field_b: 1 >\n" 207 "msg_fied: < field_b: 123 >\n" 208 "field_c <>"); 209 210 verifyFormat("field <\n" 211 " field < field: <> >,\n" 212 " field <>\n" 213 ">\n" 214 "field: < field: 1 >"); 215 216 verifyFormat("msg_field <\n" 217 " field_a: OK\n" 218 " field_b: \"OK\"\n" 219 " field_c: 1\n" 220 " field_d: 12.5\n" 221 " field_e: OK\n" 222 ">"); 223 224 verifyFormat("msg_field: <>\n" 225 "field_c: \"OK\",\n" 226 "msg_field: < field_d: 123 >\n" 227 "field_e: OK\n" 228 "msg_field: < field_d: 12 >"); 229 230 verifyFormat("field_a: OK,\n" 231 "field_b < field_c: OK >,\n" 232 "field_d: < 12.5 >,\n" 233 "field_e: OK"); 234 235 verifyFormat("field_a: OK\n" 236 "field_b < field_c: OK >\n" 237 "field_d: < 12.5 >\n" 238 "field_e: OKOKOK"); 239 240 verifyFormat("msg_field <\n" 241 " field_a: OK,\n" 242 " field_b < field_c: OK >,\n" 243 " field_d: < 12.5 >,\n" 244 " field_e: OK\n" 245 ">"); 246 247 verifyFormat("msg_field <\n" 248 " field_a: < field: OK >,\n" 249 " field_b < field_c: OK >,\n" 250 " field_d: < 12.5 >,\n" 251 " field_e: OK,\n" 252 ">"); 253 254 verifyFormat("msg_field: <\n" 255 " field_a: \"OK\"\n" 256 " msg_field: { field_b: OK }\n" 257 " field_g: OK\n" 258 " field_g: OK\n" 259 " field_g: OK\n" 260 ">"); 261 262 verifyFormat("field_a {\n" 263 " field_d: ok\n" 264 " field_b: < field_c: 1 >\n" 265 " field_d: ok\n" 266 " field_d: ok\n" 267 "}"); 268 269 verifyFormat("field_a: {\n" 270 " field_d: ok\n" 271 " field_b: < field_c: 1 >\n" 272 " field_d: ok\n" 273 " field_d: ok\n" 274 "}"); 275 276 verifyFormat("field_a: <\n" 277 " f1: 1,\n" 278 " f2: <>\n" 279 ">\n" 280 "field_b <\n" 281 " field_b1: <>\n" 282 " field_b2: ok,\n" 283 " field_b3: <\n" 284 " field_x {} // Comment\n" 285 " field_y: { field_z: 1 }\n" 286 " field_w: ok\n" 287 " >\n" 288 " field {\n" 289 " field_x <> // Comment\n" 290 " field_y: < field_z: 1 >\n" 291 " field_w: ok\n" 292 " msg_field: <\n" 293 " field: <>\n" 294 " field: < field: 1 >\n" 295 " field: < field: 2 >\n" 296 " field: < field: 3 >\n" 297 " field: < field: 4 >\n" 298 " field: ok\n" 299 " >\n" 300 " }\n" 301 ">\n" 302 "field: OK,\n" 303 "field_c < field < field <> > >"); 304 305 verifyFormat("app_id: 'com.javax.swing.salsa.latino'\n" 306 "head_id: 1\n" 307 "data < key: value >"); 308 309 verifyFormat("app_id: 'com.javax.swing.salsa.latino'\n" 310 "head_id: 1\n" 311 "data < key: value >\n" 312 "tail_id: 2"); 313 314 verifyFormat("app_id: 'com.javax.swing.salsa.latino'\n" 315 "head_id: 1\n" 316 "data < key: value >\n" 317 "data { key: value }"); 318 319 verifyFormat("app {\n" 320 " app_id: 'com.javax.swing.salsa.latino'\n" 321 " head_id: 1\n" 322 " data < key: value >\n" 323 "}"); 324 325 verifyFormat("app: {\n" 326 " app_id: 'com.javax.swing.salsa.latino'\n" 327 " head_id: 1\n" 328 " data < key: value >\n" 329 "}"); 330 331 verifyFormat("app_id: 'com.javax.swing.salsa.latino'\n" 332 "headheadheadheadheadhead_id: 1\n" 333 "product_data { product { 1 } }"); 334 335 verifyFormat("app_id: 'com.javax.swing.salsa.latino'\n" 336 "headheadheadheadheadhead_id: 1\n" 337 "product_data < product { 1 } >"); 338 339 verifyFormat("app_id: 'com.javax.swing.salsa.latino'\n" 340 "headheadheadheadheadhead_id: 1\n" 341 "product_data < product < 1 > >"); 342 343 verifyFormat("app <\n" 344 " app_id: 'com.javax.swing.salsa.latino'\n" 345 " headheadheadheadheadhead_id: 1\n" 346 " product_data < product { 1 } >\n" 347 ">"); 348 349 verifyFormat("dcccwrnfioeruvginerurneitinfo {\n" 350 " exte3nsionrnfvui { key: value }\n" 351 "}"); 352 } 353 354 TEST_F(FormatTestTextProto, DiscardsUnbreakableTailIfCanBreakAfter) { 355 // The two closing braces count towards the string UnbreakableTailLength, but 356 // since we have broken after the corresponding opening braces, we don't 357 // consider that length for string breaking. 358 verifyFormat( 359 "foo: {\n" 360 " bar: {\n" 361 " text: \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 362 " }\n" 363 "}"); 364 } 365 366 TEST_F(FormatTestTextProto, KeepsLongStringLiteralsOnSameLine) { 367 verifyFormat( 368 "foo: {\n" 369 " text: \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasaaaaaaaaaa\"\n" 370 "}"); 371 } 372 373 TEST_F(FormatTestTextProto, KeepsCommentsIndentedInList) { 374 verifyFormat("aaaaaaaaaa: 100\n" 375 "bbbbbbbbbbbbbbbbbbbbbbbbbbb: 200\n" 376 "# Single line comment for stuff here.\n" 377 "cccccccccccccccccccccccc: 3849\n" 378 "# Multiline comment for stuff here.\n" 379 "# Multiline comment for stuff here.\n" 380 "# Multiline comment for stuff here.\n" 381 "cccccccccccccccccccccccc: 3849"); 382 } 383 384 TEST_F(FormatTestTextProto, UnderstandsHashHashComments) { 385 FormatStyle Style = getGoogleStyle(FormatStyle::LK_TextProto); 386 Style.ColumnLimit = 60; // To make writing tests easier. 387 EXPECT_EQ("aaa: 100\n" 388 "##this is a double-hash comment.\n" 389 "bb: 100\n" 390 "## another double-hash comment.\n" 391 "### a triple-hash comment\n" 392 "cc: 200\n" 393 "#### a quadriple-hash comment\n" 394 "dd: 100\n", 395 format("aaa: 100\n" 396 "##this is a double-hash comment.\n" 397 "bb: 100\n" 398 "## another double-hash comment.\n" 399 "### a triple-hash comment\n" 400 "cc: 200\n" 401 "#### a quadriple-hash comment\n" 402 "dd: 100\n", 403 Style)); 404 } 405 406 TEST_F(FormatTestTextProto, FormatsExtensions) { 407 verifyFormat("[type] { key: value }"); 408 verifyFormat("[type] {\n" 409 " keyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy: value\n" 410 "}"); 411 verifyFormat("[type.type] { key: value }"); 412 verifyFormat("[type.type] < key: value >"); 413 verifyFormat("[type.type/type.type] { key: value }"); 414 verifyFormat("msg {\n" 415 " [type.type] { key: value }\n" 416 "}"); 417 verifyFormat("msg {\n" 418 " [type.type] {\n" 419 " keyyyyyyyyyyyyyy: valuuuuuuuuuuuuuuuuuuuuuuuuue\n" 420 " }\n" 421 "}"); 422 verifyFormat("key: value\n" 423 "[a.b] { key: value }"); 424 verifyFormat("msg: <\n" 425 " key: value\n" 426 " [a.b.c/d.e]: < key: value >\n" 427 " [f.g]: <\n" 428 " key: valueeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\n" 429 " key: {}\n" 430 " >\n" 431 " key {}\n" 432 " [h.i.j] < key: value >\n" 433 " [a]: {\n" 434 " [b.c]: {}\n" 435 " [d] <>\n" 436 " [e/f]: 1\n" 437 " }\n" 438 ">"); 439 verifyFormat("[longg.long.long.long.long.long.long.long.long.long.long\n" 440 " .longg.longlong] { key: value }"); 441 verifyFormat("[longg.long.long.long.long.long.long.long.long.long.long\n" 442 " .longg.longlong] {\n" 443 " key: value\n" 444 " key: value\n" 445 " key: value\n" 446 " key: value\n" 447 "}"); 448 verifyFormat("[longg.long.long.long.long.long.long.long.long.long\n" 449 " .long/longg.longlong] { key: value }"); 450 verifyFormat("[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/\n" 451 " bbbbbbbbbbbbbb] { key: value }"); 452 // These go over the column limit intentionally, since the alternative 453 // [aa..a\n] is worse. 454 verifyFormat("[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] {\n" 455 " key: value\n" 456 "}"); 457 verifyFormat("[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] {\n" 458 " [type.type] {\n" 459 " keyyyyyyyyyyyyyy: valuuuuuuuuuuuuuuuuuuuuuuuuue\n" 460 " }\n" 461 "}"); 462 verifyFormat("[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/\n" 463 " bbbbbbb] {\n" 464 " [type.type] {\n" 465 " keyyyyyyyyyyyyyy: valuuuuuuuuuuuuuuuuuuuuuuuuue\n" 466 " }\n" 467 "}"); 468 verifyFormat( 469 "aaaaaaaaaaaaaaa {\n" 470 " bbbbbb {\n" 471 " [a.b/cy] {\n" 472 " eeeeeeeeeeeee: \"The lazy coo cat jumps over the lazy hot dog\"\n" 473 " }\n" 474 " }\n" 475 "}"); 476 } 477 478 TEST_F(FormatTestTextProto, SpacesAroundPercents) { 479 verifyFormat("key: %d"); 480 verifyFormat("key: 0x%04x"); 481 verifyFormat("key: \"%d %d\""); 482 } 483 484 TEST_F(FormatTestTextProto, FormatsRepeatedListInitializers) { 485 verifyFormat("keys: []"); 486 verifyFormat("keys: [ 1 ]"); 487 verifyFormat("keys: [ 'ala', 'bala' ]"); 488 verifyFormat("keys: [\n" 489 " 'ala',\n" 490 " 'bala',\n" 491 " 'porto',\n" 492 " 'kala',\n" 493 " 'too',\n" 494 " 'long',\n" 495 " 'ng'\n" 496 "]"); 497 verifyFormat("key: item\n" 498 "keys: [\n" 499 " 'ala',\n" 500 " 'bala',\n" 501 " 'porto',\n" 502 " 'kala',\n" 503 " 'too',\n" 504 " 'long',\n" 505 " 'long',\n" 506 " 'long'\n" 507 "]\n" 508 "key: item\n" 509 "msg {\n" 510 " key: item\n" 511 " keys: [\n" 512 " 'ala',\n" 513 " 'bala',\n" 514 " 'porto',\n" 515 " 'kala',\n" 516 " 'too',\n" 517 " 'long',\n" 518 " 'long'\n" 519 " ]\n" 520 "}\n" 521 "key: value" 522 ); 523 FormatStyle Style = getGoogleStyle(FormatStyle::LK_TextProto); 524 Style.ColumnLimit = 60; // To make writing tests easier. 525 Style.Cpp11BracedListStyle = true; 526 verifyFormat("keys: [1]", Style); 527 } 528 529 TEST_F(FormatTestTextProto, AcceptsOperatorAsKey) { 530 verifyFormat("aaaaaaaaaaa: <\n" 531 " bbbbbbbbb: <\n" 532 " ccccccccccccccccccccccc: <\n" 533 " operator: 1\n" 534 " operator: 2\n" 535 " operator: 3\n" 536 " operator { key: value }\n" 537 " >\n" 538 " >\n" 539 ">"); 540 } 541 542 TEST_F(FormatTestTextProto, BreaksConsecutiveStringLiterals) { 543 verifyFormat("ala: \"str1\"\n" 544 " \"str2\"\n"); 545 } 546 547 TEST_F(FormatTestTextProto, PutsMultipleEntriesInExtensionsOnNewlines) { 548 FormatStyle Style = getGoogleStyle(FormatStyle::LK_TextProto); 549 verifyFormat("pppppppppp: {\n" 550 " ssssss: \"http://example.com/blahblahblah\"\n" 551 " ppppppp: \"sssss/MMMMMMMMMMMM\"\n" 552 " [ns.sssss.eeeeeeeee.eeeeeeeeeeeeeee] { begin: 24 end: 252 }\n" 553 " [ns.sssss.eeeeeeeee.eeeeeeeeeeeeeee] {\n" 554 " begin: 24\n" 555 " end: 252\n" 556 " key: value\n" 557 " key: value\n" 558 " }\n" 559 "}", Style); 560 } 561 562 TEST_F(FormatTestTextProto, BreaksAfterBraceFollowedByClosingBraceOnNextLine) { 563 FormatStyle Style = getGoogleStyle(FormatStyle::LK_TextProto); 564 Style.ColumnLimit = 60; 565 verifyFormat("keys: [\n" 566 " data: { item: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' }\n" 567 "]"); 568 verifyFormat("keys: <\n" 569 " data: { item: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' }\n" 570 ">"); 571 } 572 573 TEST_F(FormatTestTextProto, BreaksEntriesOfSubmessagesContainingSubmessages) { 574 FormatStyle Style = getGoogleStyle(FormatStyle::LK_TextProto); 575 Style.ColumnLimit = 60; 576 // The column limit allows for the keys submessage to be put on 1 line, but we 577 // break it since it contains a submessage an another entry. 578 verifyFormat("key: valueeeeeeee\n" 579 "keys: {\n" 580 " item: 'aaaaaaaaaaaaaaaa'\n" 581 " sub <>\n" 582 "}"); 583 verifyFormat("key: valueeeeeeee\n" 584 "keys: {\n" 585 " item: 'aaaaaaaaaaaaaaaa'\n" 586 " sub {}\n" 587 "}"); 588 verifyFormat("key: valueeeeeeee\n" 589 "keys: {\n" 590 " sub {}\n" 591 " sub: <>\n" 592 " sub: []\n" 593 "}"); 594 verifyFormat("key: valueeeeeeee\n" 595 "keys: {\n" 596 " item: 'aaaaaaaaaaa'\n" 597 " sub { msg: 1 }\n" 598 "}"); 599 verifyFormat("key: valueeeeeeee\n" 600 "keys: {\n" 601 " item: 'aaaaaaaaaaa'\n" 602 " sub: { msg: 1 }\n" 603 "}"); 604 verifyFormat("key: valueeeeeeee\n" 605 "keys: {\n" 606 " item: 'aaaaaaaaaaa'\n" 607 " sub < msg: 1 >\n" 608 "}"); 609 verifyFormat("key: valueeeeeeee\n" 610 "keys: {\n" 611 " item: 'aaaaaaaaaaa'\n" 612 " sub: [ msg: 1 ]\n" 613 "}"); 614 verifyFormat("key: valueeeeeeee\n" 615 "keys: <\n" 616 " item: 'aaaaaaaaaaa'\n" 617 " sub: [ 1, 2 ]\n" 618 ">"); 619 verifyFormat("key: valueeeeeeee\n" 620 "keys: {\n" 621 " sub {}\n" 622 " item: 'aaaaaaaaaaaaaaaa'\n" 623 "}"); 624 verifyFormat("key: valueeeeeeee\n" 625 "keys: {\n" 626 " sub: []\n" 627 " item: 'aaaaaaaaaaaaaaaa'\n" 628 "}"); 629 verifyFormat("key: valueeeeeeee\n" 630 "keys: {\n" 631 " sub <>\n" 632 " item: 'aaaaaaaaaaaaaaaa'\n" 633 "}"); 634 verifyFormat("key: valueeeeeeee\n" 635 "keys: {\n" 636 " sub { key: value }\n" 637 " item: 'aaaaaaaaaaaaaaaa'\n" 638 "}"); 639 verifyFormat("key: valueeeeeeee\n" 640 "keys: {\n" 641 " sub: [ 1, 2 ]\n" 642 " item: 'aaaaaaaaaaaaaaaa'\n" 643 "}"); 644 verifyFormat("key: valueeeeeeee\n" 645 "keys: {\n" 646 " sub < sub_2: {} >\n" 647 " item: 'aaaaaaaaaaaaaaaa'\n" 648 "}"); 649 verifyFormat("key: valueeeeeeee\n" 650 "keys: {\n" 651 " item: data\n" 652 " sub: [ 1, 2 ]\n" 653 " item: 'aaaaaaaaaaaaaaaa'\n" 654 "}"); 655 verifyFormat("key: valueeeeeeee\n" 656 "keys: {\n" 657 " item: data\n" 658 " sub < sub_2: {} >\n" 659 " item: 'aaaaaaaaaaaaaaaa'\n" 660 "}"); 661 verifyFormat("sub: {\n" 662 " key: valueeeeeeee\n" 663 " keys: {\n" 664 " sub: [ 1, 2 ]\n" 665 " item: 'aaaaaaaaaaaaaaaa'\n" 666 " }\n" 667 "}"); 668 verifyFormat("sub: {\n" 669 " key: 1\n" 670 " sub: {}\n" 671 "}\n" 672 "# comment\n"); 673 verifyFormat("sub: {\n" 674 " key: 1\n" 675 " # comment\n" 676 " sub: {}\n" 677 "}"); 678 } 679 680 TEST_F(FormatTestTextProto, PreventBreaksBetweenKeyAndSubmessages) { 681 verifyFormat("submessage: {\n" 682 " key: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n" 683 "}"); 684 verifyFormat("submessage {\n" 685 " key: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n" 686 "}"); 687 verifyFormat("submessage: <\n" 688 " key: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n" 689 ">"); 690 verifyFormat("submessage <\n" 691 " key: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n" 692 ">"); 693 verifyFormat("repeatedd: [\n" 694 " 'eyaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n" 695 "]"); 696 // "{" is going over the column limit. 697 verifyFormat( 698 "submessageeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee: {\n" 699 " key: 'aaaaa'\n" 700 "}"); 701 } 702 703 TEST_F(FormatTestTextProto, FormatsCommentsAtEndOfFile) { 704 verifyFormat("key: value\n" 705 "# endfile comment"); 706 verifyFormat("key: value\n" 707 "// endfile comment"); 708 verifyFormat("key: value\n" 709 "// endfile comment 1\n" 710 "// endfile comment 2"); 711 verifyFormat("submessage { key: value }\n" 712 "# endfile comment"); 713 verifyFormat("submessage <\n" 714 " key: value\n" 715 " item {}\n" 716 ">\n" 717 "# endfile comment"); 718 } 719 720 TEST_F(FormatTestTextProto, KeepsAmpersandsNextToKeys) { 721 verifyFormat("@tmpl { field: 1 }"); 722 verifyFormat("@placeholder: 1"); 723 verifyFormat("@name <>"); 724 verifyFormat("submessage: @base { key: value }"); 725 verifyFormat("submessage: @base {\n" 726 " key: value\n" 727 " item: {}\n" 728 "}"); 729 verifyFormat("submessage: {\n" 730 " msg: @base {\n" 731 " yolo: {}\n" 732 " key: value\n" 733 " }\n" 734 " key: value\n" 735 "}"); 736 } 737 738 } // end namespace tooling 739 } // end namespace clang 740