common/lsp/lsp-text-buffer_test.cc - third_party/verible - Git at Google

 // Copyright 2021 The Verible Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "common/lsp/lsp-text-buffer.h"

 #include "absl/strings/str_cat.h"
 #include "common/lsp/json-rpc-dispatcher.h"
 #include "gtest/gtest.h"

 namespace verible {
 namespace lsp {
 TEST(TextBufferTest, RecreateEmptyFile) {
   EditTextBuffer buffer("");
   EXPECT_EQ(buffer.lines(), 0);
   EXPECT_EQ(buffer.document_length(), 0);
   buffer.RequestContent([](absl::string_view s) {  //
     EXPECT_TRUE(s.empty());
   });
 }

 TEST(TextBufferTest, RequestParticularLine) {
   EditTextBuffer buffer("foo\nbar\nbaz\n");
   ASSERT_EQ(buffer.lines(), 3);
   buffer.RequestLine(0, [](absl::string_view s) {  //
     EXPECT_EQ(std::string(s), "foo\n");
   });
   buffer.RequestLine(1, [](absl::string_view s) {  //
     EXPECT_EQ(std::string(s), "bar\n");
   });

   // Be graceful with out-of-range requests.
   buffer.RequestLine(-1, [](absl::string_view s) {  //
     EXPECT_TRUE(s.empty());
   });
   buffer.RequestLine(100, [](absl::string_view s) {  //
     EXPECT_TRUE(s.empty());
   });
 }

 TEST(TextBufferTest, RecreateFileWithAndWithoutNewlineAtEOF) {
   static constexpr absl::string_view kBaseFile =
       "Hello World\n"
       "\n"
       "Foo";

   for (const absl::string_view append : {"", "\n", "\r\n"}) {
     const std::string &content = absl::StrCat(kBaseFile, append);
     EditTextBuffer buffer(content);
     EXPECT_EQ(buffer.lines(), 3);

     buffer.RequestContent([&](absl::string_view s) {  //
       EXPECT_EQ(std::string(s), content);
     });
   }
 }

 TEST(TextBufferTest, RecreateCRLFFiles) {
   EditTextBuffer buffer("Foo\r\nBar\r\n");
   EXPECT_EQ(buffer.lines(), 2);
   buffer.RequestContent([&](absl::string_view s) {
     EXPECT_EQ("Foo\r\nBar\r\n", std::string(s));
   });
 }

 TEST(TextBufferTest, ChangeApplyFullContent) {
   EditTextBuffer buffer("Foo\nBar\n");
   const TextDocumentContentChangeEvent change = {
       .range = {},
       .has_range = false,
       .text = "NewFile",
   };
   EXPECT_TRUE(buffer.ApplyChange(change));
   buffer.RequestContent([&](absl::string_view s) {  //
     EXPECT_EQ("NewFile", std::string(s));
   });
 }

 TEST(TextBufferTest, ChangeApplySingleLine_Insert) {
   EditTextBuffer buffer("Hello World");
   const TextDocumentContentChangeEvent change = {
       .range =
           {
               .start = {0, 6},
               .end = {0, 6},
           },
       .has_range = true,
       .text = "brave ",
   };
   EXPECT_TRUE(buffer.ApplyChange(change));
   EXPECT_EQ(buffer.document_length(), 17);
   buffer.RequestContent([&](absl::string_view s) {
     EXPECT_EQ("Hello brave World", std::string(s));
   });
 }

 TEST(TextBufferTest, ChangeApplySingleLineWithUTF8Characters_Insert) {
   EditTextBuffer buffer("Hëllö World");
   const TextDocumentContentChangeEvent change = {
       .range =
           {
               .start = {0, 6},
               .end = {0, 6},
           },
       .has_range = true,
       .text = "brave ",
   };
   EXPECT_TRUE(buffer.ApplyChange(change));
   EXPECT_EQ(buffer.document_length(), 19);
   buffer.RequestContent([&](absl::string_view s) {
     EXPECT_EQ("Hëllö brave World", std::string(s));
   });
 }

 TEST(TextBufferTest, ChangeApplySingleLine_InsertFromEmptyFile) {
   EditTextBuffer buffer("");
   const TextDocumentContentChangeEvent change = {
       .range =
           {
               .start = {0, 0},
               .end = {0, 0},
           },
       .has_range = true,
       .text = "New File!",
   };
   EXPECT_TRUE(buffer.ApplyChange(change));
   buffer.RequestContent([&](absl::string_view s) {  //
     EXPECT_EQ("New File!", std::string(s));
   });
 }

 TEST(TextBufferTest, ChangeApplySingleLine_Replace) {
   EditTextBuffer buffer("Hello World\n");
   const TextDocumentContentChangeEvent change = {
       .range =
           {
               .start = {0, 6},
               .end = {0, 11},
           },
       .has_range = true,
       .text = "Planet",
   };
   EXPECT_TRUE(buffer.ApplyChange(change));
   buffer.RequestContent([&](absl::string_view s) {
     EXPECT_EQ("Hello Planet\n", std::string(s));
   });
 }

 TEST(TextBufferTest, ChangeApplySingleLineWihtUTF8Characters_Replace) {
   EditTextBuffer buffer("Heizölrückstoßabdämpfung\n");
   const TextDocumentContentChangeEvent change = {
       .range =
           {
               .start = {0, 6},
               .end = {0, 14},
           },
       .has_range = true,
       .text = "brandgefahr",
   };
   EXPECT_TRUE(buffer.ApplyChange(change));
   buffer.RequestContent([&](absl::string_view s) {
     EXPECT_EQ("Heizölbrandgefahrabdämpfung\n", std::string(s));
   });
 }

 TEST(TextBufferTest, ChangeApplySingleLine_ReplaceNotFirstLine) {
   // Make sure we properly access the right line.
   EditTextBuffer buffer("Hello World\nFoo\n");
   const TextDocumentContentChangeEvent change = {
       .range =
           {
               .start = {1, 0},
               .end = {1, 3},
           },
       .has_range = true,
       .text = "Bar",
   };
   EXPECT_TRUE(buffer.ApplyChange(change));
   buffer.RequestContent([&](absl::string_view s) {
     EXPECT_EQ("Hello World\nBar\n", std::string(s));
   });
 }

 TEST(TextBufferTest, ChangeApplySingleLine_Erase) {
   EditTextBuffer buffer("Hello World\n");
   const TextDocumentContentChangeEvent change = {
       .range =
           {
               .start = {0, 5},
               .end = {0, 11},
           },
       .has_range = true,
       .text = "",
   };
   EXPECT_TRUE(buffer.ApplyChange(change));
   EXPECT_EQ(buffer.document_length(), 6);
   buffer.RequestContent([&](absl::string_view s) {  //
     EXPECT_EQ("Hello\n", std::string(s));
   });
 }

 TEST(TextBufferTest, ChangeApplySingleLine_ReplaceCorrectOverlongEnd) {
   const TextDocumentContentChangeEvent change = {
       .range =
           {
               .start = {0, 6}, .end = {0, 42},  // Too long end shall be trimmed
           },
       .has_range = true,
       .text = "Planet",
   };

   {
     EditTextBuffer buffer("Hello World\n");
     EXPECT_TRUE(buffer.ApplyChange(change));
     buffer.RequestContent([&](absl::string_view s) {
       EXPECT_EQ("Hello Planet\n", std::string(s));
     });
   }

   {
     EditTextBuffer buffer("Hello World");
     EXPECT_TRUE(buffer.ApplyChange(change));
     buffer.RequestContent([&](absl::string_view s) {
       EXPECT_EQ("Hello Planet", std::string(s));
     });
   }
 }

 TEST(TextBufferTest, ChangeApplyMultiLine_EraseBetweenLines) {
   EditTextBuffer buffer("Hello\nWorld\n");
   const TextDocumentContentChangeEvent change = {
       .range =
           {
               .start = {0, 2},  // From here to end of line
               .end = {1, 0},
           },
       .has_range = true,
       .text = "y ",
   };
   EXPECT_TRUE(buffer.ApplyChange(change));
   buffer.RequestContent([&](absl::string_view s) {  //
     EXPECT_EQ("Hey World\n", std::string(s));
   });
   EXPECT_EQ(buffer.document_length(), 10);
 }

 TEST(TextBufferTest, ChangeApplyMultiLineWithUTF8Characters_Modify) {
   EditTextBuffer buffer("Heizölrück-\nstoßabdämpfung\n");
   const TextDocumentContentChangeEvent change = {
       .range =
           {
               .start = {0, 6},  // From here to end of line
               .end = {1, 4},
           },
       .has_range = true,
       .text = "brand-\ngefahr",
   };
   EXPECT_TRUE(buffer.ApplyChange(change));
   buffer.RequestContent([&](absl::string_view s) {  //
     EXPECT_EQ("Heizölbrand-\ngefahrabdämpfung\n", std::string(s));
   });
 }

 TEST(TextBufferTest, ChangeApplyMultiLine_InsertMoreLines) {
   EditTextBuffer buffer("Hello\nbrave World\n");
   const TextDocumentContentChangeEvent change = {
       .range =
           {
               .start = {0, 2},  // From here to end of line
               .end = {1, 5},
           },
       .has_range = true,
       .text = "y!\nThis will be a new line\nand more in this",
   };
   EXPECT_EQ(buffer.lines(), 2);
   EXPECT_TRUE(buffer.ApplyChange(change));
   EXPECT_EQ(buffer.lines(), 3);
   static constexpr absl::string_view kExpected =
       "Hey!\nThis will be a new line\nand more in this World\n";
   buffer.RequestContent([&](absl::string_view s) {  //
     EXPECT_EQ(kExpected, std::string(s));
   });
   EXPECT_EQ(buffer.document_length(), kExpected.length());
 }

 TEST(TextBufferTest, ChangeApplyMultiLine_InsertFromStart) {
   EditTextBuffer buffer("");
   const TextDocumentContentChangeEvent change = {
       .range =
           {
               .start = {0, 0},
               .end = {0, 0},
           },
       .has_range = true,
       .text = "This is now\na multiline\nfile\n",
   };
   EXPECT_EQ(buffer.lines(), 0);
   EXPECT_TRUE(buffer.ApplyChange(change));
   EXPECT_EQ(buffer.lines(), 3);
   buffer.RequestContent([&](absl::string_view s) {
     EXPECT_EQ("This is now\na multiline\nfile\n", std::string(s));
   });
   EXPECT_EQ(buffer.document_length(), change.text.length());
 }

 TEST(TextBufferTest, ChangeApplyMultiLine_RemoveLines) {
   EditTextBuffer buffer("Foo\nBar\nBaz\nQuux");
   const TextDocumentContentChangeEvent change = {
       .range =
           {
               .start = {1, 0},
               .end = {3, 0},
           },
       .has_range = true,
       .text = "",
   };
   EXPECT_EQ(buffer.lines(), 4);
   EXPECT_TRUE(buffer.ApplyChange(change));
   EXPECT_EQ(buffer.lines(), 2);
   buffer.RequestContent([&](absl::string_view s) {  //
     EXPECT_EQ("Foo\nQuux", std::string(s));
   });
   EXPECT_EQ(buffer.document_length(), 8);
 }

 TEST(BufferCollection, SimulateDocumentLifecycleThroughRPC) {
   // Let's walk a BufferCollection through the lifecycle of a document
   // by sending it the JSON RPC notifications for open, change and close.
   //
   // Inspect at each step that the content and number of documents is what
   // we expect.

   // Notifications don't send any responses; write function not relevant.
   JsonRpcDispatcher rpc_dispatcher([](absl::string_view) {});
   BufferCollection collection(&rpc_dispatcher);

   EXPECT_EQ(collection.documents_open(), 0);

   int64_t last_global_version = 0;

   // Let's check that the callback is called on opening and contains
   // the right content.
   int change_callback_called = 0;
   collection.SetChangeListener(
       [&](const std::string &uri, const EditTextBuffer *buffer) {
         EXPECT_EQ(uri, "file:///foo.cc");
         buffer->RequestContent([](absl::string_view s) {
           EXPECT_EQ(std::string(s), "Hello\nworld");
         });
         change_callback_called++;
       });

   // ------ Opening new document
   // Simulate an incoming event from the client
   rpc_dispatcher.DispatchMessage(R"({
     "jsonrpc":"2.0",
     "method":"textDocument/didOpen",
     "params":{
         "textDocument":{
            "uri": "file:///foo.cc",
            "text": "Hello\nworld",
            "languageId": "cpp",
            "version": 1
          }
     }})");

   // We now expect one document to be open.
   EXPECT_EQ(collection.documents_open(), 1);
   EXPECT_EQ(change_callback_called, 1);

   EXPECT_GT(collection.global_version(), last_global_version);

   // Prepare for the next expected change
   collection.SetChangeListener(
       [&](const std::string &uri, const EditTextBuffer *buffer) {
         EXPECT_EQ(uri, "file:///foo.cc");
         buffer->RequestContent(
             [](absl::string_view s) { EXPECT_EQ(std::string(s), "Hey"); });
         change_callback_called++;
       });

   // ------ Editing document: receive content changes
   rpc_dispatcher.DispatchMessage(R"({
     "jsonrpc":"2.0",
     "method":"textDocument/didChange",
     "params":{
         "textDocument":   { "uri": "file:///foo.cc" },
         "contentChanges": [ {"text":"Hey"} ]
      }})");

   EXPECT_EQ(change_callback_called, 2);

   // Upcoming change will send us a nullptr buffer as it is removed.
   collection.SetChangeListener(
       [&](const std::string &uri, const EditTextBuffer *buffer) {
         EXPECT_EQ(buffer, nullptr);
         change_callback_called++;
       });

   // ------ Closing document
   rpc_dispatcher.DispatchMessage(R"({
     "jsonrpc":"2.0",
     "method":"textDocument/didClose",
     "params":{
         "textDocument":{ "uri": "file:///foo.cc" }
      }})");

   // No document open anymore
   EXPECT_EQ(collection.documents_open(), 0);
   EXPECT_EQ(change_callback_called, 3);
 }

 }  // namespace lsp
 }  // namespace verible
	// Copyright 2021 The Verible Authors.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "common/lsp/lsp-text-buffer.h"

	#include "absl/strings/str_cat.h"
	#include "common/lsp/json-rpc-dispatcher.h"
	#include "gtest/gtest.h"

	namespace verible {
	namespace lsp {
	TEST(TextBufferTest, RecreateEmptyFile) {
	EditTextBuffer buffer("");
	EXPECT_EQ(buffer.lines(), 0);
	EXPECT_EQ(buffer.document_length(), 0);
	buffer.RequestContent([](absl::string_view s) { //
	EXPECT_TRUE(s.empty());
	});
	}

	TEST(TextBufferTest, RequestParticularLine) {
	EditTextBuffer buffer("foo\nbar\nbaz\n");
	ASSERT_EQ(buffer.lines(), 3);
	buffer.RequestLine(0, [](absl::string_view s) { //
	EXPECT_EQ(std::string(s), "foo\n");
	});
	buffer.RequestLine(1, [](absl::string_view s) { //
	EXPECT_EQ(std::string(s), "bar\n");
	});

	// Be graceful with out-of-range requests.
	buffer.RequestLine(-1, [](absl::string_view s) { //
	EXPECT_TRUE(s.empty());
	});
	buffer.RequestLine(100, [](absl::string_view s) { //
	EXPECT_TRUE(s.empty());
	});
	}

	TEST(TextBufferTest, RecreateFileWithAndWithoutNewlineAtEOF) {
	static constexpr absl::string_view kBaseFile =
	"Hello World\n"
	"\n"
	"Foo";

	for (const absl::string_view append : {"", "\n", "\r\n"}) {
	const std::string &content = absl::StrCat(kBaseFile, append);
	EditTextBuffer buffer(content);
	EXPECT_EQ(buffer.lines(), 3);

	buffer.RequestContent([&](absl::string_view s) { //
	EXPECT_EQ(std::string(s), content);
	});
	}
	}

	TEST(TextBufferTest, RecreateCRLFFiles) {
	EditTextBuffer buffer("Foo\r\nBar\r\n");
	EXPECT_EQ(buffer.lines(), 2);
	buffer.RequestContent([&](absl::string_view s) {
	EXPECT_EQ("Foo\r\nBar\r\n", std::string(s));
	});
	}

	TEST(TextBufferTest, ChangeApplyFullContent) {
	EditTextBuffer buffer("Foo\nBar\n");
	const TextDocumentContentChangeEvent change = {
	.range = {},
	.has_range = false,
	.text = "NewFile",
	};
	EXPECT_TRUE(buffer.ApplyChange(change));
	buffer.RequestContent([&](absl::string_view s) { //
	EXPECT_EQ("NewFile", std::string(s));
	});
	}

	TEST(TextBufferTest, ChangeApplySingleLine_Insert) {
	EditTextBuffer buffer("Hello World");
	const TextDocumentContentChangeEvent change = {
	.range =
	{
	.start = {0, 6},
	.end = {0, 6},
	},
	.has_range = true,
	.text = "brave ",
	};
	EXPECT_TRUE(buffer.ApplyChange(change));
	EXPECT_EQ(buffer.document_length(), 17);
	buffer.RequestContent([&](absl::string_view s) {
	EXPECT_EQ("Hello brave World", std::string(s));
	});
	}

	TEST(TextBufferTest, ChangeApplySingleLineWithUTF8Characters_Insert) {
	EditTextBuffer buffer("Hëllö World");
	const TextDocumentContentChangeEvent change = {
	.range =
	{
	.start = {0, 6},
	.end = {0, 6},
	},
	.has_range = true,
	.text = "brave ",
	};
	EXPECT_TRUE(buffer.ApplyChange(change));
	EXPECT_EQ(buffer.document_length(), 19);
	buffer.RequestContent([&](absl::string_view s) {
	EXPECT_EQ("Hëllö brave World", std::string(s));
	});
	}

	TEST(TextBufferTest, ChangeApplySingleLine_InsertFromEmptyFile) {
	EditTextBuffer buffer("");
	const TextDocumentContentChangeEvent change = {
	.range =
	{
	.start = {0, 0},
	.end = {0, 0},
	},
	.has_range = true,
	.text = "New File!",
	};
	EXPECT_TRUE(buffer.ApplyChange(change));
	buffer.RequestContent([&](absl::string_view s) { //
	EXPECT_EQ("New File!", std::string(s));
	});
	}

	TEST(TextBufferTest, ChangeApplySingleLine_Replace) {
	EditTextBuffer buffer("Hello World\n");
	const TextDocumentContentChangeEvent change = {
	.range =
	{
	.start = {0, 6},
	.end = {0, 11},
	},
	.has_range = true,
	.text = "Planet",
	};
	EXPECT_TRUE(buffer.ApplyChange(change));
	buffer.RequestContent([&](absl::string_view s) {
	EXPECT_EQ("Hello Planet\n", std::string(s));
	});
	}

	TEST(TextBufferTest, ChangeApplySingleLineWihtUTF8Characters_Replace) {
	EditTextBuffer buffer("Heizölrückstoßabdämpfung\n");
	const TextDocumentContentChangeEvent change = {
	.range =
	{
	.start = {0, 6},
	.end = {0, 14},
	},
	.has_range = true,
	.text = "brandgefahr",
	};
	EXPECT_TRUE(buffer.ApplyChange(change));
	buffer.RequestContent([&](absl::string_view s) {
	EXPECT_EQ("Heizölbrandgefahrabdämpfung\n", std::string(s));
	});
	}

	TEST(TextBufferTest, ChangeApplySingleLine_ReplaceNotFirstLine) {
	// Make sure we properly access the right line.
	EditTextBuffer buffer("Hello World\nFoo\n");
	const TextDocumentContentChangeEvent change = {
	.range =
	{
	.start = {1, 0},
	.end = {1, 3},
	},
	.has_range = true,
	.text = "Bar",
	};
	EXPECT_TRUE(buffer.ApplyChange(change));
	buffer.RequestContent([&](absl::string_view s) {
	EXPECT_EQ("Hello World\nBar\n", std::string(s));
	});
	}

	TEST(TextBufferTest, ChangeApplySingleLine_Erase) {
	EditTextBuffer buffer("Hello World\n");
	const TextDocumentContentChangeEvent change = {
	.range =
	{
	.start = {0, 5},
	.end = {0, 11},
	},
	.has_range = true,
	.text = "",
	};
	EXPECT_TRUE(buffer.ApplyChange(change));
	EXPECT_EQ(buffer.document_length(), 6);
	buffer.RequestContent([&](absl::string_view s) { //
	EXPECT_EQ("Hello\n", std::string(s));
	});
	}

	TEST(TextBufferTest, ChangeApplySingleLine_ReplaceCorrectOverlongEnd) {
	const TextDocumentContentChangeEvent change = {
	.range =
	{
	.start = {0, 6}, .end = {0, 42}, // Too long end shall be trimmed
	},
	.has_range = true,
	.text = "Planet",
	};

	{
	EditTextBuffer buffer("Hello World\n");
	EXPECT_TRUE(buffer.ApplyChange(change));
	buffer.RequestContent([&](absl::string_view s) {
	EXPECT_EQ("Hello Planet\n", std::string(s));
	});
	}

	{
	EditTextBuffer buffer("Hello World");
	EXPECT_TRUE(buffer.ApplyChange(change));
	buffer.RequestContent([&](absl::string_view s) {
	EXPECT_EQ("Hello Planet", std::string(s));
	});
	}
	}

	TEST(TextBufferTest, ChangeApplyMultiLine_EraseBetweenLines) {
	EditTextBuffer buffer("Hello\nWorld\n");
	const TextDocumentContentChangeEvent change = {
	.range =
	{
	.start = {0, 2}, // From here to end of line
	.end = {1, 0},
	},
	.has_range = true,
	.text = "y ",
	};
	EXPECT_TRUE(buffer.ApplyChange(change));
	buffer.RequestContent([&](absl::string_view s) { //
	EXPECT_EQ("Hey World\n", std::string(s));
	});
	EXPECT_EQ(buffer.document_length(), 10);
	}

	TEST(TextBufferTest, ChangeApplyMultiLineWithUTF8Characters_Modify) {
	EditTextBuffer buffer("Heizölrück-\nstoßabdämpfung\n");
	const TextDocumentContentChangeEvent change = {
	.range =
	{
	.start = {0, 6}, // From here to end of line
	.end = {1, 4},
	},
	.has_range = true,
	.text = "brand-\ngefahr",
	};
	EXPECT_TRUE(buffer.ApplyChange(change));
	buffer.RequestContent([&](absl::string_view s) { //
	EXPECT_EQ("Heizölbrand-\ngefahrabdämpfung\n", std::string(s));
	});
	}

	TEST(TextBufferTest, ChangeApplyMultiLine_InsertMoreLines) {
	EditTextBuffer buffer("Hello\nbrave World\n");
	const TextDocumentContentChangeEvent change = {
	.range =
	{
	.start = {0, 2}, // From here to end of line
	.end = {1, 5},
	},
	.has_range = true,
	.text = "y!\nThis will be a new line\nand more in this",
	};
	EXPECT_EQ(buffer.lines(), 2);
	EXPECT_TRUE(buffer.ApplyChange(change));
	EXPECT_EQ(buffer.lines(), 3);
	static constexpr absl::string_view kExpected =
	"Hey!\nThis will be a new line\nand more in this World\n";
	buffer.RequestContent([&](absl::string_view s) { //
	EXPECT_EQ(kExpected, std::string(s));
	});
	EXPECT_EQ(buffer.document_length(), kExpected.length());
	}

	TEST(TextBufferTest, ChangeApplyMultiLine_InsertFromStart) {
	EditTextBuffer buffer("");
	const TextDocumentContentChangeEvent change = {
	.range =
	{
	.start = {0, 0},
	.end = {0, 0},
	},
	.has_range = true,
	.text = "This is now\na multiline\nfile\n",
	};
	EXPECT_EQ(buffer.lines(), 0);
	EXPECT_TRUE(buffer.ApplyChange(change));
	EXPECT_EQ(buffer.lines(), 3);
	buffer.RequestContent([&](absl::string_view s) {
	EXPECT_EQ("This is now\na multiline\nfile\n", std::string(s));
	});
	EXPECT_EQ(buffer.document_length(), change.text.length());
	}

	TEST(TextBufferTest, ChangeApplyMultiLine_RemoveLines) {
	EditTextBuffer buffer("Foo\nBar\nBaz\nQuux");
	const TextDocumentContentChangeEvent change = {
	.range =
	{
	.start = {1, 0},
	.end = {3, 0},
	},
	.has_range = true,
	.text = "",
	};
	EXPECT_EQ(buffer.lines(), 4);
	EXPECT_TRUE(buffer.ApplyChange(change));
	EXPECT_EQ(buffer.lines(), 2);
	buffer.RequestContent([&](absl::string_view s) { //
	EXPECT_EQ("Foo\nQuux", std::string(s));
	});
	EXPECT_EQ(buffer.document_length(), 8);
	}

	TEST(BufferCollection, SimulateDocumentLifecycleThroughRPC) {
	// Let's walk a BufferCollection through the lifecycle of a document
	// by sending it the JSON RPC notifications for open, change and close.
	//
	// Inspect at each step that the content and number of documents is what
	// we expect.

	// Notifications don't send any responses; write function not relevant.
	JsonRpcDispatcher rpc_dispatcher([](absl::string_view) {});
	BufferCollection collection(&rpc_dispatcher);

	EXPECT_EQ(collection.documents_open(), 0);

	int64_t last_global_version = 0;

	// Let's check that the callback is called on opening and contains
	// the right content.
	int change_callback_called = 0;
	collection.SetChangeListener(
	[&](const std::string &uri, const EditTextBuffer *buffer) {
	EXPECT_EQ(uri, "file:///foo.cc");
	buffer->RequestContent([](absl::string_view s) {
	EXPECT_EQ(std::string(s), "Hello\nworld");
	});
	change_callback_called++;
	});

	// ------ Opening new document
	// Simulate an incoming event from the client
	rpc_dispatcher.DispatchMessage(R"({
	"jsonrpc":"2.0",
	"method":"textDocument/didOpen",
	"params":{
	"textDocument":{
	"uri": "file:///foo.cc",
	"text": "Hello\nworld",
	"languageId": "cpp",
	"version": 1
	}
	}})");

	// We now expect one document to be open.
	EXPECT_EQ(collection.documents_open(), 1);
	EXPECT_EQ(change_callback_called, 1);

	EXPECT_GT(collection.global_version(), last_global_version);

	// Prepare for the next expected change
	collection.SetChangeListener(
	[&](const std::string &uri, const EditTextBuffer *buffer) {
	EXPECT_EQ(uri, "file:///foo.cc");
	buffer->RequestContent(
	[](absl::string_view s) { EXPECT_EQ(std::string(s), "Hey"); });
	change_callback_called++;
	});

	// ------ Editing document: receive content changes
	rpc_dispatcher.DispatchMessage(R"({
	"jsonrpc":"2.0",
	"method":"textDocument/didChange",
	"params":{
	"textDocument": { "uri": "file:///foo.cc" },
	"contentChanges": [ {"text":"Hey"} ]
	}})");

	EXPECT_EQ(change_callback_called, 2);

	// Upcoming change will send us a nullptr buffer as it is removed.
	collection.SetChangeListener(
	[&](const std::string &uri, const EditTextBuffer *buffer) {
	EXPECT_EQ(buffer, nullptr);
	change_callback_called++;
	});

	// ------ Closing document
	rpc_dispatcher.DispatchMessage(R"({
	"jsonrpc":"2.0",
	"method":"textDocument/didClose",
	"params":{
	"textDocument":{ "uri": "file:///foo.cc" }
	}})");

	// No document open anymore
	EXPECT_EQ(collection.documents_open(), 0);
	EXPECT_EQ(change_callback_called, 3);
	}

	} // namespace lsp
	} // namespace verible