mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
b95d48b228c0235e5c30e1255fe87daa9d4b4e39
linux-packaging-mono/external/llvm-project/clang/unittests/Format/FormatTestRawStrings.cpp
Xamarin Public Jenkins (auto-signing) 468663ddbb Imported Upstream version 6.10.0.49 
Former-commit-id: 1d6753294b2993e1fbf92de9366bb9544db4189b
2020-01-16 16:38:04 +00:00

734 lines
21 KiB
C++
Raw Blame History

//===- unittest/Format/FormatTestRawStrings.cpp - Formatting unit tests ---===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "clang/Format/Format.h"
#include "../Tooling/ReplacementTest.h"
#include "FormatTestUtils.h"
#include "clang/Frontend/TextDiagnosticPrinter.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) {
DEBUG(llvm::errs() << "---\n");
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));
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 = {{/*Delimiter=*/"pb",
/*Kind=*/FormatStyle::LK_TextProto,
/*BasedOnStyle=*/"google"}};
return Style;
}
FormatStyle getRawStringLLVMCppStyleBasedOn(std::string BasedOnStyle) {
FormatStyle Style = getLLVMStyle();
Style.RawStringFormats = {{/*Delimiter=*/"cpp",
/*Kind=*/FormatStyle::LK_Cpp, BasedOnStyle}};
return Style;
}
FormatStyle getRawStringGoogleCppStyleBasedOn(std::string BasedOnStyle) {
FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
Style.RawStringFormats = {{/*Delimiter=*/"cpp",
/*Kind=*/FormatStyle::LK_Cpp, 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, 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)));
FormatStyle MixedStyle = getLLVMStyle();
MixedStyle.RawStringFormats = {
{/*Delimiter=*/"cpp", /*Kind=*/FormatStyle::LK_Cpp,
/*BasedOnStyle=*/"llvm"},
{/*Delimiter=*/"CPP", /*Kind=*/FormatStyle::LK_Cpp,
/*BasedOnStyle=*/"google"}};
// Format the 'cpp' raw string with '*' on the right.
// Format the 'CPP' raw string with '*' on the left.
// Do not format the 'Cpp' raw string.
// Do not format non-raw strings.
expect_eq(R"test(
a = R"cpp(int *i = 0;)cpp";
b = R"CPP(int* j = 0;)CPP";
c = R"Cpp(int * k = 0;)Cpp";
d = R"cpp(int * k = 0;)Cpp";)test",
format(R"test(
a = R"cpp(int * i = 0;)cpp";
b = R"CPP(int * j = 0;)CPP";
c = R"Cpp(int * k = 0;)Cpp";
d = R"cpp(int * k = 0;)Cpp";)test",
MixedStyle));
}
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)));
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, 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)));
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 FirstIndent 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)));
}
} // end namespace
} // end namespace format
} // end namespace clang
Reference in New Issue View Git Blame Copy Permalink