llvm-project/clang/unittests/Format/FormatTestTextProto.cpp

741 lines
24 KiB
C++

//===- unittest/Format/FormatTestTextProto.cpp ----------------------------===//
//
// 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 "FormatTestUtils.h"
#include "clang/Format/Format.h"
#include "llvm/Support/Debug.h"
#include "gtest/gtest.h"
#define DEBUG_TYPE "format-test"
namespace clang {
namespace format {
class FormatTestTextProto : public ::testing::Test {
protected:
static std::string format(llvm::StringRef Code, unsigned Offset,
unsigned Length, const FormatStyle &Style) {
LLVM_DEBUG(llvm::errs() << "---\n");
LLVM_DEBUG(llvm::errs() << Code << "\n\n");
std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length));
tooling::Replacements Replaces = reformat(Style, Code, Ranges);
auto Result = applyAllReplacements(Code, Replaces);
EXPECT_TRUE(static_cast<bool>(Result));
LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
return *Result;
}
static std::string format(llvm::StringRef Code, const FormatStyle &Style) {
return format(Code, 0, Code.size(), Style);
}
static void verifyFormat(llvm::StringRef Code, const FormatStyle &Style) {
EXPECT_EQ(Code.str(), format(Code, Style)) << "Expected code is not stable";
EXPECT_EQ(Code.str(), format(test::messUp(Code), Style));
}
static void verifyFormat(llvm::StringRef Code) {
FormatStyle Style = getGoogleStyle(FormatStyle::LK_TextProto);
Style.ColumnLimit = 60; // To make writing tests easier.
verifyFormat(Code, Style);
}
};
TEST_F(FormatTestTextProto, KeepsTopLevelEntriesFittingALine) {
verifyFormat("field_a: OK field_b: OK field_c: OK field_d: OK field_e: OK");
}
TEST_F(FormatTestTextProto, SupportsMessageFields) {
verifyFormat("msg_field: {}");
verifyFormat("msg_field: { field_a: A }");
verifyFormat("msg_field: { field_a: \"OK\" field_b: 123 }");
verifyFormat("msg_field: {\n"
" field_a: 1\n"
" field_b: OK\n"
" field_c: \"OK\"\n"
" field_d: 123\n"
" field_e: 23\n"
"}");
verifyFormat("msg_field {}");
verifyFormat("msg_field { field_a: A }");
verifyFormat("msg_field { field_a: \"OK\" field_b: 123 }");
verifyFormat("msg_field {\n"
" field_a: 1\n"
" field_b: OK\n"
" field_c: \"OK\"\n"
" field_d: 123\n"
" field_e: 23.0\n"
" field_f: false\n"
" field_g: 'lala'\n"
" field_h: 1234.567e-89\n"
"}");
verifyFormat("msg_field: { msg_field { field_a: 1 } }");
verifyFormat("id: \"ala.bala\"\n"
"item { type: ITEM_A rank: 1 score: 90.0 }\n"
"item { type: ITEM_B rank: 2 score: 70.5 }\n"
"item {\n"
" type: ITEM_A\n"
" rank: 3\n"
" score: 20.0\n"
" description: \"the third item has a description\"\n"
"}");
}
TEST_F(FormatTestTextProto, AvoidsTopLevelBinPacking) {
verifyFormat("field_a: OK\n"
"field_b: OK\n"
"field_c: OK\n"
"field_d: OK\n"
"field_e: OK\n"
"field_f: OK");
verifyFormat("field_a: OK\n"
"field_b: \"OK\"\n"
"field_c: \"OK\"\n"
"msg_field: { field_d: 123 }\n"
"field_e: OK\n"
"field_f: OK");
verifyFormat("field_a: OK\n"
"field_b: \"OK\"\n"
"field_c: \"OK\"\n"
"msg_field: { field_d: 123 field_e: OK }");
verifyFormat("a: {\n"
" field_a: OK\n"
" field_b { field_c: OK }\n"
" field_d: OKOKOK\n"
" field_e: OK\n"
"}");
verifyFormat("field_a: OK,\n"
"field_b { field_c: OK },\n"
"field_d: OKOKOK,\n"
"field_e: OK");
}
TEST_F(FormatTestTextProto, AddsNewlinesAfterTrailingComments) {
verifyFormat("field_a: OK // Comment\n"
"field_b: 1");
verifyFormat("field_a: OK\n"
"msg_field: {\n"
" field_b: OK // Comment\n"
"}");
verifyFormat("field_a: OK\n"
"msg_field {\n"
" field_b: OK // Comment\n"
"}");
}
TEST_F(FormatTestTextProto, ImplicitStringLiteralConcatenation) {
verifyFormat("field_a: 'aaaaa'\n"
" 'bbbbb'");
verifyFormat("field_a: \"aaaaa\"\n"
" \"bbbbb\"");
FormatStyle Style = getGoogleStyle(FormatStyle::LK_TextProto);
Style.AlwaysBreakBeforeMultilineStrings = true;
verifyFormat("field_a:\n"
" 'aaaaa'\n"
" 'bbbbb'",
Style);
verifyFormat("field_a:\n"
" \"aaaaa\"\n"
" \"bbbbb\"",
Style);
}
TEST_F(FormatTestTextProto, SupportsAngleBracketMessageFields) {
// Single-line tests
verifyFormat("msg_field <>");
verifyFormat("msg_field: <>");
verifyFormat("msg_field < field_a: OK >");
verifyFormat("msg_field: < field_a: 123 >");
verifyFormat("msg_field < field_a <> >");
verifyFormat("msg_field < field_a < field_b <> > >");
verifyFormat("msg_field: < field_a < field_b: <> > >");
verifyFormat("msg_field < field_a: OK, field_b: \"OK\" >");
verifyFormat("msg_field: < field_a: OK, field_b: \"OK\" >");
// Multiple lines tests
verifyFormat("msg_field <\n"
" field_a: OK\n"
" field_b: <>,\n"
" field_c: OK\n"
">");
verifyFormat("msg_field <\n"
" field_a { field_b: 1 },\n"
" field_c: < f_d: 2 >\n"
">");
verifyFormat("msg_field: <\n"
" field_a: OK\n"
" field_b: <>,\n"
" field_c: OK\n"
">");
verifyFormat("msg_field: <\n"
" field_a { field_b: 1 },\n"
" field_c: < fd_d: 2 >\n"
">");
verifyFormat("field_a: \"OK\",\n"
"msg_field: < field_b: 123 >,\n"
"field_c: {}");
verifyFormat("field_a < field_b: 1 >,\n"
"msg_fid: < fiel_b: 123 >,\n"
"field_c <>");
verifyFormat("field_a < field_b: 1 >\n"
"msg_fied: < field_b: 123 >\n"
"field_c <>");
verifyFormat("field <\n"
" field < field: <> >,\n"
" field <>\n"
">\n"
"field: < field: 1 >");
verifyFormat("msg_field <\n"
" field_a: OK\n"
" field_b: \"OK\"\n"
" field_c: 1\n"
" field_d: 12.5\n"
" field_e: OK\n"
">");
verifyFormat("msg_field: <>\n"
"field_c: \"OK\",\n"
"msg_field: < field_d: 123 >\n"
"field_e: OK\n"
"msg_field: < field_d: 12 >");
verifyFormat("field_a: OK,\n"
"field_b < field_c: OK >,\n"
"field_d: < 12.5 >,\n"
"field_e: OK");
verifyFormat("field_a: OK\n"
"field_b < field_c: OK >\n"
"field_d: < 12.5 >\n"
"field_e: OKOKOK");
verifyFormat("msg_field <\n"
" field_a: OK,\n"
" field_b < field_c: OK >,\n"
" field_d: < 12.5 >,\n"
" field_e: OK\n"
">");
verifyFormat("msg_field <\n"
" field_a: < field: OK >,\n"
" field_b < field_c: OK >,\n"
" field_d: < 12.5 >,\n"
" field_e: OK,\n"
">");
verifyFormat("msg_field: <\n"
" field_a: \"OK\"\n"
" msg_field: { field_b: OK }\n"
" field_g: OK\n"
" field_g: OK\n"
" field_g: OK\n"
">");
verifyFormat("field_a {\n"
" field_d: ok\n"
" field_b: < field_c: 1 >\n"
" field_d: ok\n"
" field_d: ok\n"
"}");
verifyFormat("field_a: {\n"
" field_d: ok\n"
" field_b: < field_c: 1 >\n"
" field_d: ok\n"
" field_d: ok\n"
"}");
verifyFormat("field_a: <\n"
" f1: 1,\n"
" f2: <>\n"
">\n"
"field_b <\n"
" field_b1: <>\n"
" field_b2: ok,\n"
" field_b3: <\n"
" field_x {} // Comment\n"
" field_y: { field_z: 1 }\n"
" field_w: ok\n"
" >\n"
" field {\n"
" field_x <> // Comment\n"
" field_y: < field_z: 1 >\n"
" field_w: ok\n"
" msg_field: <\n"
" field: <>\n"
" field: < field: 1 >\n"
" field: < field: 2 >\n"
" field: < field: 3 >\n"
" field: < field: 4 >\n"
" field: ok\n"
" >\n"
" }\n"
">\n"
"field: OK,\n"
"field_c < field < field <> > >");
verifyFormat("app_id: 'com.javax.swing.salsa.latino'\n"
"head_id: 1\n"
"data < key: value >");
verifyFormat("app_id: 'com.javax.swing.salsa.latino'\n"
"head_id: 1\n"
"data < key: value >\n"
"tail_id: 2");
verifyFormat("app_id: 'com.javax.swing.salsa.latino'\n"
"head_id: 1\n"
"data < key: value >\n"
"data { key: value }");
verifyFormat("app {\n"
" app_id: 'com.javax.swing.salsa.latino'\n"
" head_id: 1\n"
" data < key: value >\n"
"}");
verifyFormat("app: {\n"
" app_id: 'com.javax.swing.salsa.latino'\n"
" head_id: 1\n"
" data < key: value >\n"
"}");
verifyFormat("app_id: 'com.javax.swing.salsa.latino'\n"
"headheadheadheadheadhead_id: 1\n"
"product_data { product { 1 } }");
verifyFormat("app_id: 'com.javax.swing.salsa.latino'\n"
"headheadheadheadheadhead_id: 1\n"
"product_data < product { 1 } >");
verifyFormat("app_id: 'com.javax.swing.salsa.latino'\n"
"headheadheadheadheadhead_id: 1\n"
"product_data < product < 1 > >");
verifyFormat("app <\n"
" app_id: 'com.javax.swing.salsa.latino'\n"
" headheadheadheadheadhead_id: 1\n"
" product_data < product { 1 } >\n"
">");
verifyFormat("dcccwrnfioeruvginerurneitinfo {\n"
" exte3nsionrnfvui { key: value }\n"
"}");
}
TEST_F(FormatTestTextProto, DiscardsUnbreakableTailIfCanBreakAfter) {
// The two closing braces count towards the string UnbreakableTailLength, but
// since we have broken after the corresponding opening braces, we don't
// consider that length for string breaking.
verifyFormat(
"foo: {\n"
" bar: {\n"
" text: \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
" }\n"
"}");
}
TEST_F(FormatTestTextProto, KeepsLongStringLiteralsOnSameLine) {
verifyFormat(
"foo: {\n"
" text: \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasaaaaaaaaaa\"\n"
"}");
}
TEST_F(FormatTestTextProto, KeepsCommentsIndentedInList) {
verifyFormat("aaaaaaaaaa: 100\n"
"bbbbbbbbbbbbbbbbbbbbbbbbbbb: 200\n"
"# Single line comment for stuff here.\n"
"cccccccccccccccccccccccc: 3849\n"
"# Multiline comment for stuff here.\n"
"# Multiline comment for stuff here.\n"
"# Multiline comment for stuff here.\n"
"cccccccccccccccccccccccc: 3849");
}
TEST_F(FormatTestTextProto, UnderstandsHashHashComments) {
FormatStyle Style = getGoogleStyle(FormatStyle::LK_TextProto);
Style.ColumnLimit = 60; // To make writing tests easier.
EXPECT_EQ("aaa: 100\n"
"##this is a double-hash comment.\n"
"bb: 100\n"
"## another double-hash comment.\n"
"### a triple-hash comment\n"
"cc: 200\n"
"#### a quadriple-hash comment\n"
"dd: 100\n",
format("aaa: 100\n"
"##this is a double-hash comment.\n"
"bb: 100\n"
"## another double-hash comment.\n"
"### a triple-hash comment\n"
"cc: 200\n"
"#### a quadriple-hash comment\n"
"dd: 100\n",
Style));
}
TEST_F(FormatTestTextProto, FormatsExtensions) {
verifyFormat("[type] { key: value }");
verifyFormat("[type] {\n"
" keyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy: value\n"
"}");
verifyFormat("[type.type] { key: value }");
verifyFormat("[type.type] < key: value >");
verifyFormat("[type.type/type.type] { key: value }");
verifyFormat("msg {\n"
" [type.type] { key: value }\n"
"}");
verifyFormat("msg {\n"
" [type.type] {\n"
" keyyyyyyyyyyyyyy: valuuuuuuuuuuuuuuuuuuuuuuuuue\n"
" }\n"
"}");
verifyFormat("key: value\n"
"[a.b] { key: value }");
verifyFormat("msg: <\n"
" key: value\n"
" [a.b.c/d.e]: < key: value >\n"
" [f.g]: <\n"
" key: valueeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\n"
" key: {}\n"
" >\n"
" key {}\n"
" [h.i.j] < key: value >\n"
" [a]: {\n"
" [b.c]: {}\n"
" [d] <>\n"
" [e/f]: 1\n"
" }\n"
">");
verifyFormat("[longg.long.long.long.long.long.long.long.long.long.long\n"
" .longg.longlong] { key: value }");
verifyFormat("[longg.long.long.long.long.long.long.long.long.long.long\n"
" .longg.longlong] {\n"
" key: value\n"
" key: value\n"
" key: value\n"
" key: value\n"
"}");
verifyFormat("[longg.long.long.long.long.long.long.long.long.long\n"
" .long/longg.longlong] { key: value }");
verifyFormat("[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/\n"
" bbbbbbbbbbbbbb] { key: value }");
// These go over the column limit intentionally, since the alternative
// [aa..a\n] is worse.
verifyFormat(
"[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] {\n"
" key: value\n"
"}");
verifyFormat(
"[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] {\n"
" [type.type] {\n"
" keyyyyyyyyyyyyyy: valuuuuuuuuuuuuuuuuuuuuuuuuue\n"
" }\n"
"}");
verifyFormat("[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/\n"
" bbbbbbb] {\n"
" [type.type] {\n"
" keyyyyyyyyyyyyyy: valuuuuuuuuuuuuuuuuuuuuuuuuue\n"
" }\n"
"}");
verifyFormat(
"aaaaaaaaaaaaaaa {\n"
" bbbbbb {\n"
" [a.b/cy] {\n"
" eeeeeeeeeeeee: \"The lazy coo cat jumps over the lazy hot dog\"\n"
" }\n"
" }\n"
"}");
}
TEST_F(FormatTestTextProto, SpacesAroundPercents) {
verifyFormat("key: %d");
verifyFormat("key: 0x%04x");
verifyFormat("key: \"%d %d\"");
}
TEST_F(FormatTestTextProto, FormatsRepeatedListInitializers) {
verifyFormat("keys: []");
verifyFormat("keys: [ 1 ]");
verifyFormat("keys: [ 'ala', 'bala' ]");
verifyFormat("keys: [\n"
" 'ala',\n"
" 'bala',\n"
" 'porto',\n"
" 'kala',\n"
" 'too',\n"
" 'long',\n"
" 'ng'\n"
"]");
verifyFormat("key: item\n"
"keys: [\n"
" 'ala',\n"
" 'bala',\n"
" 'porto',\n"
" 'kala',\n"
" 'too',\n"
" 'long',\n"
" 'long',\n"
" 'long'\n"
"]\n"
"key: item\n"
"msg {\n"
" key: item\n"
" keys: [\n"
" 'ala',\n"
" 'bala',\n"
" 'porto',\n"
" 'kala',\n"
" 'too',\n"
" 'long',\n"
" 'long'\n"
" ]\n"
"}\n"
"key: value");
FormatStyle Style = getGoogleStyle(FormatStyle::LK_TextProto);
Style.ColumnLimit = 60; // To make writing tests easier.
Style.Cpp11BracedListStyle = true;
verifyFormat("keys: [1]", Style);
}
TEST_F(FormatTestTextProto, AcceptsOperatorAsKey) {
verifyFormat("aaaaaaaaaaa: <\n"
" bbbbbbbbb: <\n"
" ccccccccccccccccccccccc: <\n"
" operator: 1\n"
" operator: 2\n"
" operator: 3\n"
" operator { key: value }\n"
" >\n"
" >\n"
">");
}
TEST_F(FormatTestTextProto, BreaksConsecutiveStringLiterals) {
verifyFormat("ala: \"str1\"\n"
" \"str2\"\n");
}
TEST_F(FormatTestTextProto, PutsMultipleEntriesInExtensionsOnNewlines) {
FormatStyle Style = getGoogleStyle(FormatStyle::LK_TextProto);
verifyFormat("pppppppppp: {\n"
" ssssss: \"http://example.com/blahblahblah\"\n"
" ppppppp: \"sssss/MMMMMMMMMMMM\"\n"
" [ns.sssss.eeeeeeeee.eeeeeeeeeeeeeee] { begin: 24 end: 252 }\n"
" [ns.sssss.eeeeeeeee.eeeeeeeeeeeeeee] {\n"
" begin: 24\n"
" end: 252\n"
" key: value\n"
" key: value\n"
" }\n"
"}",
Style);
}
TEST_F(FormatTestTextProto, BreaksAfterBraceFollowedByClosingBraceOnNextLine) {
FormatStyle Style = getGoogleStyle(FormatStyle::LK_TextProto);
Style.ColumnLimit = 60;
verifyFormat("keys: [\n"
" data: { item: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' }\n"
"]");
verifyFormat("keys: <\n"
" data: { item: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' }\n"
">");
}
TEST_F(FormatTestTextProto, BreaksEntriesOfSubmessagesContainingSubmessages) {
FormatStyle Style = getGoogleStyle(FormatStyle::LK_TextProto);
Style.ColumnLimit = 60;
// The column limit allows for the keys submessage to be put on 1 line, but we
// break it since it contains a submessage an another entry.
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
" sub <>\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
" sub {}\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" sub {}\n"
" sub: <>\n"
" sub: []\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" item: 'aaaaaaaaaaa'\n"
" sub { msg: 1 }\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" item: 'aaaaaaaaaaa'\n"
" sub: { msg: 1 }\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" item: 'aaaaaaaaaaa'\n"
" sub < msg: 1 >\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" item: 'aaaaaaaaaaa'\n"
" sub: [ msg: 1 ]\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: <\n"
" item: 'aaaaaaaaaaa'\n"
" sub: [ 1, 2 ]\n"
">");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" sub {}\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" sub: []\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" sub <>\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" sub { key: value }\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" sub: [ 1, 2 ]\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" sub < sub_2: {} >\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" item: data\n"
" sub: [ 1, 2 ]\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" item: data\n"
" sub < sub_2: {} >\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
"}");
verifyFormat("sub: {\n"
" key: valueeeeeeee\n"
" keys: {\n"
" sub: [ 1, 2 ]\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
" }\n"
"}");
verifyFormat("sub: {\n"
" key: 1\n"
" sub: {}\n"
"}\n"
"# comment\n");
verifyFormat("sub: {\n"
" key: 1\n"
" # comment\n"
" sub: {}\n"
"}");
}
TEST_F(FormatTestTextProto, PreventBreaksBetweenKeyAndSubmessages) {
verifyFormat("submessage: {\n"
" key: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n"
"}");
verifyFormat("submessage {\n"
" key: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n"
"}");
verifyFormat("submessage: <\n"
" key: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n"
">");
verifyFormat("submessage <\n"
" key: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n"
">");
verifyFormat("repeatedd: [\n"
" 'eyaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n"
"]");
// "{" is going over the column limit.
verifyFormat(
"submessageeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee: {\n"
" key: 'aaaaa'\n"
"}");
}
TEST_F(FormatTestTextProto, FormatsCommentsAtEndOfFile) {
verifyFormat("key: value\n"
"# endfile comment");
verifyFormat("key: value\n"
"// endfile comment");
verifyFormat("key: value\n"
"// endfile comment 1\n"
"// endfile comment 2");
verifyFormat("submessage { key: value }\n"
"# endfile comment");
verifyFormat("submessage <\n"
" key: value\n"
" item {}\n"
">\n"
"# endfile comment");
}
TEST_F(FormatTestTextProto, KeepsAmpersandsNextToKeys) {
verifyFormat("@tmpl { field: 1 }");
verifyFormat("@placeholder: 1");
verifyFormat("@name <>");
verifyFormat("submessage: @base { key: value }");
verifyFormat("submessage: @base {\n"
" key: value\n"
" item: {}\n"
"}");
verifyFormat("submessage: {\n"
" msg: @base {\n"
" yolo: {}\n"
" key: value\n"
" }\n"
" key: value\n"
"}");
}
} // namespace format
} // end namespace clang