1 //===- unittest/Format/FormatTestProto.cpp --------------------------------===// 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 "FormatTestUtils.h" 10 #include "clang/Format/Format.h" 11 #include "llvm/Support/Debug.h" 12 #include "gtest/gtest.h" 13 14 #define DEBUG_TYPE "format-test" 15 16 namespace clang { 17 namespace format { 18 19 class FormatTestProto : public testing::Test { 20 protected: 21 static std::string format(StringRef Code, unsigned Offset, unsigned Length, 22 const FormatStyle &Style) { 23 LLVM_DEBUG(llvm::errs() << "---\n"); 24 LLVM_DEBUG(llvm::errs() << Code << "\n\n"); 25 std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length)); 26 tooling::Replacements Replaces = reformat(Style, Code, Ranges); 27 auto Result = applyAllReplacements(Code, Replaces); 28 EXPECT_TRUE(static_cast<bool>(Result)); 29 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n"); 30 return *Result; 31 } 32 33 static std::string format(StringRef Code) { 34 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Proto); 35 Style.ColumnLimit = 60; // To make writing tests easier. 36 return format(Code, 0, Code.size(), Style); 37 } 38 39 static void verifyFormat(StringRef Code) { 40 EXPECT_EQ(Code.str(), format(Code)) << "Expected code is not stable"; 41 EXPECT_EQ(Code.str(), format(test::messUp(Code))); 42 } 43 }; 44 45 TEST_F(FormatTestProto, FormatsMessages) { 46 verifyFormat("message SomeMessage {\n" 47 " required int32 field1 = 1;\n" 48 "}"); 49 verifyFormat("message SomeMessage {\n" 50 " required .absolute.Reference field1 = 1;\n" 51 "}"); 52 verifyFormat("message SomeMessage {\n" 53 " required int32 field1 = 1;\n" 54 " optional string field2 = 2 [default = \"2\"]\n" 55 "}"); 56 57 verifyFormat("message SomeMessage {\n" 58 " optional really.really.long.qualified.type.aaa.aaaaaaa\n" 59 " fiiiiiiiiiiiiiiiiiiiiiiiiield = 1;\n" 60 " optional\n" 61 " really.really.long.qualified.type.aaa.aaaaaaa.aaaaaaaa\n" 62 " another_fiiiiiiiiiiiiiiiiiiiiield = 2;\n" 63 "}"); 64 verifyFormat("message SomeMessage {\n" 65 " map<string, Project> projects = 1;\n" 66 " optional map<string, int32> size_projects = 2;\n" 67 " map<int, really.really.really.long.qualified.type.nameeee>\n" 68 " projects = 3;\n" 69 " map<int, really.really.really.really.long.qualified.type\n" 70 " .nameeee> projects = 4;\n" 71 " map<int,\n" 72 " reallyreallyreallyreallyreallyreallyreallylongname>\n" 73 " projects = 5;\n" 74 " map<int, Project>\n" 75 " longlonglonglonglonglonglonglonglonglongonglon = 6;\n" 76 " map<releleallyreallyreallyreallyreallyreallyreallylongname,\n" 77 " int> projects = 7;\n" 78 " map<releleallyreallyreallyreallyreallyreallyreallylongname,\n" 79 " releleallyreallyreallyreallyreallyreallyreallylongname>\n" 80 " releleallyreallyreallyreallyreallyreallyreallylongnam =\n" 81 " 8;\n" 82 " map<relele.llyreal.yreallyr.allyreally.eallyreal\n" 83 " .sauenirylongname,\n" 84 " really.really.really.really.long.qualified.type\n" 85 " .nameeee> projects = 9;\n" 86 "}"); 87 } 88 89 TEST_F(FormatTestProto, KeywordsInOtherLanguages) { 90 verifyFormat("optional string operator = 1;"); 91 } 92 93 TEST_F(FormatTestProto, FormatsEnums) { 94 verifyFormat("enum Type {\n" 95 " UNKNOWN = 0;\n" 96 " TYPE_A = 1;\n" 97 " TYPE_B = 2;\n" 98 "};"); 99 verifyFormat("enum Type {\n" 100 " UNKNOWN = 0 [(some_options) = { a: aa, b: bb }];\n" 101 "};"); 102 verifyFormat("enum Type {\n" 103 " UNKNOWN = 0 [(some_options) = {\n" 104 " a: aa, // wrap\n" 105 " b: bb\n" 106 " }];\n" 107 "};"); 108 } 109 110 TEST_F(FormatTestProto, EnumAsFieldName) { 111 verifyFormat("message SomeMessage {\n" 112 " required int32 enum = 1;\n" 113 "}"); 114 } 115 116 TEST_F(FormatTestProto, CaseAsFieldName) { 117 verifyFormat("message SomeMessage {\n" 118 " required string case = 1;\n" 119 " repeated int32 fizz = 2;\n" 120 "}"); 121 } 122 123 TEST_F(FormatTestProto, UnderstandsReturns) { 124 verifyFormat("rpc Search(SearchRequest) returns (SearchResponse);"); 125 } 126 127 TEST_F(FormatTestProto, MessageFieldAttributes) { 128 verifyFormat("optional string test = 1 [default = \"test\"];"); 129 verifyFormat("optional bool a = 1 [default = true, deprecated = true];"); 130 verifyFormat("optional LongMessageType long_proto_field = 1 [\n" 131 " default = REALLY_REALLY_LONG_CONSTANT_VALUE,\n" 132 " deprecated = true\n" 133 "];"); 134 verifyFormat("optional LongMessageType long_proto_field = 1\n" 135 " [default = REALLY_REALLY_LONG_CONSTANT_VALUE];"); 136 verifyFormat("repeated double value = 1\n" 137 " [(aaaaaaa.aaaaaaaaa) = { aaaaaaaaaaaaaaaaa: AAAAAAAA }];"); 138 verifyFormat("repeated double value = 1 [(aaaaaaa.aaaaaaaaa) = {\n" 139 " aaaaaaaaaaaaaaaa: AAAAAAAAAA,\n" 140 " bbbbbbbbbbbbbbbb: BBBBBBBBBB\n" 141 "}];"); 142 verifyFormat("repeated double value = 1 [(aaaaaaa.aaaaaaaaa) = {\n" 143 " aaaaaaaaaaaaaaaa: AAAAAAAAAA\n" 144 " bbbbbbbbbbbbbbbb: BBBBBBBBBB\n" 145 "}];"); 146 verifyFormat("repeated double value = 1 [\n" 147 " (aaaaaaa.aaaaaaaaa) = {\n" 148 " aaaaaaaaaaaaaaaa: AAAAAAAAAA\n" 149 " bbbbbbbbbbbbbbbb: BBBBBBBBBB\n" 150 " },\n" 151 " (bbbbbbb.bbbbbbbbb) = {\n" 152 " aaaaaaaaaaaaaaaa: AAAAAAAAAA\n" 153 " bbbbbbbbbbbbbbbb: BBBBBBBBBB\n" 154 " }\n" 155 "];"); 156 verifyFormat("repeated double value = 1 [(aaaaaaa.aaaaaaaaa) = {\n" 157 " type: \"AAAAAAAAAA\"\n" 158 " is: \"AAAAAAAAAA\"\n" 159 " or: \"BBBBBBBBBB\"\n" 160 "}];"); 161 verifyFormat("repeated double value = 1 [(aaaaaaa.aaaaaaaaa) = {\n" 162 " aaaaaaaaaaaaaaaa: AAAAAAAAAA,\n" 163 " bbbbbbb: BBBB,\n" 164 " bbbb: BBB\n" 165 "}];"); 166 verifyFormat("optional AAA aaa = 1 [\n" 167 " foo = {\n" 168 " key: 'a' //\n" 169 " },\n" 170 " bar = {\n" 171 " key: 'a' //\n" 172 " }\n" 173 "];"); 174 verifyFormat("optional string test = 1 [default = \"test\"\n" 175 " \"test\"];"); 176 verifyFormat("optional Aaaaaaaa aaaaaaaa = 12 [\n" 177 " (aaa) = aaaa,\n" 178 " (bbbbbbbbbbbbbbbbbbbbbbbbbb) = {\n" 179 " aaaaaaaaaaaaaaaaa: true,\n" 180 " aaaaaaaaaaaaaaaa: true\n" 181 " }\n" 182 "];"); 183 verifyFormat("extensions 20 [(proto2.type) = 'Aaaa.bbbb'];"); 184 verifyFormat("extensions 20\n" 185 " [(proto3.type) = 'Aaaa.bbbb', (aaa.Aaa) = 'aaa.bbb'];"); 186 verifyFormat("extensions 123 [\n" 187 " (aaa) = aaaa,\n" 188 " (bbbbbbbbbbbbbbbbbbbbbbbbbb) = {\n" 189 " aaaaaaaaaaaaaaaaa: true,\n" 190 " aaaaaaaaaaaaaaaa: true\n" 191 " }\n" 192 "];"); 193 verifyFormat("repeated A a = 1 [(annotation).int32.repeated.test = true];"); 194 } 195 196 TEST_F(FormatTestProto, DoesntWrapFileOptions) { 197 EXPECT_EQ( 198 "option java_package = " 199 "\"some.really.long.package.that.exceeds.the.column.limit\";", 200 format("option java_package = " 201 "\"some.really.long.package.that.exceeds.the.column.limit\";")); 202 } 203 204 TEST_F(FormatTestProto, TrailingCommentAfterFileOption) { 205 verifyFormat("option java_package = \"foo.pkg\"; // comment"); 206 } 207 208 TEST_F(FormatTestProto, FormatsOptions) { 209 verifyFormat("option (MyProto.options) = {\n" 210 " field_a: OK\n" 211 " field_b: \"OK\"\n" 212 " field_c: \"OK\"\n" 213 " msg_field: { field_d: 123 }\n" 214 "};"); 215 verifyFormat("option (MyProto.options) = {\n" 216 " field_a: OK\n" 217 " field_b: \"OK\"\n" 218 " field_c: \"OK\"\n" 219 " msg_field: { field_d: 123 field_e: OK }\n" 220 "};"); 221 verifyFormat("option (MyProto.options) = {\n" 222 " field_a: OK // Comment\n" 223 " field_b: \"OK\"\n" 224 " field_c: \"OK\"\n" 225 " msg_field: { field_d: 123 }\n" 226 "};"); 227 verifyFormat("option (MyProto.options) = {\n" 228 " field_c: \"OK\"\n" 229 " msg_field { field_d: 123 }\n" 230 "};"); 231 verifyFormat("option (MyProto.options) = {\n" 232 " field_a: OK\n" 233 " field_b { field_c: OK }\n" 234 " field_d: OKOKOK\n" 235 " field_e: OK\n" 236 "}"); 237 238 // Support syntax with <> instead of {}. 239 verifyFormat("option (MyProto.options) = {\n" 240 " field_c: \"OK\",\n" 241 " msg_field: < field_d: 123 >\n" 242 " empty: <>\n" 243 " empty <>\n" 244 "};"); 245 246 verifyFormat("option (MyProto.options) = {\n" 247 " field_a: OK\n" 248 " field_b < field_c: OK >\n" 249 " field_d: OKOKOK\n" 250 " field_e: OK\n" 251 "}"); 252 253 verifyFormat("option (MyProto.options) = {\n" 254 " msg_field: <>\n" 255 " field_c: \"OK\",\n" 256 " msg_field: < field_d: 123 >\n" 257 " field_e: OK\n" 258 " msg_field: < field_d: 12 >\n" 259 "};"); 260 261 verifyFormat("option (MyProto.options) = <\n" 262 " field_a: OK\n" 263 " field_b: \"OK\"\n" 264 " field_c: 1\n" 265 " field_d: 12.5\n" 266 " field_e: OK\n" 267 ">;"); 268 269 verifyFormat("option (MyProto.options) = <\n" 270 " field_a: OK,\n" 271 " field_b: \"OK\",\n" 272 " field_c: 1,\n" 273 " field_d: 12.5,\n" 274 " field_e: OK,\n" 275 ">;"); 276 277 verifyFormat("option (MyProto.options) = <\n" 278 " field_a: \"OK\"\n" 279 " msg_field: { field_b: OK }\n" 280 " field_g: OK\n" 281 " field_g: OK\n" 282 " field_g: OK\n" 283 ">;"); 284 285 verifyFormat("option (MyProto.options) = <\n" 286 " field_a: \"OK\"\n" 287 " msg_field <\n" 288 " field_b: OK\n" 289 " field_c: OK\n" 290 " field_d: OK\n" 291 " field_e: OK\n" 292 " field_f: OK\n" 293 " >\n" 294 " field_g: OK\n" 295 ">;"); 296 297 verifyFormat("option (MyProto.options) = <\n" 298 " field_a: \"OK\"\n" 299 " msg_field <\n" 300 " field_b: OK,\n" 301 " field_c: OK,\n" 302 " field_d: OK,\n" 303 " field_e: OK,\n" 304 " field_f: OK\n" 305 " >\n" 306 " field_g: OK\n" 307 ">;"); 308 309 verifyFormat("option (MyProto.options) = <\n" 310 " field_a: \"OK\"\n" 311 " msg_field: <\n" 312 " field_b: OK\n" 313 " field_c: OK\n" 314 " field_d: OK\n" 315 " field_e: OK\n" 316 " field_f: OK\n" 317 " >\n" 318 " field_g: OK\n" 319 ">;"); 320 321 verifyFormat("option (MyProto.options) = <\n" 322 " field_a: \"OK\"\n" 323 " msg_field: {\n" 324 " field_b: OK\n" 325 " field_c: OK\n" 326 " field_d: OK\n" 327 " field_e: OK\n" 328 " field_f: OK\n" 329 " }\n" 330 " field_g: OK\n" 331 ">;"); 332 333 verifyFormat("option (MyProto.options) = <\n" 334 " field_a: \"OK\"\n" 335 " msg_field {\n" 336 " field_b: OK\n" 337 " field_c: OK\n" 338 " field_d: OK\n" 339 " field_e: OK\n" 340 " field_f: OK\n" 341 " }\n" 342 " field_g: OK\n" 343 ">;"); 344 345 verifyFormat("option (MyProto.options) = {\n" 346 " field_a: \"OK\"\n" 347 " msg_field <\n" 348 " field_b: OK\n" 349 " field_c: OK\n" 350 " field_d: OK\n" 351 " field_e: OK\n" 352 " field_f: OK\n" 353 " >\n" 354 " field_g: OK\n" 355 "};"); 356 357 verifyFormat("option (MyProto.options) = {\n" 358 " field_a: \"OK\"\n" 359 " msg_field: <\n" 360 " field_b: OK\n" 361 " field_c: OK\n" 362 " field_d: OK\n" 363 " field_e: OK\n" 364 " field_f: OK\n" 365 " >\n" 366 " field_g: OK\n" 367 "};"); 368 369 verifyFormat("option (MyProto.options) = <\n" 370 " field_a: \"OK\"\n" 371 " msg_field {\n" 372 " field_b: OK\n" 373 " field_c: OK\n" 374 " field_d: OK\n" 375 " msg_field <\n" 376 " field_A: 1\n" 377 " field_B: 2\n" 378 " field_C: 3\n" 379 " field_D: 4\n" 380 " field_E: 5\n" 381 " >\n" 382 " msg_field < field_A: 1 field_B: 2 field_C: 3 f_D: 4 >\n" 383 " field_e: OK\n" 384 " field_f: OK\n" 385 " }\n" 386 " field_g: OK\n" 387 ">;"); 388 389 verifyFormat("option (MyProto.options) = <\n" 390 " data1 < key1: value1 >\n" 391 " data2 { key2: value2 }\n" 392 ">;"); 393 394 verifyFormat("option (MyProto.options) = <\n" 395 " app_id: 'com.javax.swing.salsa.latino'\n" 396 " head_id: 1\n" 397 " data < key: value >\n" 398 ">;"); 399 400 verifyFormat("option (MyProto.options) = {\n" 401 " app_id: 'com.javax.swing.salsa.latino'\n" 402 " head_id: 1\n" 403 " headheadheadheadheadhead_id: 1\n" 404 " product_data { product { 1 } }\n" 405 "};"); 406 } 407 408 TEST_F(FormatTestProto, DoesntWrapPackageStatements) { 409 verifyFormat( 410 "package" 411 " some.really.long.package.that.exceeds.the.column.limit00000000;"); 412 } 413 414 TEST_F(FormatTestProto, TrailingCommentAfterPackage) { 415 verifyFormat("package foo.pkg; // comment"); 416 } 417 418 TEST_F(FormatTestProto, FormatsService) { 419 verifyFormat("service SearchService {\n" 420 " rpc Search(SearchRequest) returns (SearchResponse) {\n" 421 " option foo = true;\n" 422 " }\n" 423 "};"); 424 } 425 426 TEST_F(FormatTestProto, ExtendingMessage) { 427 verifyFormat("extend .foo.Bar {}"); 428 } 429 430 TEST_F(FormatTestProto, FormatsImports) { 431 verifyFormat("import \"a.proto\";\n" 432 "import \"b.proto\";\n" 433 "// comment\n" 434 "message A {}"); 435 436 verifyFormat("import public \"a.proto\";\n" 437 "import \"b.proto\";\n" 438 "// comment\n" 439 "message A {}"); 440 441 // Missing semicolons should not confuse clang-format. 442 verifyFormat("import \"a.proto\"\n" 443 "import \"b.proto\"\n" 444 "// comment\n" 445 "message A {}"); 446 } 447 448 TEST_F(FormatTestProto, KeepsLongStringLiteralsOnSameLine) { 449 verifyFormat( 450 "option (MyProto.options) = {\n" 451 " foo: {\n" 452 " text: \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasaaaaaaaa\"\n" 453 " }\n" 454 "}"); 455 } 456 457 TEST_F(FormatTestProto, FormatsOptionsExtensions) { 458 verifyFormat("option (MyProto.options) = {\n" 459 " msg_field: { field_d: 123 }\n" 460 " [ext.t/u] { key: value }\n" 461 " key: value\n" 462 " [t.u/v] <\n" 463 " [ext] { key: value }\n" 464 " >\n" 465 "};"); 466 } 467 468 TEST_F(FormatTestProto, SpacesAroundPercents) { 469 verifyFormat("option (MyProto.options) = {\n" 470 " key: %lld\n" 471 " key: 0x%04x\n" 472 " key: \"%d %d\"\n" 473 "};"); 474 } 475 476 TEST_F(FormatTestProto, FormatsRepeatedListInitializersInOptions) { 477 verifyFormat("option (MyProto.options) = {\n" 478 " key: item\n" 479 " keys: [\n" 480 " 'ala',\n" 481 " 'bala',\n" 482 " 'porto',\n" 483 " 'kala',\n" 484 " 'too',\n" 485 " 'long',\n" 486 " 'long',\n" 487 " 'long'\n" 488 " ]\n" 489 " key: [ item ]\n" 490 " msg {\n" 491 " key: item\n" 492 " keys: [\n" 493 " 'ala',\n" 494 " 'bala',\n" 495 " 'porto',\n" 496 " 'kala',\n" 497 " 'too',\n" 498 " 'long',\n" 499 " 'long'\n" 500 " ]\n" 501 " }\n" 502 " key: value\n" 503 "};"); 504 } 505 506 TEST_F(FormatTestProto, AcceptsOperatorAsKeyInOptions) { 507 verifyFormat("option (MyProto.options) = {\n" 508 " bbbbbbbbb: <\n" 509 " ccccccccccccccccccccccc: <\n" 510 " operator: 1\n" 511 " operator: 2\n" 512 " operator: 3\n" 513 " operator { key: value }\n" 514 " >\n" 515 " >\n" 516 "};"); 517 } 518 519 TEST_F(FormatTestProto, BreaksEntriesOfSubmessagesContainingSubmessages) { 520 // The column limit allows for the keys submessage to be put on 1 line, but we 521 // break it since it contains a submessage an another entry. 522 verifyFormat("option (MyProto.options) = {\n" 523 " key: valueeeeeeee\n" 524 " keys: {\n" 525 " item: 'aaaaaaaaaaaaaaaa'\n" 526 " sub <>\n" 527 " }\n" 528 "}"); 529 verifyFormat("option (MyProto.options) = {\n" 530 " key: valueeeeeeee\n" 531 " keys: {\n" 532 " item: 'aaaaaaaaaaaaaaaa'\n" 533 " sub {}\n" 534 " }\n" 535 "}"); 536 verifyFormat("option (MyProto.options) = {\n" 537 " key: valueeeeeeee\n" 538 " keys: {\n" 539 " sub {}\n" 540 " sub: <>\n" 541 " sub: []\n" 542 " }\n" 543 "}"); 544 verifyFormat("option (MyProto.options) = {\n" 545 " key: valueeeeeeee\n" 546 " keys: {\n" 547 " item: 'aaaaaaaaaaa'\n" 548 " sub { msg: 1 }\n" 549 " }\n" 550 "}"); 551 verifyFormat("option (MyProto.options) = {\n" 552 " key: valueeeeeeee\n" 553 " keys: {\n" 554 " item: 'aaaaaaaaaaa'\n" 555 " sub: { msg: 1 }\n" 556 " }\n" 557 "}"); 558 verifyFormat("option (MyProto.options) = {\n" 559 " key: valueeeeeeee\n" 560 " keys: {\n" 561 " item: 'aaaaaaaaaaa'\n" 562 " sub < msg: 1 >\n" 563 " }\n" 564 "}"); 565 verifyFormat("option (MyProto.options) = {\n" 566 " key: valueeeeeeee\n" 567 " keys: {\n" 568 " item: 'aaaaaaaaaaa'\n" 569 " sub: [ msg: 1 ]\n" 570 " }\n" 571 "}"); 572 verifyFormat("option (MyProto.options) = {\n" 573 " key: valueeeeeeee\n" 574 " keys: <\n" 575 " item: 'aaaaaaaaaaa'\n" 576 " sub: [ 1, 2 ]\n" 577 " >\n" 578 "}"); 579 verifyFormat("option (MyProto.options) = {\n" 580 " key: valueeeeeeee\n" 581 " keys: {\n" 582 " sub {}\n" 583 " item: 'aaaaaaaaaaaaaaaa'\n" 584 " }\n" 585 "}"); 586 verifyFormat("option (MyProto.options) = {\n" 587 " key: valueeeeeeee\n" 588 " keys: {\n" 589 " sub: []\n" 590 " item: 'aaaaaaaaaaaaaaaa'\n" 591 " }\n" 592 "}"); 593 verifyFormat("option (MyProto.options) = {\n" 594 " key: valueeeeeeee\n" 595 " keys: {\n" 596 " sub <>\n" 597 " item: 'aaaaaaaaaaaaaaaa'\n" 598 " }\n" 599 "}"); 600 verifyFormat("option (MyProto.options) = {\n" 601 " key: valueeeeeeee\n" 602 " keys: {\n" 603 " sub { key: value }\n" 604 " item: 'aaaaaaaaaaaaaaaa'\n" 605 " }\n" 606 "}"); 607 verifyFormat("option (MyProto.options) = {\n" 608 " key: valueeeeeeee\n" 609 " keys: {\n" 610 " sub: [ 1, 2 ]\n" 611 " item: 'aaaaaaaaaaaaaaaa'\n" 612 " }\n" 613 "}"); 614 verifyFormat("option (MyProto.options) = {\n" 615 " key: valueeeeeeee\n" 616 " keys: {\n" 617 " sub < sub_2: {} >\n" 618 " item: 'aaaaaaaaaaaaaaaa'\n" 619 " }\n" 620 "}"); 621 verifyFormat("option (MyProto.options) = {\n" 622 " key: valueeeeeeee\n" 623 " keys: {\n" 624 " item: data\n" 625 " sub: [ 1, 2 ]\n" 626 " item: 'aaaaaaaaaaaaaaaa'\n" 627 " }\n" 628 "}"); 629 verifyFormat("option (MyProto.options) = {\n" 630 " key: valueeeeeeee\n" 631 " keys: {\n" 632 " item: data\n" 633 " sub < sub_2: {} >\n" 634 " item: 'aaaaaaaaaaaaaaaa'\n" 635 " }\n" 636 "}"); 637 verifyFormat("option (MyProto.options) = {\n" 638 " sub: {\n" 639 " key: valueeeeeeee\n" 640 " keys: {\n" 641 " sub: [ 1, 2 ]\n" 642 " item: 'aaaaaaaaaaaaaaaa'\n" 643 " }\n" 644 " }\n" 645 "}"); 646 } 647 648 TEST_F(FormatTestProto, PreventBreaksBetweenKeyAndSubmessages) { 649 verifyFormat("option (MyProto.options) = {\n" 650 " submessage: {\n" 651 " key: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n" 652 " }\n" 653 "}"); 654 verifyFormat("option (MyProto.options) = {\n" 655 " submessage {\n" 656 " key: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n" 657 " }\n" 658 "}"); 659 verifyFormat("option (MyProto.options) = {\n" 660 " submessage: <\n" 661 " key: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n" 662 " >\n" 663 "}"); 664 verifyFormat("option (MyProto.options) = {\n" 665 " submessage <\n" 666 " key: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n" 667 " >\n" 668 "}"); 669 verifyFormat("option (MyProto.options) = {\n" 670 " repeatedd: [\n" 671 " 'eyaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n" 672 " ]\n" 673 "}"); 674 } 675 676 } // namespace format 677 } // end namespace clang 678