clang/unittests/Format/FormatTestRawStrings.cpp

   1 //===- unittest/Format/FormatTestRawStrings.cpp - Formatting 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 "../Tooling/ReplacementTest.h"
  12 #include "FormatTestUtils.h"
  13
  14 #include "llvm/Support/Debug.h"
  15 #include "llvm/Support/MemoryBuffer.h"
  16 #include "gtest/gtest.h"
  17
  18 #define DEBUG_TYPE "format-test"
  19
  20 namespace clang {
  21 namespace format {
  22 namespace {
  23
  24 class FormatTestRawStrings : public ::testing::Test {
  25 protected:
  26   enum StatusCheck { SC_ExpectComplete, SC_ExpectIncomplete, SC_DoNotCheck };
  27
  28   std::string format(llvm::StringRef Code,
  29                      const FormatStyle &Style = getLLVMStyle(),
  30                      StatusCheck CheckComplete = SC_ExpectComplete) {
  31     LLVM_DEBUG(llvm::errs() << "---\n");
  32     LLVM_DEBUG(llvm::errs() << Code << "\n\n");
  33     std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
  34     FormattingAttemptStatus Status;
  35     tooling::Replacements Replaces =
  36         reformat(Style, Code, Ranges, "<stdin>", &Status);
  37     if (CheckComplete != SC_DoNotCheck) {
  38       bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete;
  39       EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete)
  40           << Code << "\n\n";
  41     }
  42     ReplacementCount = Replaces.size();
  43     auto Result = applyAllReplacements(Code, Replaces);
  44     EXPECT_TRUE(static_cast<bool>(Result));
  45     LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
  46     return *Result;
  47   }
  48
  49   FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) {
  50     Style.ColumnLimit = ColumnLimit;
  51     return Style;
  52   }
  53
  54   FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) {
  55     return getStyleWithColumns(getLLVMStyle(), ColumnLimit);
  56   }
  57
  58   int ReplacementCount;
  59
  60   FormatStyle getRawStringPbStyleWithColumns(unsigned ColumnLimit) {
  61     FormatStyle Style = getLLVMStyle();
  62     Style.ColumnLimit = ColumnLimit;
  63     Style.RawStringFormats = {
  64         {
  65             /*Language=*/FormatStyle::LK_TextProto,
  66             /*Delimiters=*/{"pb"},
  67             /*EnclosingFunctions=*/{},
  68             /*CanonicalDelimiter=*/"",
  69             /*BasedOnStyle=*/"google",
  70         },
  71     };
  72     return Style;
  73   }
  74
  75   FormatStyle getRawStringLLVMCppStyleBasedOn(std::string BasedOnStyle) {
  76     FormatStyle Style = getLLVMStyle();
  77     Style.RawStringFormats = {
  78         {
  79             /*Language=*/FormatStyle::LK_Cpp,
  80             /*Delimiters=*/{"cpp"},
  81             /*EnclosingFunctions=*/{},
  82             /*CanonicalDelimiter=*/"",
  83             BasedOnStyle,
  84         },
  85     };
  86     return Style;
  87   }
  88
  89   FormatStyle getRawStringGoogleCppStyleBasedOn(std::string BasedOnStyle) {
  90     FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
  91     Style.RawStringFormats = {
  92         {
  93             /*Language=*/FormatStyle::LK_Cpp,
  94             /*Delimiters=*/{"cpp"},
  95             /*EnclosingFunctions=*/{},
  96             /*CanonicalDelimiter=*/"",
  97             BasedOnStyle,
  98         },
  99     };
 100     return Style;
 101   }
 102
 103   // Gcc 4.8 doesn't support raw string literals in macros, which breaks some
 104   // build bots. We use this function instead.
 105   void expect_eq(const std::string Expected, const std::string Actual) {
 106     EXPECT_EQ(Expected, Actual);
 107   }
 108 };
 109
 110 TEST_F(FormatTestRawStrings, ReformatsAccordingToBaseStyle) {
 111   // llvm style puts '*' on the right.
 112   // google style puts '*' on the left.
 113
 114   // Use the llvm style if the raw string style has no BasedOnStyle.
 115   expect_eq(R"test(int *i = R"cpp(int *p = nullptr;)cpp")test",
 116             format(R"test(int * i = R"cpp(int * p = nullptr;)cpp")test",
 117                    getRawStringLLVMCppStyleBasedOn("")));
 118
 119   // Use the google style if the raw string style has BasedOnStyle=google.
 120   expect_eq(R"test(int *i = R"cpp(int* p = nullptr;)cpp")test",
 121             format(R"test(int * i = R"cpp(int * p = nullptr;)cpp")test",
 122                    getRawStringLLVMCppStyleBasedOn("google")));
 123
 124   // Use the llvm style if the raw string style has no BasedOnStyle=llvm.
 125   expect_eq(R"test(int* i = R"cpp(int *p = nullptr;)cpp")test",
 126             format(R"test(int * i = R"cpp(int * p = nullptr;)cpp")test",
 127                    getRawStringGoogleCppStyleBasedOn("llvm")));
 128 }
 129
 130 TEST_F(FormatTestRawStrings, UsesConfigurationOverBaseStyle) {
 131   // llvm style puts '*' on the right.
 132   // google style puts '*' on the left.
 133
 134   // Uses the configured google style inside raw strings even if BasedOnStyle in
 135   // the raw string format is llvm.
 136   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
 137   EXPECT_EQ(0, parseConfiguration("---\n"
 138                                   "Language: Cpp\n"
 139                                   "BasedOnStyle: Google",
 140                                   &Style)
 141                    .value());
 142   Style.RawStringFormats = {{
 143       FormatStyle::LK_Cpp,
 144       {"cpp"},
 145       {},
 146       /*CanonicalDelimiter=*/"",
 147       /*BasedOnStyle=*/"llvm",
 148   }};
 149   expect_eq(R"test(int* i = R"cpp(int* j = 0;)cpp";)test",
 150             format(R"test(int * i = R"cpp(int * j = 0;)cpp";)test", Style));
 151 }
 152
 153 TEST_F(FormatTestRawStrings, MatchesDelimitersCaseSensitively) {
 154   // Don't touch the 'PB' raw string, format the 'pb' raw string.
 155   expect_eq(R"test(
 156 s = R"PB(item:1)PB";
 157 t = R"pb(item: 1)pb";)test",
 158             format(R"test(
 159 s = R"PB(item:1)PB";
 160 t = R"pb(item:1)pb";)test",
 161                    getRawStringPbStyleWithColumns(40)));
 162 }
 163
 164 TEST_F(FormatTestRawStrings, RespectsClangFormatOff) {
 165   expect_eq(R"test(
 166 // clang-format off
 167 s = R"pb(item:      1)pb";
 168 // clang-format on
 169 t = R"pb(item: 1)pb";)test",
 170             format(R"test(
 171 // clang-format off
 172 s = R"pb(item:      1)pb";
 173 // clang-format on
 174 t = R"pb(item:      1)pb";)test",
 175                    getRawStringPbStyleWithColumns(40)));
 176 }
 177
 178 TEST_F(FormatTestRawStrings, ReformatsShortRawStringsOnSingleLine) {
 179   expect_eq(R"test(P p = TP(R"pb()pb");)test",
 180             format(R"test(P p = TP(R"pb( )pb");)test",
 181                    getRawStringPbStyleWithColumns(40)));
 182   expect_eq(R"test(P p = TP(R"pb(item_1: 1)pb");)test",
 183             format(R"test(P p = TP(R"pb(item_1:1)pb");)test",
 184                    getRawStringPbStyleWithColumns(40)));
 185   expect_eq(R"test(P p = TP(R"pb(item_1: 1)pb");)test",
 186             format(R"test(P p = TP(R"pb(  item_1 :  1   )pb");)test",
 187                    getRawStringPbStyleWithColumns(40)));
 188   expect_eq(R"test(P p = TP(R"pb(item_1: 1 item_2: 2)pb");)test",
 189             format(R"test(P p = TP(R"pb(item_1:1 item_2:2)pb");)test",
 190                    getRawStringPbStyleWithColumns(40)));
 191   // Merge two short lines into one.
 192   expect_eq(R"test(
 193 std::string s = R"pb(
 194   item_1: 1 item_2: 2
 195 )pb";
 196 )test",
 197             format(R"test(
 198 std::string s = R"pb(
 199   item_1:1
 200   item_2:2
 201 )pb";
 202 )test",
 203                    getRawStringPbStyleWithColumns(40)));
 204 }
 205
 206 TEST_F(FormatTestRawStrings, BreaksShortRawStringsWhenNeeded) {
 207   // The raw string contains multiple submessage entries, so break for
 208   // readability.
 209   expect_eq(R"test(
 210 P p = TP(R"pb(item_1 < 1 >
 211               item_2: { 2 })pb");)test",
 212             format(
 213                 R"test(
 214 P p = TP(R"pb(item_1<1> item_2:{2})pb");)test",
 215                 getRawStringPbStyleWithColumns(40)));
 216 }
 217
 218 TEST_F(FormatTestRawStrings, BreaksRawStringsExceedingColumnLimit) {
 219   expect_eq(R"test(
 220 P p = TPPPPPPPPPPPPPPP(
 221     R"pb(item_1: 1, item_2: 2)pb");)test",
 222             format(R"test(
 223 P p = TPPPPPPPPPPPPPPP(R"pb(item_1: 1, item_2: 2)pb");)test",
 224                    getRawStringPbStyleWithColumns(40)));
 225
 226   expect_eq(R"test(
 227 P p =
 228     TPPPPPPPPPPPPPPP(
 229         R"pb(item_1: 1,
 230              item_2: 2,
 231              item_3: 3)pb");)test",
 232             format(R"test(
 233 P p = TPPPPPPPPPPPPPPP(R"pb(item_1: 1, item_2: 2, item_3: 3)pb");)test",
 234                    getRawStringPbStyleWithColumns(40)));
 235
 236   expect_eq(R"test(
 237 P p = TP(R"pb(item_1 < 1 >
 238               item_2: < 2 >
 239               item_3 {})pb");)test",
 240             format(R"test(
 241 P p = TP(R"pb(item_1<1> item_2:<2> item_3{ })pb");)test",
 242                    getRawStringPbStyleWithColumns(40)));
 243
 244   expect_eq(
 245       R"test(
 246 P p = TP(R"pb(item_1: 1,
 247               item_2: 2,
 248               item_3: 3,
 249               item_4: 4)pb");)test",
 250       format(
 251           R"test(
 252 P p = TP(R"pb(item_1: 1, item_2: 2, item_3: 3, item_4: 4)pb");)test",
 253           getRawStringPbStyleWithColumns(40)));
 254
 255   expect_eq(R"test(
 256 P p = TPPPPPPPPPPPPPPP(
 257     R"pb(item_1 < 1 >,
 258          item_2: { 2 },
 259          item_3: < 3 >,
 260          item_4: { 4 })pb");)test",
 261             format(R"test(
 262 P p = TPPPPPPPPPPPPPPP(R"pb(item_1<1>, item_2: {2}, item_3: <3>, item_4:{4})pb");)test",
 263                    getRawStringPbStyleWithColumns(40)));
 264
 265   // Breaks before a short raw string exceeding the column limit.
 266   expect_eq(R"test(
 267 FFFFFFFFFFFFFFFFFFFFFFFFFFF(
 268     R"pb(key: 1)pb");
 269 P p = TPPPPPPPPPPPPPPPPPPPP(
 270     R"pb(key: 2)pb");
 271 auto TPPPPPPPPPPPPPPPPPPPP =
 272     R"pb(key: 3)pb";
 273 P p = TPPPPPPPPPPPPPPPPPPPP(
 274     R"pb(i: 1, j: 2)pb");
 275
 276 int f(string s) {
 277   FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF(
 278       R"pb(key: 1)pb");
 279   P p = TPPPPPPPPPPPPPPPPPPPP(
 280       R"pb(key: 2)pb");
 281   auto TPPPPPPPPPPPPPPPPPPPP =
 282       R"pb(key: 3)pb";
 283   if (s.empty())
 284     P p = TPPPPPPPPPPPPPPPPPPPP(
 285         R"pb(i: 1, j: 2)pb");
 286 }
 287 )test",
 288             format(R"test(
 289 FFFFFFFFFFFFFFFFFFFFFFFFFFF(R"pb(key:1)pb");
 290 P p = TPPPPPPPPPPPPPPPPPPPP(R"pb(key:2)pb");
 291 auto TPPPPPPPPPPPPPPPPPPPP = R"pb(key:3)pb";
 292 P p = TPPPPPPPPPPPPPPPPPPPP(R"pb(i: 1, j:2)pb");
 293
 294 int f(string s) {
 295   FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF(R"pb(key:1)pb");
 296   P p = TPPPPPPPPPPPPPPPPPPPP(R"pb(key:2)pb");
 297   auto TPPPPPPPPPPPPPPPPPPPP = R"pb(key:3)pb";
 298   if (s.empty())
 299     P p = TPPPPPPPPPPPPPPPPPPPP(R"pb(i: 1, j:2)pb");
 300 }
 301 )test",
 302                    getRawStringPbStyleWithColumns(40)));
 303 }
 304
 305 TEST_F(FormatTestRawStrings, FormatsRawStringArguments) {
 306   expect_eq(R"test(
 307 P p = TP(R"pb(key { 1 })pb", param_2);)test",
 308             format(R"test(
 309 P p = TP(R"pb(key{1})pb",param_2);)test",
 310                    getRawStringPbStyleWithColumns(40)));
 311
 312   expect_eq(R"test(
 313 PPPPPPPPPPPPP(R"pb(keykeyk)pb",
 314               param_2);)test",
 315             format(R"test(
 316 PPPPPPPPPPPPP(R"pb(keykeyk)pb", param_2);)test",
 317                    getRawStringPbStyleWithColumns(40)));
 318
 319   expect_eq(R"test(
 320 P p = TP(
 321     R"pb(item: { i: 1, s: 's' }
 322          item: { i: 2, s: 't' })pb");)test",
 323             format(R"test(
 324 P p = TP(R"pb(item: {i: 1, s: 's'} item: {i: 2, s: 't'})pb");)test",
 325                    getRawStringPbStyleWithColumns(40)));
 326   expect_eq(R"test(
 327 FFFFFFFFFFFFFFFFFFF(
 328     R"pb(key: "value")pb",
 329     R"pb(key2: "value")pb");)test",
 330             format(R"test(
 331 FFFFFFFFFFFFFFFFFFF(R"pb(key: "value")pb", R"pb(key2: "value")pb");)test",
 332                    getRawStringPbStyleWithColumns(40)));
 333
 334   // Formats the first out of two arguments.
 335   expect_eq(R"test(
 336 FFFFFFFF(R"pb(key: 1)pb", argument2);
 337 struct S {
 338   const s =
 339       f(R"pb(key: 1)pb", argument2);
 340   void f() {
 341     if (gol)
 342       return g(R"pb(key: 1)pb",
 343                132789237);
 344     return g(R"pb(key: 1)pb", "172893");
 345   }
 346 };)test",
 347             format(R"test(
 348 FFFFFFFF(R"pb(key:1)pb", argument2);
 349 struct S {
 350 const s = f(R"pb(key:1)pb", argument2);
 351 void f() {
 352   if (gol)
 353     return g(R"pb(key:1)pb", 132789237);
 354   return g(R"pb(key:1)pb", "172893");
 355 }
 356 };)test",
 357                    getRawStringPbStyleWithColumns(40)));
 358
 359   // Formats the second out of two arguments.
 360   expect_eq(R"test(
 361 FFFFFFFF(argument1, R"pb(key: 2)pb");
 362 struct S {
 363   const s =
 364       f(argument1, R"pb(key: 2)pb");
 365   void f() {
 366     if (gol)
 367       return g(12784137,
 368                R"pb(key: 2)pb");
 369     return g(17283122, R"pb(key: 2)pb");
 370   }
 371 };)test",
 372             format(R"test(
 373 FFFFFFFF(argument1, R"pb(key:2)pb");
 374 struct S {
 375 const s = f(argument1, R"pb(key:2)pb");
 376 void f() {
 377   if (gol)
 378     return g(12784137, R"pb(key:2)pb");
 379   return g(17283122, R"pb(key:2)pb");
 380 }
 381 };)test",
 382                    getRawStringPbStyleWithColumns(40)));
 383
 384   // Formats two short raw string arguments.
 385   expect_eq(R"test(
 386 FFFFF(R"pb(key: 1)pb", R"pb(key: 2)pb");)test",
 387             format(R"test(
 388 FFFFF(R"pb(key:1)pb", R"pb(key:2)pb");)test",
 389                    getRawStringPbStyleWithColumns(40)));
 390   // TODO(krasimir): The original source code fits on one line, so the
 391   // non-optimizing formatter is chosen. But after the formatting in protos is
 392   // made, the code doesn't fit on one line anymore and further formatting
 393   // splits it.
 394   //
 395   // Should we disable raw string formatting for the non-optimizing formatter?
 396   expect_eq(R"test(
 397 FFFFFFF(R"pb(key: 1)pb", R"pb(key: 2)pb");)test",
 398             format(R"test(
 399 FFFFFFF(R"pb(key:1)pb", R"pb(key:2)pb");)test",
 400                    getRawStringPbStyleWithColumns(40)));
 401
 402   // Formats two short raw string arguments, puts second on newline.
 403   expect_eq(R"test(
 404 FFFFFFFF(R"pb(key: 1)pb",
 405          R"pb(key: 2)pb");)test",
 406             format(R"test(
 407 FFFFFFFF(R"pb(key:1)pb", R"pb(key:2)pb");)test",
 408                    getRawStringPbStyleWithColumns(40)));
 409
 410   // Formats both arguments.
 411   expect_eq(R"test(
 412 FFFFFFFF(R"pb(key: 1)pb",
 413          R"pb(key: 2)pb");
 414 struct S {
 415   const s = f(R"pb(key: 1)pb",
 416               R"pb(key: 2)pb");
 417   void f() {
 418     if (gol)
 419       return g(R"pb(key: 1)pb",
 420                R"pb(key: 2)pb");
 421     return g(R"pb(k1)pb", R"pb(k2)pb");
 422   }
 423 };)test",
 424             format(R"test(
 425 FFFFFFFF(R"pb(key:1)pb", R"pb(key:2)pb");
 426 struct S {
 427 const s = f(R"pb(key:1)pb", R"pb(key:2)pb");
 428 void f() {
 429   if (gol)
 430     return g(R"pb(key:1)pb", R"pb(key:2)pb");
 431   return g(R"pb( k1 )pb", R"pb( k2 )pb");
 432 }
 433 };)test",
 434                    getRawStringPbStyleWithColumns(40)));
 435 }
 436
 437 TEST_F(FormatTestRawStrings, RawStringStartingWithNewlines) {
 438   expect_eq(R"test(
 439 std::string s = R"pb(
 440   item_1: 1
 441 )pb";
 442 )test",
 443             format(R"test(
 444 std::string s = R"pb(
 445     item_1:1
 446 )pb";
 447 )test",
 448                    getRawStringPbStyleWithColumns(40)));
 449
 450   expect_eq(R"test(
 451 std::string s = R"pb(
 452
 453   item_1: 1
 454 )pb";
 455 )test",
 456             format(R"test(
 457 std::string s = R"pb(
 458
 459     item_1:1
 460 )pb";
 461 )test",
 462                    getRawStringPbStyleWithColumns(40)));
 463
 464   expect_eq(R"test(
 465 std::string s = R"pb(
 466   item_1: 1
 467 )pb";
 468 )test",
 469             format(R"test(
 470 std::string s = R"pb(
 471     item_1:1
 472
 473 )pb";
 474 )test",
 475                    getRawStringPbStyleWithColumns(40)));
 476
 477   expect_eq(R"test(
 478 std::string s = R"pb(
 479   item_1: 1,
 480   item_2: 2
 481 )pb";
 482 )test",
 483             format(R"test(
 484 std::string s = R"pb(
 485   item_1:1, item_2:2
 486 )pb";
 487 )test",
 488                    getRawStringPbStyleWithColumns(40)));
 489
 490   expect_eq(R"test(
 491 std::string s = R"pb(
 492   book {
 493     title: "Alice's Adventures"
 494     author: "Lewis Caroll"
 495   }
 496   book {
 497     title: "Peter Pan"
 498     author: "J. M. Barrie"
 499   }
 500 )pb";
 501 )test",
 502             format(R"test(
 503 std::string s = R"pb(
 504     book { title: "Alice's Adventures" author: "Lewis Caroll" }
 505     book { title: "Peter Pan" author: "J. M. Barrie" }
 506 )pb";
 507 )test",
 508                    getRawStringPbStyleWithColumns(40)));
 509 }
 510
 511 TEST_F(FormatTestRawStrings, BreaksBeforeRawStrings) {
 512   expect_eq(R"test(
 513 ASSERT_TRUE(
 514     ParseFromString(R"pb(item_1: 1)pb"),
 515     ptr);)test",
 516             format(R"test(
 517 ASSERT_TRUE(ParseFromString(R"pb(item_1: 1)pb"), ptr);)test",
 518                    getRawStringPbStyleWithColumns(40)));
 519
 520   expect_eq(R"test(
 521 ASSERT_TRUE(toolong::ParseFromString(
 522                 R"pb(item_1: 1)pb"),
 523             ptr);)test",
 524             format(R"test(
 525 ASSERT_TRUE(toolong::ParseFromString(R"pb(item_1: 1)pb"), ptr);)test",
 526                    getRawStringPbStyleWithColumns(40)));
 527
 528   expect_eq(R"test(
 529 ASSERT_TRUE(ParseFromString(
 530                 R"pb(item_1: 1,
 531                      item_2: 2)pb"),
 532             ptr);)test",
 533             format(R"test(
 534 ASSERT_TRUE(ParseFromString(R"pb(item_1: 1, item_2: 2)pb"), ptr);)test",
 535                    getRawStringPbStyleWithColumns(40)));
 536
 537   expect_eq(R"test(
 538 ASSERT_TRUE(
 539     ParseFromString(
 540         R"pb(item_1: 1 item_2: 2)pb"),
 541     ptr);)test",
 542             format(R"test(
 543 ASSERT_TRUE(ParseFromString(R"pb(item_1: 1 item_2: 2)pb"), ptr);)test",
 544                    getRawStringPbStyleWithColumns(40)));
 545 }
 546
 547 TEST_F(FormatTestRawStrings, RawStringsInOperands) {
 548   // Formats the raw string first operand of a binary operator expression.
 549   expect_eq(R"test(auto S = R"pb(item_1: 1)pb" + rest;)test",
 550             format(R"test(auto S = R"pb(item_1:1)pb" + rest;)test",
 551                    getRawStringPbStyleWithColumns(40)));
 552
 553   expect_eq(R"test(
 554 auto S = R"pb(item_1: 1, item_2: 2)pb" +
 555          rest;)test",
 556             format(R"test(
 557 auto S = R"pb(item_1:1,item_2:2)pb"+rest;)test",
 558                    getRawStringPbStyleWithColumns(40)));
 559
 560   expect_eq(R"test(
 561 auto S =
 562     R"pb(item_1: 1 item_2: 2)pb" + rest;)test",
 563             format(R"test(
 564 auto S = R"pb(item_1:1 item_2:2)pb"+rest;)test",
 565                    getRawStringPbStyleWithColumns(40)));
 566
 567   // `rest` fits on the line after )pb", but forced on newline since the raw
 568   // string literal is multiline.
 569   expect_eq(R"test(
 570 auto S = R"pb(item_1: 1,
 571               item_2: 2,
 572               item_3: 3)pb" +
 573          rest;)test",
 574             format(R"test(
 575 auto S = R"pb(item_1:1,item_2:2,item_3:3)pb"+rest;)test",
 576                    getRawStringPbStyleWithColumns(40)));
 577
 578   expect_eq(R"test(
 579 auto S = R"pb(item_1: 1,
 580               item_2: 2,
 581               item_3: 3)pb" +
 582          longlongrest;)test",
 583             format(R"test(
 584 auto S = R"pb(item_1:1,item_2:2,item_3:3)pb"+longlongrest;)test",
 585                    getRawStringPbStyleWithColumns(40)));
 586
 587   // Formats the raw string second operand of a binary operator expression.
 588   expect_eq(R"test(auto S = first + R"pb(item_1: 1)pb";)test",
 589             format(R"test(auto S = first + R"pb(item_1:1)pb";)test",
 590                    getRawStringPbStyleWithColumns(40)));
 591
 592   expect_eq(R"test(
 593 auto S = first + R"pb(item_1: 1,
 594                       item_2: 2)pb";)test",
 595             format(R"test(
 596 auto S = first+R"pb(item_1:1,item_2:2)pb";)test",
 597                    getRawStringPbStyleWithColumns(40)));
 598
 599   expect_eq(R"test(
 600 auto S = first + R"pb(item_1: 1
 601                       item_2: 2)pb";)test",
 602             format(R"test(
 603 auto S = first+R"pb(item_1:1 item_2:2)pb";)test",
 604                    getRawStringPbStyleWithColumns(40)));
 605
 606   expect_eq(R"test(
 607 auto S = R"pb(item_1: 1,
 608               item_2: 2,
 609               item_3: 3)pb" +
 610          rest;)test",
 611             format(R"test(
 612 auto S = R"pb(item_1:1,item_2:2,item_3:3)pb"+rest;)test",
 613                    getRawStringPbStyleWithColumns(40)));
 614
 615   expect_eq(R"test(
 616 auto S = R"pb(item_1: 1,
 617               item_2: 2,
 618               item_3: 3)pb" +
 619          longlongrest;)test",
 620             format(R"test(
 621 auto S = R"pb(item_1:1,item_2:2,item_3:3)pb"+longlongrest;)test",
 622                    getRawStringPbStyleWithColumns(40)));
 623
 624   // Formats the raw string operands in expressions.
 625   expect_eq(R"test(
 626 auto S = R"pb(item_1: 1)pb" +
 627          R"pb(item_2: 2)pb";
 628 )test",
 629             format(R"test(
 630 auto S=R"pb(item_1:1)pb"+R"pb(item_2:2)pb";
 631 )test",
 632                    getRawStringPbStyleWithColumns(40)));
 633
 634   expect_eq(R"test(
 635 auto S = R"pb(item_1: 1)pb" +
 636          R"pb(item_2: 2)pb" +
 637          R"pb(item_3: 3)pb";
 638 )test",
 639             format(R"test(
 640 auto S=R"pb(item_1:1)pb"+R"pb(item_2:2)pb"+R"pb(item_3:3)pb";
 641 )test",
 642                    getRawStringPbStyleWithColumns(40)));
 643
 644   expect_eq(R"test(
 645 auto S = (count < 3)
 646              ? R"pb(item_1: 1)pb"
 647              : R"pb(item_2: 2)pb";
 648 )test",
 649             format(R"test(
 650 auto S=(count<3)?R"pb(item_1:1)pb":R"pb(item_2:2)pb";
 651 )test",
 652                    getRawStringPbStyleWithColumns(40)));
 653
 654   expect_eq(R"test(
 655 auto S =
 656     (count < 3)
 657         ? R"pb(item_1: 1, item_2: 2)pb"
 658         : R"pb(item_3: 3)pb";
 659 )test",
 660             format(R"test(
 661 auto S=(count<3)?R"pb(item_1:1,item_2:2)pb":R"pb(item_3:3)pb";
 662 )test",
 663                    getRawStringPbStyleWithColumns(40)));
 664
 665   expect_eq(R"test(
 666 auto S =
 667     (count < 3)
 668         ? R"pb(item_1: 1)pb"
 669         : R"pb(item_2: 2, item_3: 3)pb";
 670 )test",
 671             format(R"test(
 672 auto S=(count<3)?R"pb(item_1:1)pb":R"pb(item_2:2,item_3:3)pb";
 673 )test",
 674                    getRawStringPbStyleWithColumns(40)));
 675 }
 676
 677 TEST_F(FormatTestRawStrings, PrefixAndSuffixAlignment) {
 678   // Keep the suffix at the end of line if not on newline.
 679   expect_eq(R"test(
 680 int s() {
 681   auto S = PTP(
 682       R"pb(
 683         item_1: 1,
 684         item_2: 2)pb");
 685 })test",
 686             format(R"test(
 687 int s() {
 688   auto S = PTP(
 689       R"pb(
 690       item_1: 1,
 691       item_2: 2)pb");
 692 })test",
 693                    getRawStringPbStyleWithColumns(20)));
 694
 695   // Align the suffix with the surrounding indent if the prefix is not on
 696   // a line of its own.
 697   expect_eq(R"test(
 698 int s() {
 699   auto S = PTP(R"pb(
 700     item_1: 1,
 701     item_2: 2
 702   )pb");
 703 })test",
 704             format(R"test(
 705 int s() {
 706   auto S = PTP(R"pb(
 707       item_1: 1,
 708       item_2: 2
 709       )pb");
 710 })test",
 711                    getRawStringPbStyleWithColumns(20)));
 712
 713   // Align the prefix with the suffix if both the prefix and suffix are on a
 714   // line of their own.
 715   expect_eq(R"test(
 716 int s() {
 717   auto S = PTP(
 718       R"pb(
 719         item_1: 1,
 720         item_2: 2,
 721       )pb");
 722 })test",
 723             format(R"test(
 724 int s() {
 725   auto S = PTP(
 726       R"pb(
 727       item_1: 1,
 728       item_2: 2,
 729       )pb");
 730 })test",
 731                    getRawStringPbStyleWithColumns(20)));
 732 }
 733
 734 TEST_F(FormatTestRawStrings, EstimatesPenalty) {
 735   // The penalty for characters exceeding the column limit in the raw string
 736   // forces 'hh' to be put on a newline.
 737   expect_eq(R"test(
 738 ff(gggggg,
 739    hh(R"pb(key {
 740              i1: k1
 741              i2: k2
 742            })pb"));
 743 )test",
 744             format(R"test(
 745 ff(gggggg, hh(R"pb(key {
 746     i1: k1
 747     i2: k2
 748     })pb"));
 749 )test",
 750                    getRawStringPbStyleWithColumns(20)));
 751 }
 752
 753 TEST_F(FormatTestRawStrings, DontFormatNonRawStrings) {
 754   expect_eq(R"test(a = R"pb(key:value)";)test",
 755             format(R"test(a = R"pb(key:value)";)test",
 756                    getRawStringPbStyleWithColumns(20)));
 757 }
 758
 759 TEST_F(FormatTestRawStrings, FormatsRawStringsWithEnclosingFunctionName) {
 760   FormatStyle Style = getRawStringPbStyleWithColumns(40);
 761   Style.RawStringFormats[0].EnclosingFunctions.push_back("PARSE_TEXT_PROTO");
 762   Style.RawStringFormats[0].EnclosingFunctions.push_back("ParseTextProto");
 763   expect_eq(R"test(a = PARSE_TEXT_PROTO(R"(key: value)");)test",
 764             format(R"test(a = PARSE_TEXT_PROTO(R"(key:value)");)test", Style));
 765
 766   expect_eq(R"test(
 767 a = PARSE_TEXT_PROTO /**/ (
 768     /**/ R"(key: value)");)test",
 769             format(R"test(
 770 a = PARSE_TEXT_PROTO/**/(/**/R"(key:value)");)test",
 771                    Style));
 772
 773   expect_eq(R"test(
 774 a = ParseTextProto<ProtoType>(
 775     R"(key: value)");)test",
 776             format(R"test(
 777 a = ParseTextProto<ProtoType>(R"(key:value)");)test",
 778                    Style));
 779 }
 780
 781 TEST_F(FormatTestRawStrings, UpdatesToCanonicalDelimiters) {
 782   FormatStyle Style = getRawStringPbStyleWithColumns(35);
 783   Style.RawStringFormats[0].CanonicalDelimiter = "proto";
 784   Style.RawStringFormats[0].EnclosingFunctions.push_back("PARSE_TEXT_PROTO");
 785
 786   expect_eq(R"test(a = R"proto(key: value)proto";)test",
 787             format(R"test(a = R"pb(key:value)pb";)test", Style));
 788
 789   expect_eq(R"test(PARSE_TEXT_PROTO(R"proto(key: value)proto");)test",
 790             format(R"test(PARSE_TEXT_PROTO(R"(key:value)");)test", Style));
 791
 792   // Don't update to canonical delimiter if it occurs as a raw string suffix in
 793   // the raw string content.
 794   expect_eq(R"test(a = R"pb(key: ")proto")pb";)test",
 795             format(R"test(a = R"pb(key:")proto")pb";)test", Style));
 796 }
 797
 798 TEST_F(FormatTestRawStrings, PenalizesPrefixExcessChars) {
 799   FormatStyle Style = getRawStringPbStyleWithColumns(60);
 800
 801   // The '(' in R"pb is at column 60, no break.
 802   expect_eq(R"test(
 803 xxxxxxxaaaaax wwwwwww = _Verxrrrrrrrr(PARSE_TEXT_PROTO(R"pb(
 804   Category: aaaaaaaaaaaaaaaaaaaaaaaaaa
 805 )pb"));
 806 )test",
 807             format(R"test(
 808 xxxxxxxaaaaax wwwwwww = _Verxrrrrrrrr(PARSE_TEXT_PROTO(R"pb(
 809   Category: aaaaaaaaaaaaaaaaaaaaaaaaaa
 810 )pb"));
 811 )test",
 812                    Style));
 813   // The '(' in R"pb is at column 61, break.
 814   expect_eq(R"test(
 815 xxxxxxxaaaaax wwwwwww =
 816     _Verxrrrrrrrrr(PARSE_TEXT_PROTO(R"pb(
 817       Category: aaaaaaaaaaaaaaaaaaaaaaaaaa
 818     )pb"));
 819 )test",
 820             format(R"test(
 821 xxxxxxxaaaaax wwwwwww = _Verxrrrrrrrrr(PARSE_TEXT_PROTO(R"pb(
 822       Category: aaaaaaaaaaaaaaaaaaaaaaaaaa
 823 )pb"));
 824 )test",
 825                    Style));
 826 }
 827
 828 TEST_F(FormatTestRawStrings, KeepsRBraceFolloedByMoreLBracesOnSameLine) {
 829   FormatStyle Style = getRawStringPbStyleWithColumns(80);
 830
 831   expect_eq(
 832       R"test(
 833 int f() {
 834   if (1) {
 835     TTTTTTTTTTTTTTTTTTTTT s = PARSE_TEXT_PROTO(R"pb(
 836       ttttttttt {
 837         ppppppppppppp {
 838           [cccccccccc.pppppppppppppp.TTTTTTTTTTTTTTTTTTTT] { field_1: "123_1" }
 839           [cccccccccc.pppppppppppppp.TTTTTTTTTTTTTTTTTTTT] { field_2: "123_2" }
 840         }
 841       }
 842     )pb");
 843   }
 844 }
 845 )test",
 846       format(
 847           R"test(
 848 int f() {
 849   if (1) {
 850    TTTTTTTTTTTTTTTTTTTTT s = PARSE_TEXT_PROTO(R"pb(
 851    ttttttttt {
 852    ppppppppppppp {
 853    [cccccccccc.pppppppppppppp.TTTTTTTTTTTTTTTTTTTT] { field_1: "123_1" }
 854    [cccccccccc.pppppppppppppp.TTTTTTTTTTTTTTTTTTTT] { field_2: "123_2" }}}
 855    )pb");
 856   }
 857 }
 858 )test",
 859           Style));
 860 }
 861
 862 TEST_F(FormatTestRawStrings,
 863        DoNotFormatUnrecognizedDelimitersInRecognizedFunctions) {
 864   FormatStyle Style = getRawStringPbStyleWithColumns(60);
 865   Style.RawStringFormats[0].EnclosingFunctions.push_back("EqualsProto");
 866   // EqualsProto is a recognized function, but the Raw delimiter is
 867   // unrecognized. Do not touch the string in this case, since it might be
 868   // special.
 869   expect_eq(R"test(
 870 void f() {
 871   aaaaaaaaa(bbbbbbbbb, EqualsProto(R"Raw(
 872 item {
 873   key: value
 874 }
 875 )Raw"));
 876 })test",
 877             format(R"test(
 878 void f() {
 879   aaaaaaaaa(bbbbbbbbb, EqualsProto(R"Raw(
 880 item {
 881   key: value
 882 }
 883 )Raw"));
 884 })test",
 885                    Style));
 886 }
 887
 888 TEST_F(FormatTestRawStrings,
 889        BreaksBeforeNextParamAfterMultilineRawStringParam) {
 890   FormatStyle Style = getRawStringPbStyleWithColumns(60);
 891   expect_eq(R"test(
 892 int f() {
 893   int a = g(x, R"pb(
 894               key: 1  #
 895               key: 2
 896             )pb",
 897             3, 4);
 898 }
 899 )test",
 900             format(R"test(
 901 int f() {
 902   int a = g(x, R"pb(
 903               key: 1 #
 904               key: 2
 905             )pb", 3, 4);
 906 }
 907 )test",
 908                    Style));
 909
 910   // Breaks after a parent of a multiline param.
 911   expect_eq(R"test(
 912 int f() {
 913   int a = g(x, h(R"pb(
 914               key: 1  #
 915               key: 2
 916             )pb"),
 917             3, 4);
 918 }
 919 )test",
 920             format(R"test(
 921 int f() {
 922   int a = g(x, h(R"pb(
 923               key: 1 #
 924               key: 2
 925             )pb"), 3, 4);
 926 }
 927 )test",
 928                    Style));
 929
 930   expect_eq(R"test(
 931 int f() {
 932   int a = g(x,
 933             h(R"pb(
 934                 key: 1  #
 935                 key: 2
 936               )pb",
 937               2),
 938             3, 4);
 939 }
 940 )test",
 941             format(R"test(
 942 int f() {
 943   int a = g(x, h(R"pb(
 944               key: 1 #
 945               key: 2
 946             )pb", 2), 3, 4);
 947 }
 948 )test",
 949                    Style));
 950   // Breaks if formatting introduces a multiline raw string.
 951   expect_eq(R"test(
 952 int f() {
 953   int a = g(x, R"pb(key1: value111111111
 954                     key2: value2222222222)pb",
 955             3, 4);
 956 }
 957 )test",
 958             format(R"test(
 959 int f() {
 960   int a = g(x, R"pb(key1: value111111111 key2: value2222222222)pb", 3, 4);
 961 }
 962 )test",
 963                    Style));
 964   // Does not force a break after an original multiline param that is
 965   // reformatterd as on single line.
 966   expect_eq(R"test(
 967 int f() {
 968   int a = g(R"pb(key: 1)pb", 2);
 969 })test",
 970             format(R"test(
 971 int f() {
 972   int a = g(R"pb(key:
 973                  1)pb", 2);
 974 })test",
 975                    Style));
 976 }
 977
 978 TEST_F(FormatTestRawStrings, IndentsLastParamAfterNewline) {
 979   FormatStyle Style = getRawStringPbStyleWithColumns(60);
 980   expect_eq(R"test(
 981 fffffffffffffffffffff("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
 982                       R"pb(
 983                         b: c
 984                       )pb");)test",
 985             format(R"test(
 986 fffffffffffffffffffff("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
 987                       R"pb(
 988                       b: c
 989                       )pb");)test",
 990                    Style));
 991 }
 992 } // end namespace
 993 } // end namespace format
 994 } // end namespace clang