| //===- unittest/Format/FormatTestRawStrings.cpp - Formatting unit tests ---===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "clang/Format/Format.h" |
| |
| #include "../Tooling/ReplacementTest.h" |
| #include "FormatTestUtils.h" |
| |
| #include "llvm/Support/Debug.h" |
| #include "llvm/Support/MemoryBuffer.h" |
| #include "gtest/gtest.h" |
| |
| #define DEBUG_TYPE "format-test" |
| |
| using clang::tooling::ReplacementTest; |
| using clang::tooling::toReplacements; |
| |
| namespace clang { |
| namespace format { |
| namespace { |
| |
| class FormatTestRawStrings : public ::testing::Test { |
| protected: |
| enum StatusCheck { SC_ExpectComplete, SC_ExpectIncomplete, SC_DoNotCheck }; |
| |
| std::string format(llvm::StringRef Code, |
| const FormatStyle &Style = getLLVMStyle(), |
| StatusCheck CheckComplete = SC_ExpectComplete) { |
| LLVM_DEBUG(llvm::errs() << "---\n"); |
| LLVM_DEBUG(llvm::errs() << Code << "\n\n"); |
| std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size())); |
| FormattingAttemptStatus Status; |
| tooling::Replacements Replaces = |
| reformat(Style, Code, Ranges, "<stdin>", &Status); |
| if (CheckComplete != SC_DoNotCheck) { |
| bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete; |
| EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete) |
| << Code << "\n\n"; |
| } |
| ReplacementCount = Replaces.size(); |
| auto Result = applyAllReplacements(Code, Replaces); |
| EXPECT_TRUE(static_cast<bool>(Result)); |
| LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n"); |
| return *Result; |
| } |
| |
| FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) { |
| Style.ColumnLimit = ColumnLimit; |
| return Style; |
| } |
| |
| FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { |
| return getStyleWithColumns(getLLVMStyle(), ColumnLimit); |
| } |
| |
| int ReplacementCount; |
| |
| FormatStyle getRawStringPbStyleWithColumns(unsigned ColumnLimit) { |
| FormatStyle Style = getLLVMStyle(); |
| Style.ColumnLimit = ColumnLimit; |
| Style.RawStringFormats = { |
| { |
| /*Language=*/FormatStyle::LK_TextProto, |
| /*Delimiters=*/{"pb"}, |
| /*EnclosingFunctions=*/{}, |
| /*CanonicalDelimiter=*/"", |
| /*BasedOnStyle=*/"google", |
| }, |
| }; |
| return Style; |
| } |
| |
| FormatStyle getRawStringLLVMCppStyleBasedOn(std::string BasedOnStyle) { |
| FormatStyle Style = getLLVMStyle(); |
| Style.RawStringFormats = { |
| { |
| /*Language=*/FormatStyle::LK_Cpp, |
| /*Delimiters=*/{"cpp"}, |
| /*EnclosingFunctions=*/{}, |
| /*CanonicalDelimiter=*/"", |
| BasedOnStyle, |
| }, |
| }; |
| return Style; |
| } |
| |
| FormatStyle getRawStringGoogleCppStyleBasedOn(std::string BasedOnStyle) { |
| FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); |
| Style.RawStringFormats = { |
| { |
| /*Language=*/FormatStyle::LK_Cpp, |
| /*Delimiters=*/{"cpp"}, |
| /*EnclosingFunctions=*/{}, |
| /*CanonicalDelimiter=*/"", |
| BasedOnStyle, |
| }, |
| }; |
| return Style; |
| } |
| |
| // Gcc 4.8 doesn't support raw string literals in macros, which breaks some |
| // build bots. We use this function instead. |
| void expect_eq(const std::string Expected, const std::string Actual) { |
| EXPECT_EQ(Expected, Actual); |
| } |
| }; |
| |
| TEST_F(FormatTestRawStrings, ReformatsAccordingToBaseStyle) { |
| // llvm style puts '*' on the right. |
| // google style puts '*' on the left. |
| |
| // Use the llvm style if the raw string style has no BasedOnStyle. |
| expect_eq(R"test(int *i = R"cpp(int *p = nullptr;)cpp")test", |
| format(R"test(int * i = R"cpp(int * p = nullptr;)cpp")test", |
| getRawStringLLVMCppStyleBasedOn(""))); |
| |
| // Use the google style if the raw string style has BasedOnStyle=google. |
| expect_eq(R"test(int *i = R"cpp(int* p = nullptr;)cpp")test", |
| format(R"test(int * i = R"cpp(int * p = nullptr;)cpp")test", |
| getRawStringLLVMCppStyleBasedOn("google"))); |
| |
| // Use the llvm style if the raw string style has no BasedOnStyle=llvm. |
| expect_eq(R"test(int* i = R"cpp(int *p = nullptr;)cpp")test", |
| format(R"test(int * i = R"cpp(int * p = nullptr;)cpp")test", |
| getRawStringGoogleCppStyleBasedOn("llvm"))); |
| } |
| |
| TEST_F(FormatTestRawStrings, UsesConfigurationOverBaseStyle) { |
| // llvm style puts '*' on the right. |
| // google style puts '*' on the left. |
| |
| // Uses the configured google style inside raw strings even if BasedOnStyle in |
| // the raw string format is llvm. |
| FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); |
| EXPECT_EQ(0, parseConfiguration("---\n" |
| "Language: Cpp\n" |
| "BasedOnStyle: Google", |
| &Style) |
| .value()); |
| Style.RawStringFormats = {{ |
| FormatStyle::LK_Cpp, |
| {"cpp"}, |
| {}, |
| /*CanonicalDelimiter=*/"", |
| /*BasedOnStyle=*/"llvm", |
| }}; |
| expect_eq(R"test(int* i = R"cpp(int* j = 0;)cpp";)test", |
| format(R"test(int * i = R"cpp(int * j = 0;)cpp";)test", Style)); |
| } |
| |
| TEST_F(FormatTestRawStrings, MatchesDelimitersCaseSensitively) { |
| // Don't touch the 'PB' raw string, format the 'pb' raw string. |
| expect_eq(R"test( |
| s = R"PB(item:1)PB"; |
| t = R"pb(item: 1)pb";)test", |
| format(R"test( |
| s = R"PB(item:1)PB"; |
| t = R"pb(item:1)pb";)test", |
| getRawStringPbStyleWithColumns(40))); |
| } |
| |
| TEST_F(FormatTestRawStrings, RespectsClangFormatOff) { |
| expect_eq(R"test( |
| // clang-format off |
| s = R"pb(item: 1)pb"; |
| // clang-format on |
| t = R"pb(item: 1)pb";)test", |
| format(R"test( |
| // clang-format off |
| s = R"pb(item: 1)pb"; |
| // clang-format on |
| t = R"pb(item: 1)pb";)test", |
| getRawStringPbStyleWithColumns(40))); |
| } |
| |
| TEST_F(FormatTestRawStrings, ReformatsShortRawStringsOnSingleLine) { |
| expect_eq(R"test(P p = TP(R"pb()pb");)test", |
| format(R"test(P p = TP(R"pb( )pb");)test", |
| getRawStringPbStyleWithColumns(40))); |
| expect_eq(R"test(P p = TP(R"pb(item_1: 1)pb");)test", |
| format(R"test(P p = TP(R"pb(item_1:1)pb");)test", |
| getRawStringPbStyleWithColumns(40))); |
| expect_eq(R"test(P p = TP(R"pb(item_1: 1)pb");)test", |
| format(R"test(P p = TP(R"pb( item_1 : 1 )pb");)test", |
| getRawStringPbStyleWithColumns(40))); |
| expect_eq(R"test(P p = TP(R"pb(item_1: 1 item_2: 2)pb");)test", |
| format(R"test(P p = TP(R"pb(item_1:1 item_2:2)pb");)test", |
| getRawStringPbStyleWithColumns(40))); |
| // Merge two short lines into one. |
| expect_eq(R"test( |
| std::string s = R"pb( |
| item_1: 1 item_2: 2 |
| )pb"; |
| )test", |
| format(R"test( |
| std::string s = R"pb( |
| item_1:1 |
| item_2:2 |
| )pb"; |
| )test", |
| getRawStringPbStyleWithColumns(40))); |
| } |
| |
| TEST_F(FormatTestRawStrings, BreaksShortRawStringsWhenNeeded) { |
| // The raw string contains multiple submessage entries, so break for |
| // readability. |
| expect_eq(R"test( |
| P p = TP(R"pb(item_1 < 1 > |
| item_2: { 2 })pb");)test", |
| format( |
| R"test( |
| P p = TP(R"pb(item_1<1> item_2:{2})pb");)test", |
| getRawStringPbStyleWithColumns(40))); |
| } |
| |
| TEST_F(FormatTestRawStrings, BreaksRawStringsExceedingColumnLimit) { |
| expect_eq(R"test( |
| P p = TPPPPPPPPPPPPPPP( |
| R"pb(item_1: 1, item_2: 2)pb");)test", |
| format(R"test( |
| P p = TPPPPPPPPPPPPPPP(R"pb(item_1: 1, item_2: 2)pb");)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| P p = |
| TPPPPPPPPPPPPPPP( |
| R"pb(item_1: 1, |
| item_2: 2, |
| item_3: 3)pb");)test", |
| format(R"test( |
| P p = TPPPPPPPPPPPPPPP(R"pb(item_1: 1, item_2: 2, item_3: 3)pb");)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| P p = TP(R"pb(item_1 < 1 > |
| item_2: < 2 > |
| item_3 {})pb");)test", |
| format(R"test( |
| P p = TP(R"pb(item_1<1> item_2:<2> item_3{ })pb");)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq( |
| R"test( |
| P p = TP(R"pb(item_1: 1, |
| item_2: 2, |
| item_3: 3, |
| item_4: 4)pb");)test", |
| format( |
| R"test( |
| P p = TP(R"pb(item_1: 1, item_2: 2, item_3: 3, item_4: 4)pb");)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| P p = TPPPPPPPPPPPPPPP( |
| R"pb(item_1 < 1 >, |
| item_2: { 2 }, |
| item_3: < 3 >, |
| item_4: { 4 })pb");)test", |
| format(R"test( |
| P p = TPPPPPPPPPPPPPPP(R"pb(item_1<1>, item_2: {2}, item_3: <3>, item_4:{4})pb");)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| // Breaks before a short raw string exceeding the column limit. |
| expect_eq(R"test( |
| FFFFFFFFFFFFFFFFFFFFFFFFFFF( |
| R"pb(key: 1)pb"); |
| P p = TPPPPPPPPPPPPPPPPPPPP( |
| R"pb(key: 2)pb"); |
| auto TPPPPPPPPPPPPPPPPPPPP = |
| R"pb(key: 3)pb"; |
| P p = TPPPPPPPPPPPPPPPPPPPP( |
| R"pb(i: 1, j: 2)pb"); |
| |
| int f(string s) { |
| FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF( |
| R"pb(key: 1)pb"); |
| P p = TPPPPPPPPPPPPPPPPPPPP( |
| R"pb(key: 2)pb"); |
| auto TPPPPPPPPPPPPPPPPPPPP = |
| R"pb(key: 3)pb"; |
| if (s.empty()) |
| P p = TPPPPPPPPPPPPPPPPPPPP( |
| R"pb(i: 1, j: 2)pb"); |
| } |
| )test", |
| format(R"test( |
| FFFFFFFFFFFFFFFFFFFFFFFFFFF(R"pb(key:1)pb"); |
| P p = TPPPPPPPPPPPPPPPPPPPP(R"pb(key:2)pb"); |
| auto TPPPPPPPPPPPPPPPPPPPP = R"pb(key:3)pb"; |
| P p = TPPPPPPPPPPPPPPPPPPPP(R"pb(i: 1, j:2)pb"); |
| |
| int f(string s) { |
| FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF(R"pb(key:1)pb"); |
| P p = TPPPPPPPPPPPPPPPPPPPP(R"pb(key:2)pb"); |
| auto TPPPPPPPPPPPPPPPPPPPP = R"pb(key:3)pb"; |
| if (s.empty()) |
| P p = TPPPPPPPPPPPPPPPPPPPP(R"pb(i: 1, j:2)pb"); |
| } |
| )test", |
| getRawStringPbStyleWithColumns(40))); |
| } |
| |
| TEST_F(FormatTestRawStrings, FormatsRawStringArguments) { |
| expect_eq(R"test( |
| P p = TP(R"pb(key { 1 })pb", param_2);)test", |
| format(R"test( |
| P p = TP(R"pb(key{1})pb",param_2);)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| PPPPPPPPPPPPP(R"pb(keykeyk)pb", |
| param_2);)test", |
| format(R"test( |
| PPPPPPPPPPPPP(R"pb(keykeyk)pb", param_2);)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| P p = TP( |
| R"pb(item: { i: 1, s: 's' } |
| item: { i: 2, s: 't' })pb");)test", |
| format(R"test( |
| P p = TP(R"pb(item: {i: 1, s: 's'} item: {i: 2, s: 't'})pb");)test", |
| getRawStringPbStyleWithColumns(40))); |
| expect_eq(R"test( |
| FFFFFFFFFFFFFFFFFFF( |
| R"pb(key: "value")pb", |
| R"pb(key2: "value")pb");)test", |
| format(R"test( |
| FFFFFFFFFFFFFFFFFFF(R"pb(key: "value")pb", R"pb(key2: "value")pb");)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| // Formats the first out of two arguments. |
| expect_eq(R"test( |
| FFFFFFFF(R"pb(key: 1)pb", argument2); |
| struct S { |
| const s = |
| f(R"pb(key: 1)pb", argument2); |
| void f() { |
| if (gol) |
| return g(R"pb(key: 1)pb", |
| 132789237); |
| return g(R"pb(key: 1)pb", "172893"); |
| } |
| };)test", |
| format(R"test( |
| FFFFFFFF(R"pb(key:1)pb", argument2); |
| struct S { |
| const s = f(R"pb(key:1)pb", argument2); |
| void f() { |
| if (gol) |
| return g(R"pb(key:1)pb", 132789237); |
| return g(R"pb(key:1)pb", "172893"); |
| } |
| };)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| // Formats the second out of two arguments. |
| expect_eq(R"test( |
| FFFFFFFF(argument1, R"pb(key: 2)pb"); |
| struct S { |
| const s = |
| f(argument1, R"pb(key: 2)pb"); |
| void f() { |
| if (gol) |
| return g(12784137, |
| R"pb(key: 2)pb"); |
| return g(17283122, R"pb(key: 2)pb"); |
| } |
| };)test", |
| format(R"test( |
| FFFFFFFF(argument1, R"pb(key:2)pb"); |
| struct S { |
| const s = f(argument1, R"pb(key:2)pb"); |
| void f() { |
| if (gol) |
| return g(12784137, R"pb(key:2)pb"); |
| return g(17283122, R"pb(key:2)pb"); |
| } |
| };)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| // Formats two short raw string arguments. |
| expect_eq(R"test( |
| FFFFF(R"pb(key: 1)pb", R"pb(key: 2)pb");)test", |
| format(R"test( |
| FFFFF(R"pb(key:1)pb", R"pb(key:2)pb");)test", |
| getRawStringPbStyleWithColumns(40))); |
| // TODO(krasimir): The original source code fits on one line, so the |
| // non-optimizing formatter is chosen. But after the formatting in protos is |
| // made, the code doesn't fit on one line anymore and further formatting |
| // splits it. |
| // |
| // Should we disable raw string formatting for the non-optimizing formatter? |
| expect_eq(R"test( |
| FFFFFFF(R"pb(key: 1)pb", R"pb(key: 2)pb");)test", |
| format(R"test( |
| FFFFFFF(R"pb(key:1)pb", R"pb(key:2)pb");)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| // Formats two short raw string arguments, puts second on newline. |
| expect_eq(R"test( |
| FFFFFFFF(R"pb(key: 1)pb", |
| R"pb(key: 2)pb");)test", |
| format(R"test( |
| FFFFFFFF(R"pb(key:1)pb", R"pb(key:2)pb");)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| // Formats both arguments. |
| expect_eq(R"test( |
| FFFFFFFF(R"pb(key: 1)pb", |
| R"pb(key: 2)pb"); |
| struct S { |
| const s = f(R"pb(key: 1)pb", |
| R"pb(key: 2)pb"); |
| void f() { |
| if (gol) |
| return g(R"pb(key: 1)pb", |
| R"pb(key: 2)pb"); |
| return g(R"pb(k1)pb", R"pb(k2)pb"); |
| } |
| };)test", |
| format(R"test( |
| FFFFFFFF(R"pb(key:1)pb", R"pb(key:2)pb"); |
| struct S { |
| const s = f(R"pb(key:1)pb", R"pb(key:2)pb"); |
| void f() { |
| if (gol) |
| return g(R"pb(key:1)pb", R"pb(key:2)pb"); |
| return g(R"pb( k1 )pb", R"pb( k2 )pb"); |
| } |
| };)test", |
| getRawStringPbStyleWithColumns(40))); |
| } |
| |
| TEST_F(FormatTestRawStrings, RawStringStartingWithNewlines) { |
| expect_eq(R"test( |
| std::string s = R"pb( |
| item_1: 1 |
| )pb"; |
| )test", |
| format(R"test( |
| std::string s = R"pb( |
| item_1:1 |
| )pb"; |
| )test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| std::string s = R"pb( |
| |
| item_1: 1 |
| )pb"; |
| )test", |
| format(R"test( |
| std::string s = R"pb( |
| |
| item_1:1 |
| )pb"; |
| )test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| std::string s = R"pb( |
| item_1: 1 |
| )pb"; |
| )test", |
| format(R"test( |
| std::string s = R"pb( |
| item_1:1 |
| |
| )pb"; |
| )test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| std::string s = R"pb( |
| item_1: 1, |
| item_2: 2 |
| )pb"; |
| )test", |
| format(R"test( |
| std::string s = R"pb( |
| item_1:1, item_2:2 |
| )pb"; |
| )test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| std::string s = R"pb( |
| book { |
| title: "Alice's Adventures" |
| author: "Lewis Caroll" |
| } |
| book { |
| title: "Peter Pan" |
| author: "J. M. Barrie" |
| } |
| )pb"; |
| )test", |
| format(R"test( |
| std::string s = R"pb( |
| book { title: "Alice's Adventures" author: "Lewis Caroll" } |
| book { title: "Peter Pan" author: "J. M. Barrie" } |
| )pb"; |
| )test", |
| getRawStringPbStyleWithColumns(40))); |
| } |
| |
| TEST_F(FormatTestRawStrings, BreaksBeforeRawStrings) { |
| expect_eq(R"test( |
| ASSERT_TRUE( |
| ParseFromString(R"pb(item_1: 1)pb"), |
| ptr);)test", |
| format(R"test( |
| ASSERT_TRUE(ParseFromString(R"pb(item_1: 1)pb"), ptr);)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| ASSERT_TRUE(toolong::ParseFromString( |
| R"pb(item_1: 1)pb"), |
| ptr);)test", |
| format(R"test( |
| ASSERT_TRUE(toolong::ParseFromString(R"pb(item_1: 1)pb"), ptr);)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| ASSERT_TRUE(ParseFromString( |
| R"pb(item_1: 1, |
| item_2: 2)pb"), |
| ptr);)test", |
| format(R"test( |
| ASSERT_TRUE(ParseFromString(R"pb(item_1: 1, item_2: 2)pb"), ptr);)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| ASSERT_TRUE( |
| ParseFromString( |
| R"pb(item_1: 1 item_2: 2)pb"), |
| ptr);)test", |
| format(R"test( |
| ASSERT_TRUE(ParseFromString(R"pb(item_1: 1 item_2: 2)pb"), ptr);)test", |
| getRawStringPbStyleWithColumns(40))); |
| } |
| |
| TEST_F(FormatTestRawStrings, RawStringsInOperands) { |
| // Formats the raw string first operand of a binary operator expression. |
| expect_eq(R"test(auto S = R"pb(item_1: 1)pb" + rest;)test", |
| format(R"test(auto S = R"pb(item_1:1)pb" + rest;)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| auto S = R"pb(item_1: 1, item_2: 2)pb" + |
| rest;)test", |
| format(R"test( |
| auto S = R"pb(item_1:1,item_2:2)pb"+rest;)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| auto S = |
| R"pb(item_1: 1 item_2: 2)pb" + rest;)test", |
| format(R"test( |
| auto S = R"pb(item_1:1 item_2:2)pb"+rest;)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| // `rest` fits on the line after )pb", but forced on newline since the raw |
| // string literal is multiline. |
| expect_eq(R"test( |
| auto S = R"pb(item_1: 1, |
| item_2: 2, |
| item_3: 3)pb" + |
| rest;)test", |
| format(R"test( |
| auto S = R"pb(item_1:1,item_2:2,item_3:3)pb"+rest;)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| auto S = R"pb(item_1: 1, |
| item_2: 2, |
| item_3: 3)pb" + |
| longlongrest;)test", |
| format(R"test( |
| auto S = R"pb(item_1:1,item_2:2,item_3:3)pb"+longlongrest;)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| // Formats the raw string second operand of a binary operator expression. |
| expect_eq(R"test(auto S = first + R"pb(item_1: 1)pb";)test", |
| format(R"test(auto S = first + R"pb(item_1:1)pb";)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| auto S = first + R"pb(item_1: 1, |
| item_2: 2)pb";)test", |
| format(R"test( |
| auto S = first+R"pb(item_1:1,item_2:2)pb";)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| auto S = first + R"pb(item_1: 1 |
| item_2: 2)pb";)test", |
| format(R"test( |
| auto S = first+R"pb(item_1:1 item_2:2)pb";)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| auto S = R"pb(item_1: 1, |
| item_2: 2, |
| item_3: 3)pb" + |
| rest;)test", |
| format(R"test( |
| auto S = R"pb(item_1:1,item_2:2,item_3:3)pb"+rest;)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| auto S = R"pb(item_1: 1, |
| item_2: 2, |
| item_3: 3)pb" + |
| longlongrest;)test", |
| format(R"test( |
| auto S = R"pb(item_1:1,item_2:2,item_3:3)pb"+longlongrest;)test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| // Formats the raw string operands in expressions. |
| expect_eq(R"test( |
| auto S = R"pb(item_1: 1)pb" + |
| R"pb(item_2: 2)pb"; |
| )test", |
| format(R"test( |
| auto S=R"pb(item_1:1)pb"+R"pb(item_2:2)pb"; |
| )test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| auto S = R"pb(item_1: 1)pb" + |
| R"pb(item_2: 2)pb" + |
| R"pb(item_3: 3)pb"; |
| )test", |
| format(R"test( |
| auto S=R"pb(item_1:1)pb"+R"pb(item_2:2)pb"+R"pb(item_3:3)pb"; |
| )test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| auto S = (count < 3) |
| ? R"pb(item_1: 1)pb" |
| : R"pb(item_2: 2)pb"; |
| )test", |
| format(R"test( |
| auto S=(count<3)?R"pb(item_1:1)pb":R"pb(item_2:2)pb"; |
| )test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| auto S = |
| (count < 3) |
| ? R"pb(item_1: 1, item_2: 2)pb" |
| : R"pb(item_3: 3)pb"; |
| )test", |
| format(R"test( |
| auto S=(count<3)?R"pb(item_1:1,item_2:2)pb":R"pb(item_3:3)pb"; |
| )test", |
| getRawStringPbStyleWithColumns(40))); |
| |
| expect_eq(R"test( |
| auto S = |
| (count < 3) |
| ? R"pb(item_1: 1)pb" |
| : R"pb(item_2: 2, item_3: 3)pb"; |
| )test", |
| format(R"test( |
| auto S=(count<3)?R"pb(item_1:1)pb":R"pb(item_2:2,item_3:3)pb"; |
| )test", |
| getRawStringPbStyleWithColumns(40))); |
| } |
| |
| TEST_F(FormatTestRawStrings, PrefixAndSuffixAlignment) { |
| // Keep the suffix at the end of line if not on newline. |
| expect_eq(R"test( |
| int s() { |
| auto S = PTP( |
| R"pb( |
| item_1: 1, |
| item_2: 2)pb"); |
| })test", |
| format(R"test( |
| int s() { |
| auto S = PTP( |
| R"pb( |
| item_1: 1, |
| item_2: 2)pb"); |
| })test", |
| getRawStringPbStyleWithColumns(20))); |
| |
| // Align the suffix with the surrounding indent if the prefix is not on |
| // a line of its own. |
| expect_eq(R"test( |
| int s() { |
| auto S = PTP(R"pb( |
| item_1: 1, |
| item_2: 2 |
| )pb"); |
| })test", |
| format(R"test( |
| int s() { |
| auto S = PTP(R"pb( |
| item_1: 1, |
| item_2: 2 |
| )pb"); |
| })test", |
| getRawStringPbStyleWithColumns(20))); |
| |
| // Align the prefix with the suffix if both the prefix and suffix are on a |
| // line of their own. |
| expect_eq(R"test( |
| int s() { |
| auto S = PTP( |
| R"pb( |
| item_1: 1, |
| item_2: 2, |
| )pb"); |
| })test", |
| format(R"test( |
| int s() { |
| auto S = PTP( |
| R"pb( |
| item_1: 1, |
| item_2: 2, |
| )pb"); |
| })test", |
| getRawStringPbStyleWithColumns(20))); |
| } |
| |
| TEST_F(FormatTestRawStrings, EstimatesPenalty) { |
| // The penalty for characters exceeding the column limit in the raw string |
| // forces 'hh' to be put on a newline. |
| expect_eq(R"test( |
| ff(gggggg, |
| hh(R"pb(key { |
| i1: k1 |
| i2: k2 |
| })pb")); |
| )test", |
| format(R"test( |
| ff(gggggg, hh(R"pb(key { |
| i1: k1 |
| i2: k2 |
| })pb")); |
| )test", |
| getRawStringPbStyleWithColumns(20))); |
| } |
| |
| TEST_F(FormatTestRawStrings, DontFormatNonRawStrings) { |
| expect_eq(R"test(a = R"pb(key:value)";)test", |
| format(R"test(a = R"pb(key:value)";)test", |
| getRawStringPbStyleWithColumns(20))); |
| } |
| |
| TEST_F(FormatTestRawStrings, FormatsRawStringsWithEnclosingFunctionName) { |
| FormatStyle Style = getRawStringPbStyleWithColumns(40); |
| Style.RawStringFormats[0].EnclosingFunctions.push_back("PARSE_TEXT_PROTO"); |
| Style.RawStringFormats[0].EnclosingFunctions.push_back("ParseTextProto"); |
| expect_eq(R"test(a = PARSE_TEXT_PROTO(R"(key: value)");)test", |
| format(R"test(a = PARSE_TEXT_PROTO(R"(key:value)");)test", Style)); |
| |
| expect_eq(R"test( |
| a = PARSE_TEXT_PROTO /**/ ( |
| /**/ R"(key: value)");)test", |
| format(R"test( |
| a = PARSE_TEXT_PROTO/**/(/**/R"(key:value)");)test", |
| Style)); |
| |
| expect_eq(R"test( |
| a = ParseTextProto<ProtoType>( |
| R"(key: value)");)test", |
| format(R"test( |
| a = ParseTextProto<ProtoType>(R"(key:value)");)test", |
| Style)); |
| } |
| |
| TEST_F(FormatTestRawStrings, UpdatesToCanonicalDelimiters) { |
| FormatStyle Style = getRawStringPbStyleWithColumns(35); |
| Style.RawStringFormats[0].CanonicalDelimiter = "proto"; |
| Style.RawStringFormats[0].EnclosingFunctions.push_back("PARSE_TEXT_PROTO"); |
| |
| expect_eq(R"test(a = R"proto(key: value)proto";)test", |
| format(R"test(a = R"pb(key:value)pb";)test", Style)); |
| |
| expect_eq(R"test(PARSE_TEXT_PROTO(R"proto(key: value)proto");)test", |
| format(R"test(PARSE_TEXT_PROTO(R"(key:value)");)test", Style)); |
| |
| // Don't update to canonical delimiter if it occurs as a raw string suffix in |
| // the raw string content. |
| expect_eq(R"test(a = R"pb(key: ")proto")pb";)test", |
| format(R"test(a = R"pb(key:")proto")pb";)test", Style)); |
| } |
| |
| TEST_F(FormatTestRawStrings, PenalizesPrefixExcessChars) { |
| FormatStyle Style = getRawStringPbStyleWithColumns(60); |
| |
| // The '(' in R"pb is at column 60, no break. |
| expect_eq(R"test( |
| xxxxxxxaaaaax wwwwwww = _Verxrrrrrrrr(PARSE_TEXT_PROTO(R"pb( |
| Category: aaaaaaaaaaaaaaaaaaaaaaaaaa |
| )pb")); |
| )test", |
| format(R"test( |
| xxxxxxxaaaaax wwwwwww = _Verxrrrrrrrr(PARSE_TEXT_PROTO(R"pb( |
| Category: aaaaaaaaaaaaaaaaaaaaaaaaaa |
| )pb")); |
| )test", |
| Style)); |
| // The '(' in R"pb is at column 61, break. |
| expect_eq(R"test( |
| xxxxxxxaaaaax wwwwwww = |
| _Verxrrrrrrrrr(PARSE_TEXT_PROTO(R"pb( |
| Category: aaaaaaaaaaaaaaaaaaaaaaaaaa |
| )pb")); |
| )test", |
| format(R"test( |
| xxxxxxxaaaaax wwwwwww = _Verxrrrrrrrrr(PARSE_TEXT_PROTO(R"pb( |
| Category: aaaaaaaaaaaaaaaaaaaaaaaaaa |
| )pb")); |
| )test", |
| Style)); |
| } |
| |
| TEST_F(FormatTestRawStrings, KeepsRBraceFolloedByMoreLBracesOnSameLine) { |
| FormatStyle Style = getRawStringPbStyleWithColumns(80); |
| |
| expect_eq( |
| R"test( |
| int f() { |
| if (1) { |
| TTTTTTTTTTTTTTTTTTTTT s = PARSE_TEXT_PROTO(R"pb( |
| ttttttttt { |
| ppppppppppppp { |
| [cccccccccc.pppppppppppppp.TTTTTTTTTTTTTTTTTTTT] { field_1: "123_1" } |
| [cccccccccc.pppppppppppppp.TTTTTTTTTTTTTTTTTTTT] { field_2: "123_2" } |
| } |
| } |
| )pb"); |
| } |
| } |
| )test", |
| format( |
| R"test( |
| int f() { |
| if (1) { |
| TTTTTTTTTTTTTTTTTTTTT s = PARSE_TEXT_PROTO(R"pb( |
| ttttttttt { |
| ppppppppppppp { |
| [cccccccccc.pppppppppppppp.TTTTTTTTTTTTTTTTTTTT] { field_1: "123_1" } |
| [cccccccccc.pppppppppppppp.TTTTTTTTTTTTTTTTTTTT] { field_2: "123_2" }}} |
| )pb"); |
| } |
| } |
| )test", |
| Style)); |
| } |
| |
| TEST_F(FormatTestRawStrings, |
| DoNotFormatUnrecognizedDelimitersInRecognizedFunctions) { |
| FormatStyle Style = getRawStringPbStyleWithColumns(60); |
| Style.RawStringFormats[0].EnclosingFunctions.push_back("EqualsProto"); |
| // EqualsProto is a recognized function, but the Raw delimiter is |
| // unrecognized. Do not touch the string in this case, since it might be |
| // special. |
| expect_eq(R"test( |
| void f() { |
| aaaaaaaaa(bbbbbbbbb, EqualsProto(R"Raw( |
| item { |
| key: value |
| } |
| )Raw")); |
| })test", |
| format(R"test( |
| void f() { |
| aaaaaaaaa(bbbbbbbbb, EqualsProto(R"Raw( |
| item { |
| key: value |
| } |
| )Raw")); |
| })test", |
| Style)); |
| } |
| |
| TEST_F(FormatTestRawStrings, |
| BreaksBeforeNextParamAfterMultilineRawStringParam) { |
| FormatStyle Style = getRawStringPbStyleWithColumns(60); |
| expect_eq(R"test( |
| int f() { |
| int a = g(x, R"pb( |
| key: 1 # |
| key: 2 |
| )pb", |
| 3, 4); |
| } |
| )test", |
| format(R"test( |
| int f() { |
| int a = g(x, R"pb( |
| key: 1 # |
| key: 2 |
| )pb", 3, 4); |
| } |
| )test", |
| Style)); |
| |
| // Breaks after a parent of a multiline param. |
| expect_eq(R"test( |
| int f() { |
| int a = g(x, h(R"pb( |
| key: 1 # |
| key: 2 |
| )pb"), |
| 3, 4); |
| } |
| )test", |
| format(R"test( |
| int f() { |
| int a = g(x, h(R"pb( |
| key: 1 # |
| key: 2 |
| )pb"), 3, 4); |
| } |
| )test", |
| Style)); |
| |
| expect_eq(R"test( |
| int f() { |
| int a = g(x, |
| h(R"pb( |
| key: 1 # |
| key: 2 |
| )pb", |
| 2), |
| 3, 4); |
| } |
| )test", |
| format(R"test( |
| int f() { |
| int a = g(x, h(R"pb( |
| key: 1 # |
| key: 2 |
| )pb", 2), 3, 4); |
| } |
| )test", |
| Style)); |
| // Breaks if formatting introduces a multiline raw string. |
| expect_eq(R"test( |
| int f() { |
| int a = g(x, R"pb(key1: value111111111 |
| key2: value2222222222)pb", |
| 3, 4); |
| } |
| )test", |
| format(R"test( |
| int f() { |
| int a = g(x, R"pb(key1: value111111111 key2: value2222222222)pb", 3, 4); |
| } |
| )test", |
| Style)); |
| // Does not force a break after an original multiline param that is |
| // reformatterd as on single line. |
| expect_eq(R"test( |
| int f() { |
| int a = g(R"pb(key: 1)pb", 2); |
| })test", |
| format(R"test( |
| int f() { |
| int a = g(R"pb(key: |
| 1)pb", 2); |
| })test", |
| Style)); |
| } |
| |
| TEST_F(FormatTestRawStrings, IndentsLastParamAfterNewline) { |
| FormatStyle Style = getRawStringPbStyleWithColumns(60); |
| expect_eq(R"test( |
| fffffffffffffffffffff("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", |
| R"pb( |
| b: c |
| )pb");)test", |
| format(R"test( |
| fffffffffffffffffffff("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", |
| R"pb( |
| b: c |
| )pb");)test", |
| Style)); |
| } |
| } // end namespace |
| } // end namespace format |
| } // end namespace clang |
