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(llvm::StringRef Code, unsigned Offset, 22 unsigned Length, 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(llvm::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(llvm::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, UnderstandsReturns) { 111 verifyFormat("rpc Search(SearchRequest) returns (SearchResponse);"); 112 } 113 114 TEST_F(FormatTestProto, MessageFieldAttributes) { 115 verifyFormat("optional string test = 1 [default = \"test\"];"); 116 verifyFormat("optional bool a = 1 [default = true, deprecated = true];"); 117 verifyFormat("optional LongMessageType long_proto_field = 1 [\n" 118 " default = REALLY_REALLY_LONG_CONSTANT_VALUE,\n" 119 " deprecated = true\n" 120 "];"); 121 verifyFormat("optional LongMessageType long_proto_field = 1\n" 122 " [default = REALLY_REALLY_LONG_CONSTANT_VALUE];"); 123 verifyFormat("repeated double value = 1\n" 124 " [(aaaaaaa.aaaaaaaaa) = { aaaaaaaaaaaaaaaaa: AAAAAAAA }];"); 125 verifyFormat("repeated double value = 1 [(aaaaaaa.aaaaaaaaa) = {\n" 126 " aaaaaaaaaaaaaaaa: AAAAAAAAAA,\n" 127 " bbbbbbbbbbbbbbbb: BBBBBBBBBB\n" 128 "}];"); 129 verifyFormat("repeated double value = 1 [(aaaaaaa.aaaaaaaaa) = {\n" 130 " aaaaaaaaaaaaaaaa: AAAAAAAAAA\n" 131 " bbbbbbbbbbbbbbbb: BBBBBBBBBB\n" 132 "}];"); 133 verifyFormat("repeated double value = 1 [\n" 134 " (aaaaaaa.aaaaaaaaa) = {\n" 135 " aaaaaaaaaaaaaaaa: AAAAAAAAAA\n" 136 " bbbbbbbbbbbbbbbb: BBBBBBBBBB\n" 137 " },\n" 138 " (bbbbbbb.bbbbbbbbb) = {\n" 139 " aaaaaaaaaaaaaaaa: AAAAAAAAAA\n" 140 " bbbbbbbbbbbbbbbb: BBBBBBBBBB\n" 141 " }\n" 142 "];"); 143 verifyFormat("repeated double value = 1 [(aaaaaaa.aaaaaaaaa) = {\n" 144 " type: \"AAAAAAAAAA\"\n" 145 " is: \"AAAAAAAAAA\"\n" 146 " or: \"BBBBBBBBBB\"\n" 147 "}];"); 148 verifyFormat("repeated double value = 1 [(aaaaaaa.aaaaaaaaa) = {\n" 149 " aaaaaaaaaaaaaaaa: AAAAAAAAAA,\n" 150 " bbbbbbb: BBBB,\n" 151 " bbbb: BBB\n" 152 "}];"); 153 verifyFormat("optional AAA aaa = 1 [\n" 154 " foo = {\n" 155 " key: 'a' //\n" 156 " },\n" 157 " bar = {\n" 158 " key: 'a' //\n" 159 " }\n" 160 "];"); 161 verifyFormat("optional string test = 1 [default = \"test\"\n" 162 " \"test\"];"); 163 verifyFormat("optional Aaaaaaaa aaaaaaaa = 12 [\n" 164 " (aaa) = aaaa,\n" 165 " (bbbbbbbbbbbbbbbbbbbbbbbbbb) = {\n" 166 " aaaaaaaaaaaaaaaaa: true,\n" 167 " aaaaaaaaaaaaaaaa: true\n" 168 " }\n" 169 "];"); 170 verifyFormat("extensions 20 [(proto2.type) = 'Aaaa.bbbb'];"); 171 verifyFormat("extensions 20\n" 172 " [(proto3.type) = 'Aaaa.bbbb', (aaa.Aaa) = 'aaa.bbb'];"); 173 verifyFormat("extensions 123 [\n" 174 " (aaa) = aaaa,\n" 175 " (bbbbbbbbbbbbbbbbbbbbbbbbbb) = {\n" 176 " aaaaaaaaaaaaaaaaa: true,\n" 177 " aaaaaaaaaaaaaaaa: true\n" 178 " }\n" 179 "];"); 180 } 181 182 TEST_F(FormatTestProto, DoesntWrapFileOptions) { 183 EXPECT_EQ( 184 "option java_package = " 185 "\"some.really.long.package.that.exceeds.the.column.limit\";", 186 format("option java_package = " 187 "\"some.really.long.package.that.exceeds.the.column.limit\";")); 188 } 189 190 TEST_F(FormatTestProto, FormatsOptions) { 191 verifyFormat("option (MyProto.options) = {\n" 192 " field_a: OK\n" 193 " field_b: \"OK\"\n" 194 " field_c: \"OK\"\n" 195 " msg_field: { field_d: 123 }\n" 196 "};"); 197 verifyFormat("option (MyProto.options) = {\n" 198 " field_a: OK\n" 199 " field_b: \"OK\"\n" 200 " field_c: \"OK\"\n" 201 " msg_field: { field_d: 123 field_e: OK }\n" 202 "};"); 203 verifyFormat("option (MyProto.options) = {\n" 204 " field_a: OK // Comment\n" 205 " field_b: \"OK\"\n" 206 " field_c: \"OK\"\n" 207 " msg_field: { field_d: 123 }\n" 208 "};"); 209 verifyFormat("option (MyProto.options) = {\n" 210 " field_c: \"OK\"\n" 211 " msg_field { field_d: 123 }\n" 212 "};"); 213 verifyFormat("option (MyProto.options) = {\n" 214 " field_a: OK\n" 215 " field_b { field_c: OK }\n" 216 " field_d: OKOKOK\n" 217 " field_e: OK\n" 218 "}"); 219 220 // Support syntax with <> instead of {}. 221 verifyFormat("option (MyProto.options) = {\n" 222 " field_c: \"OK\",\n" 223 " msg_field: < field_d: 123 >\n" 224 " empty: <>\n" 225 " empty <>\n" 226 "};"); 227 228 verifyFormat("option (MyProto.options) = {\n" 229 " field_a: OK\n" 230 " field_b < field_c: OK >\n" 231 " field_d: OKOKOK\n" 232 " field_e: OK\n" 233 "}"); 234 235 verifyFormat("option (MyProto.options) = {\n" 236 " msg_field: <>\n" 237 " field_c: \"OK\",\n" 238 " msg_field: < field_d: 123 >\n" 239 " field_e: OK\n" 240 " msg_field: < field_d: 12 >\n" 241 "};"); 242 243 verifyFormat("option (MyProto.options) = <\n" 244 " field_a: OK\n" 245 " field_b: \"OK\"\n" 246 " field_c: 1\n" 247 " field_d: 12.5\n" 248 " field_e: OK\n" 249 ">;"); 250 251 verifyFormat("option (MyProto.options) = <\n" 252 " field_a: OK,\n" 253 " field_b: \"OK\",\n" 254 " field_c: 1,\n" 255 " field_d: 12.5,\n" 256 " field_e: OK,\n" 257 ">;"); 258 259 verifyFormat("option (MyProto.options) = <\n" 260 " field_a: \"OK\"\n" 261 " msg_field: { field_b: OK }\n" 262 " field_g: OK\n" 263 " field_g: OK\n" 264 " field_g: OK\n" 265 ">;"); 266 267 verifyFormat("option (MyProto.options) = <\n" 268 " field_a: \"OK\"\n" 269 " msg_field <\n" 270 " field_b: OK\n" 271 " field_c: OK\n" 272 " field_d: OK\n" 273 " field_e: OK\n" 274 " field_f: OK\n" 275 " >\n" 276 " field_g: OK\n" 277 ">;"); 278 279 verifyFormat("option (MyProto.options) = <\n" 280 " field_a: \"OK\"\n" 281 " msg_field <\n" 282 " field_b: OK,\n" 283 " field_c: OK,\n" 284 " field_d: OK,\n" 285 " field_e: OK,\n" 286 " field_f: OK\n" 287 " >\n" 288 " field_g: OK\n" 289 ">;"); 290 291 verifyFormat("option (MyProto.options) = <\n" 292 " field_a: \"OK\"\n" 293 " msg_field: <\n" 294 " field_b: OK\n" 295 " field_c: OK\n" 296 " field_d: OK\n" 297 " field_e: OK\n" 298 " field_f: OK\n" 299 " >\n" 300 " field_g: OK\n" 301 ">;"); 302 303 verifyFormat("option (MyProto.options) = <\n" 304 " field_a: \"OK\"\n" 305 " msg_field: {\n" 306 " field_b: OK\n" 307 " field_c: OK\n" 308 " field_d: OK\n" 309 " field_e: OK\n" 310 " field_f: OK\n" 311 " }\n" 312 " field_g: OK\n" 313 ">;"); 314 315 verifyFormat("option (MyProto.options) = <\n" 316 " field_a: \"OK\"\n" 317 " msg_field {\n" 318 " field_b: OK\n" 319 " field_c: OK\n" 320 " field_d: OK\n" 321 " field_e: OK\n" 322 " field_f: OK\n" 323 " }\n" 324 " field_g: OK\n" 325 ">;"); 326 327 verifyFormat("option (MyProto.options) = {\n" 328 " field_a: \"OK\"\n" 329 " msg_field <\n" 330 " field_b: OK\n" 331 " field_c: OK\n" 332 " field_d: OK\n" 333 " field_e: OK\n" 334 " field_f: OK\n" 335 " >\n" 336 " field_g: OK\n" 337 "};"); 338 339 verifyFormat("option (MyProto.options) = {\n" 340 " field_a: \"OK\"\n" 341 " msg_field: <\n" 342 " field_b: OK\n" 343 " field_c: OK\n" 344 " field_d: OK\n" 345 " field_e: OK\n" 346 " field_f: OK\n" 347 " >\n" 348 " field_g: OK\n" 349 "};"); 350 351 verifyFormat("option (MyProto.options) = <\n" 352 " field_a: \"OK\"\n" 353 " msg_field {\n" 354 " field_b: OK\n" 355 " field_c: OK\n" 356 " field_d: OK\n" 357 " msg_field <\n" 358 " field_A: 1\n" 359 " field_B: 2\n" 360 " field_C: 3\n" 361 " field_D: 4\n" 362 " field_E: 5\n" 363 " >\n" 364 " msg_field < field_A: 1 field_B: 2 field_C: 3 f_D: 4 >\n" 365 " field_e: OK\n" 366 " field_f: OK\n" 367 " }\n" 368 " field_g: OK\n" 369 ">;"); 370 371 verifyFormat("option (MyProto.options) = <\n" 372 " data1 < key1: value1 >\n" 373 " data2 { key2: value2 }\n" 374 ">;"); 375 376 verifyFormat("option (MyProto.options) = <\n" 377 " app_id: 'com.javax.swing.salsa.latino'\n" 378 " head_id: 1\n" 379 " data < key: value >\n" 380 ">;"); 381 382 verifyFormat("option (MyProto.options) = {\n" 383 " app_id: 'com.javax.swing.salsa.latino'\n" 384 " head_id: 1\n" 385 " headheadheadheadheadhead_id: 1\n" 386 " product_data { product { 1 } }\n" 387 "};"); 388 } 389 390 TEST_F(FormatTestProto, FormatsService) { 391 verifyFormat("service SearchService {\n" 392 " rpc Search(SearchRequest) returns (SearchResponse) {\n" 393 " option foo = true;\n" 394 " }\n" 395 "};"); 396 } 397 398 TEST_F(FormatTestProto, ExtendingMessage) { 399 verifyFormat("extend .foo.Bar {}"); 400 } 401 402 TEST_F(FormatTestProto, FormatsImports) { 403 verifyFormat("import \"a.proto\";\n" 404 "import \"b.proto\";\n" 405 "// comment\n" 406 "message A {}"); 407 408 verifyFormat("import public \"a.proto\";\n" 409 "import \"b.proto\";\n" 410 "// comment\n" 411 "message A {}"); 412 413 // Missing semicolons should not confuse clang-format. 414 verifyFormat("import \"a.proto\"\n" 415 "import \"b.proto\"\n" 416 "// comment\n" 417 "message A {}"); 418 } 419 420 TEST_F(FormatTestProto, KeepsLongStringLiteralsOnSameLine) { 421 verifyFormat( 422 "option (MyProto.options) = {\n" 423 " foo: {\n" 424 " text: \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasaaaaaaaa\"\n" 425 " }\n" 426 "}"); 427 } 428 429 TEST_F(FormatTestProto, FormatsOptionsExtensions) { 430 verifyFormat("option (MyProto.options) = {\n" 431 " msg_field: { field_d: 123 }\n" 432 " [ext.t/u] { key: value }\n" 433 " key: value\n" 434 " [t.u/v] <\n" 435 " [ext] { key: value }\n" 436 " >\n" 437 "};"); 438 } 439 440 TEST_F(FormatTestProto, SpacesAroundPercents) { 441 verifyFormat("option (MyProto.options) = {\n" 442 " key: %lld\n" 443 " key: 0x%04x\n" 444 " key: \"%d %d\"\n" 445 "};"); 446 } 447 448 TEST_F(FormatTestProto, FormatsRepeatedListInitializersInOptions) { 449 verifyFormat("option (MyProto.options) = {\n" 450 " key: item\n" 451 " keys: [\n" 452 " 'ala',\n" 453 " 'bala',\n" 454 " 'porto',\n" 455 " 'kala',\n" 456 " 'too',\n" 457 " 'long',\n" 458 " 'long',\n" 459 " 'long'\n" 460 " ]\n" 461 " key: [ item ]\n" 462 " msg {\n" 463 " key: item\n" 464 " keys: [\n" 465 " 'ala',\n" 466 " 'bala',\n" 467 " 'porto',\n" 468 " 'kala',\n" 469 " 'too',\n" 470 " 'long',\n" 471 " 'long'\n" 472 " ]\n" 473 " }\n" 474 " key: value\n" 475 "};"); 476 } 477 478 TEST_F(FormatTestProto, AcceptsOperatorAsKeyInOptions) { 479 verifyFormat("option (MyProto.options) = {\n" 480 " bbbbbbbbb: <\n" 481 " ccccccccccccccccccccccc: <\n" 482 " operator: 1\n" 483 " operator: 2\n" 484 " operator: 3\n" 485 " operator { key: value }\n" 486 " >\n" 487 " >\n" 488 "};"); 489 } 490 491 TEST_F(FormatTestProto, BreaksEntriesOfSubmessagesContainingSubmessages) { 492 FormatStyle Style = getGoogleStyle(FormatStyle::LK_TextProto); 493 Style.ColumnLimit = 60; 494 // The column limit allows for the keys submessage to be put on 1 line, but we 495 // break it since it contains a submessage an another entry. 496 verifyFormat("option (MyProto.options) = {\n" 497 " key: valueeeeeeee\n" 498 " keys: {\n" 499 " item: 'aaaaaaaaaaaaaaaa'\n" 500 " sub <>\n" 501 " }\n" 502 "}"); 503 verifyFormat("option (MyProto.options) = {\n" 504 " key: valueeeeeeee\n" 505 " keys: {\n" 506 " item: 'aaaaaaaaaaaaaaaa'\n" 507 " sub {}\n" 508 " }\n" 509 "}"); 510 verifyFormat("option (MyProto.options) = {\n" 511 " key: valueeeeeeee\n" 512 " keys: {\n" 513 " sub {}\n" 514 " sub: <>\n" 515 " sub: []\n" 516 " }\n" 517 "}"); 518 verifyFormat("option (MyProto.options) = {\n" 519 " key: valueeeeeeee\n" 520 " keys: {\n" 521 " item: 'aaaaaaaaaaa'\n" 522 " sub { msg: 1 }\n" 523 " }\n" 524 "}"); 525 verifyFormat("option (MyProto.options) = {\n" 526 " key: valueeeeeeee\n" 527 " keys: {\n" 528 " item: 'aaaaaaaaaaa'\n" 529 " sub: { msg: 1 }\n" 530 " }\n" 531 "}"); 532 verifyFormat("option (MyProto.options) = {\n" 533 " key: valueeeeeeee\n" 534 " keys: {\n" 535 " item: 'aaaaaaaaaaa'\n" 536 " sub < msg: 1 >\n" 537 " }\n" 538 "}"); 539 verifyFormat("option (MyProto.options) = {\n" 540 " key: valueeeeeeee\n" 541 " keys: {\n" 542 " item: 'aaaaaaaaaaa'\n" 543 " sub: [ msg: 1 ]\n" 544 " }\n" 545 "}"); 546 verifyFormat("option (MyProto.options) = {\n" 547 " key: valueeeeeeee\n" 548 " keys: <\n" 549 " item: 'aaaaaaaaaaa'\n" 550 " sub: [ 1, 2 ]\n" 551 " >\n" 552 "}"); 553 verifyFormat("option (MyProto.options) = {\n" 554 " key: valueeeeeeee\n" 555 " keys: {\n" 556 " sub {}\n" 557 " item: 'aaaaaaaaaaaaaaaa'\n" 558 " }\n" 559 "}"); 560 verifyFormat("option (MyProto.options) = {\n" 561 " key: valueeeeeeee\n" 562 " keys: {\n" 563 " sub: []\n" 564 " item: 'aaaaaaaaaaaaaaaa'\n" 565 " }\n" 566 "}"); 567 verifyFormat("option (MyProto.options) = {\n" 568 " key: valueeeeeeee\n" 569 " keys: {\n" 570 " sub <>\n" 571 " item: 'aaaaaaaaaaaaaaaa'\n" 572 " }\n" 573 "}"); 574 verifyFormat("option (MyProto.options) = {\n" 575 " key: valueeeeeeee\n" 576 " keys: {\n" 577 " sub { key: value }\n" 578 " item: 'aaaaaaaaaaaaaaaa'\n" 579 " }\n" 580 "}"); 581 verifyFormat("option (MyProto.options) = {\n" 582 " key: valueeeeeeee\n" 583 " keys: {\n" 584 " sub: [ 1, 2 ]\n" 585 " item: 'aaaaaaaaaaaaaaaa'\n" 586 " }\n" 587 "}"); 588 verifyFormat("option (MyProto.options) = {\n" 589 " key: valueeeeeeee\n" 590 " keys: {\n" 591 " sub < sub_2: {} >\n" 592 " item: 'aaaaaaaaaaaaaaaa'\n" 593 " }\n" 594 "}"); 595 verifyFormat("option (MyProto.options) = {\n" 596 " key: valueeeeeeee\n" 597 " keys: {\n" 598 " item: data\n" 599 " sub: [ 1, 2 ]\n" 600 " item: 'aaaaaaaaaaaaaaaa'\n" 601 " }\n" 602 "}"); 603 verifyFormat("option (MyProto.options) = {\n" 604 " key: valueeeeeeee\n" 605 " keys: {\n" 606 " item: data\n" 607 " sub < sub_2: {} >\n" 608 " item: 'aaaaaaaaaaaaaaaa'\n" 609 " }\n" 610 "}"); 611 verifyFormat("option (MyProto.options) = {\n" 612 " sub: {\n" 613 " key: valueeeeeeee\n" 614 " keys: {\n" 615 " sub: [ 1, 2 ]\n" 616 " item: 'aaaaaaaaaaaaaaaa'\n" 617 " }\n" 618 " }\n" 619 "}"); 620 } 621 622 TEST_F(FormatTestProto, PreventBreaksBetweenKeyAndSubmessages) { 623 verifyFormat("option (MyProto.options) = {\n" 624 " submessage: {\n" 625 " key: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n" 626 " }\n" 627 "}"); 628 verifyFormat("option (MyProto.options) = {\n" 629 " submessage {\n" 630 " key: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n" 631 " }\n" 632 "}"); 633 verifyFormat("option (MyProto.options) = {\n" 634 " submessage: <\n" 635 " key: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n" 636 " >\n" 637 "}"); 638 verifyFormat("option (MyProto.options) = {\n" 639 " submessage <\n" 640 " key: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n" 641 " >\n" 642 "}"); 643 verifyFormat("option (MyProto.options) = {\n" 644 " repeatedd: [\n" 645 " 'eyaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n" 646 " ]\n" 647 "}"); 648 } 649 650 651 } // end namespace tooling 652 } // end namespace clang 653