//===- 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(const char *File, int Line, llvm::StringRef Code,
                            const FormatStyle &Style) {
    ::testing::ScopedTrace t(File, Line, ::testing::Message() << Code.str());
    EXPECT_EQ(Code.str(), format(Code, Style)) << "Expected code is not stable";
    EXPECT_EQ(Code.str(), format(test::messUp(Code), Style));
  }

  static void _verifyFormat(const char *File, int Line, llvm::StringRef Code) {
    FormatStyle Style = getGoogleStyle(FormatStyle::LK_TextProto);
    Style.ColumnLimit = 60; // To make writing tests easier.
    _verifyFormat(File, Line, Code, Style);
  }
};

#define verifyFormat(...) _verifyFormat(__FILE__, __LINE__, __VA_ARGS__)

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, UnderstandsHashComments) {
  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"
            "### another triple-hash comment\n"
            "#### a quadriple-hash comment\n"
            "dd: 100\n"
            "#### another quadriple-hash comment\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"
                   "### another triple-hash comment\n"
                   "####a quadriple-hash comment\n"
                   "dd: 100\n"
                   "#### another quadriple-hash comment\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
