#include "LibLsp/JsonRpc/Endpoint.h" #include "LibLsp/JsonRpc/RemoteEndPoint.h" #include "LibLsp/lsp/ProtocolJsonHandler.h" #include "LibLsp/lsp/textDocument/did_change.h" #include "LibLsp/lsp/textDocument/did_close.h" #include "LibLsp/lsp/textDocument/did_open.h" #include "LibLsp/lsp/working_files.h" #include "test_helpers.h" #include #include #include #include #include #include #include #include namespace { using test::DummyLog; using test::Expect; using test::FeedableIStream; using test::StringOStream; AbsolutePath MakePath(std::string const& name) { return AbsolutePath("/tmp/lspcpp-text-document-sync-suite/" + name); } std::shared_ptr OpenFile(WorkingFiles& files, AbsolutePath const& path, std::string text, int version = 1) { lsTextDocumentItem open; open.uri = lsDocumentUri(path); open.languageId = "cpp"; open.version = version; open.text = std::move(text); return files.OnOpen(open); } std::string ContentOf(WorkingFiles& files, std::shared_ptr& file) { std::string content; Expect(files.GetFileBufferContent(file, content), "expected file content to be available"); return content; } std::vector LineStarts(std::string const& text) { std::vector starts; starts.push_back(0); for (size_t i = 0; i < text.size(); ++i) { if (text[i] == '\n') { starts.push_back(i + 1); } } return starts; } lsPosition PositionAt(std::string const& text, size_t offset) { offset = std::min(offset, text.size()); unsigned line = 0; size_t line_start = 0; for (size_t i = 0; i < offset; ++i) { if (text[i] == '\n') { ++line; line_start = i + 1; } } return lsPosition(static_cast(line), static_cast(offset - line_start)); } size_t LineLength(std::string const& text, std::vector const& starts, size_t line) { size_t const start = starts[line]; size_t const next = (line + 1 < starts.size()) ? starts[line + 1] : text.size(); size_t end = next; if (end > start && text[end - 1] == '\n') { --end; } return end - start; } void AssertValidLineOffsets(WorkingFile& file, std::string const& expected) { auto const starts = LineStarts(expected); Expect(file.LineOffsetCountForTest() == starts.size(), "line offset count must match document line count"); for (size_t line = 0; line < starts.size(); ++line) { Expect( file.GetOffsetForPosition(lsPosition(static_cast(line), 0)) == static_cast(starts[line]), "line start offset mismatch"); size_t const length = LineLength(expected, starts, line); Expect( file.GetOffsetForPosition(lsPosition(static_cast(line), static_cast(length))) == static_cast(starts[line] + length), "line end offset mismatch"); } Expect( file.GetOffsetForPosition(lsPosition(static_cast(starts.size() + 10), 0)) == static_cast(expected.size()), "out-of-range line must clamp to document end"); } void AssertDocument(WorkingFiles& files, std::shared_ptr& file, std::string const& expected, int version) { Expect(ContentOf(files, file) == expected, "document content mismatch after didChange"); Expect(file->version == version, "document version mismatch after didChange"); AssertValidLineOffsets(*file, expected); } lsTextDocumentContentChangeEvent FullEdit(std::string text) { lsTextDocumentContentChangeEvent edit; edit.text = std::move(text); return edit; } lsTextDocumentContentChangeEvent RangedEdit(lsPosition start, lsPosition end, std::string text) { lsTextDocumentContentChangeEvent edit; edit.range = lsRange(start, end); edit.text = std::move(text); return edit; } lsTextDocumentContentChangeEvent ReplaceFirst(std::string& model, std::string const& old_text, std::string replacement) { size_t const start = model.find(old_text); Expect(start != std::string::npos, "test fixture target text must exist"); size_t const end = start + old_text.size(); auto edit = RangedEdit(PositionAt(model, start), PositionAt(model, end), replacement); model.replace(start, old_text.size(), replacement); return edit; } lsTextDocumentContentChangeEvent InsertAfter(std::string& model, std::string const& marker, std::string insertion) { size_t const start = model.find(marker); Expect(start != std::string::npos, "test fixture marker text must exist"); size_t const offset = start + marker.size(); auto edit = RangedEdit(PositionAt(model, offset), PositionAt(model, offset), insertion); model.insert(offset, insertion); return edit; } lsTextDocumentContentChangeEvent InsertAtOffset(std::string& model, size_t offset, std::string insertion) { offset = std::min(offset, model.size()); auto edit = RangedEdit(PositionAt(model, offset), PositionAt(model, offset), insertion); model.insert(offset, insertion); return edit; } lsTextDocumentContentChangeEvent DeleteRange(std::string& model, size_t start, size_t end) { start = std::min(start, model.size()); end = std::min(end, model.size()); auto edit = RangedEdit(PositionAt(model, start), PositionAt(model, end), ""); model.erase(start, end - start); return edit; } std::shared_ptr ApplyChanges( WorkingFiles& files, AbsolutePath const& path, int version, std::vector changes) { lsTextDocumentDidChangeParams change; change.textDocument.uri = lsDocumentUri(path); change.textDocument.version = optional(version); change.contentChanges = std::move(changes); return files.OnChange(change); } void TestFullContentUpdates() { WorkingFiles files; AbsolutePath const path = MakePath("full-updates.cpp"); auto file = OpenFile(files, path, "abc123", 0); auto changed = ApplyChanges(files, path, 1, {FullEdit("efg456")}); Expect(changed == file, "full update must return the tracked file"); AssertDocument(files, file, "efg456", 1); ApplyChanges(files, path, 2, {FullEdit("hello")}); ApplyChanges(files, path, 3, {FullEdit("world")}); AssertDocument(files, file, "world", 3); } void TestIncrementalRemovals() { WorkingFiles files; AbsolutePath const path = MakePath("incremental-removals.cpp"); std::string model = "function abc() {\n console.log(\"hello, world!\");\n}\n"; auto file = OpenFile(files, path, model, 1); ApplyChanges(files, path, 2, {ReplaceFirst(model, ", world!", "")}); AssertDocument(files, file, model, 2); ApplyChanges(files, path, 3, {ReplaceFirst(model, " console.log(\"hello\");\n", "")}); AssertDocument(files, file, model, 3); } void TestIncrementalMultiLineRemovals() { WorkingFiles files; AbsolutePath const path = MakePath("multi-line-removals.cpp"); std::string model = "function abc() {\n foo();\n bar();\n baz();\n}\n"; auto file = OpenFile(files, path, model, 1); ApplyChanges(files, path, 2, {ReplaceFirst(model, " foo();\n bar();\n", "")}); AssertDocument(files, file, model, 2); ApplyChanges(files, path, 3, {ReplaceFirst(model, " baz();\n}", "}")}); AssertDocument(files, file, model, 3); } void TestIncrementalAdditions() { WorkingFiles files; AbsolutePath const path = MakePath("incremental-additions.cpp"); std::string model = "function abc() {\n console.log(\"hello\");\n}\n"; auto file = OpenFile(files, path, model, 1); ApplyChanges(files, path, 2, {InsertAfter(model, "hello", ", world!")}); AssertDocument(files, file, model, 2); ApplyChanges(files, path, 3, {InsertAfter(model, "console.log(\"hello, world!\");", "\n bar();")}); AssertDocument(files, file, model, 3); } void TestSingleLineReplacements() { WorkingFiles files; AbsolutePath const path = MakePath("single-line-replacements.cpp"); std::string model = "function abc() {\n console.log(\"hello, world!\");\n}\n"; auto file = OpenFile(files, path, model, 1); ApplyChanges(files, path, 2, {ReplaceFirst(model, "hello, world!", "hello, test case!!!")}); AssertDocument(files, file, model, 2); ApplyChanges(files, path, 3, {ReplaceFirst(model, "hello, test case!!!", "short")}); AssertDocument(files, file, model, 3); ApplyChanges(files, path, 4, {ReplaceFirst(model, "short", "equal")}); AssertDocument(files, file, model, 4); } void TestMultiLineReplacements() { WorkingFiles files; AbsolutePath const path = MakePath("multi-line-replacements.cpp"); std::string model = "a1\nb1\nc1\na2\nb2\nc2\n"; auto file = OpenFile(files, path, model, 1); ApplyChanges(files, path, 2, {ReplaceFirst(model, "b1\nc1", "b1\nx1\ny1\nc1")}); AssertDocument(files, file, model, 2); ApplyChanges(files, path, 3, {ReplaceFirst(model, "b1\nx1\ny1\nc1", "b1")}); AssertDocument(files, file, model, 3); ApplyChanges(files, path, 4, {ReplaceFirst(model, "a2\nb2\nc2", "d2\ne2\nf2")}); AssertDocument(files, file, model, 4); } void TestHugeMultiLineInsertion() { WorkingFiles files; AbsolutePath const path = MakePath("huge-insertion.cpp"); std::string model = "prefix\nsuffix\n"; auto file = OpenFile(files, path, model, 1); std::string insertion; for (int i = 0; i < 19999; ++i) { insertion += "line "; insertion += std::to_string(i); insertion += "\n"; } ApplyChanges(files, path, 2, {InsertAfter(model, "prefix\n", insertion)}); AssertDocument(files, file, model, 2); } void TestSeveralIncrementalChangesInOneNotification() { WorkingFiles files; AbsolutePath const path = MakePath("several-changes.cpp"); std::string model = "function abc() {\n console.log(\"hello\");\n}\n"; auto file = OpenFile(files, path, model, 1); std::vector changes; changes.push_back(InsertAfter(model, "abc", "defg")); changes.push_back(ReplaceFirst(model, "\"hello\"", "\"hello, world!\"")); changes.push_back(InsertAfter(model, "abcdefg", "hij")); ApplyChanges(files, path, 2, std::move(changes)); AssertDocument(files, file, model, 2); } void TestAppendDeleteAndCharacterReplace() { WorkingFiles files; AbsolutePath const path = MakePath("append-delete-replace.cpp"); std::string model = "0123456789\nabcdefghij\n"; auto file = OpenFile(files, path, model, 1); ApplyChanges(files, path, 2, {InsertAtOffset(model, 10, "A")}); AssertDocument(files, file, model, 2); ApplyChanges(files, path, 3, {InsertAtOffset(model, model.size(), "tail\nmore")}); AssertDocument(files, file, model, 3); ApplyChanges(files, path, 4, {DeleteRange(model, 1, 4)}); AssertDocument(files, file, model, 4); size_t const multi_start = model.find("abcd"); ApplyChanges(files, path, 5, {DeleteRange(model, multi_start, multi_start + 7)}); AssertDocument(files, file, model, 5); ApplyChanges(files, path, 6, {ReplaceFirst(model, "0", "X")}); AssertDocument(files, file, model, 6); ApplyChanges(files, path, 7, {ReplaceFirst(model, "tail", "TAIL-UPDATED")}); AssertDocument(files, file, model, 7); } void TestEditStyleInsertReplaceAndMultiline() { WorkingFiles files; AbsolutePath const path = MakePath("edits-style.cpp"); std::string model = "012345678901234567890123456789"; auto file = OpenFile(files, path, model, 1); ApplyChanges(files, path, 2, {InsertAtOffset(model, 0, "a"), InsertAtOffset(model, 2, "b")}); AssertDocument(files, file, model, 2); ApplyChanges(files, path, 3, {ReplaceFirst(model, "345", "XYZ")}); AssertDocument(files, file, model, 3); ApplyChanges(files, path, 4, {ReplaceFirst(model, "XYZ67", "one\ntwo\nthree")}); AssertDocument(files, file, model, 4); } void TestInvalidRangesClamp() { WorkingFiles files; AbsolutePath const path = MakePath("invalid-ranges.cpp"); std::string model = "abc\ndef\n"; auto file = OpenFile(files, path, model, 1); ApplyChanges(files, path, 2, {RangedEdit(lsPosition(-1, -1), lsPosition(0, 1), "A")}); model.replace(0, 1, "A"); AssertDocument(files, file, model, 2); ApplyChanges(files, path, 3, {RangedEdit(lsPosition(-10, 0), lsPosition(1, 1), "prefix")}); model.replace(0, std::string("Abc\nd").size(), "prefix"); AssertDocument(files, file, model, 3); size_t const from_middle = model.find("ef"); ApplyChanges(files, path, 4, {RangedEdit(PositionAt(model, from_middle), lsPosition(99, 99), "")}); model.erase(from_middle); AssertDocument(files, file, model, 4); ApplyChanges(files, path, 5, {RangedEdit(lsPosition(99, 99), lsPosition(99, 99), "\nend")}); model += "\nend"; AssertDocument(files, file, model, 5); ApplyChanges(files, path, 6, {RangedEdit(lsPosition(-1, 0), lsPosition(99, 99), "whole")}); model = "whole"; AssertDocument(files, file, model, 6); } bool WaitUntil(std::function const& predicate) { for (int i = 0; i < 100; ++i) { if (predicate()) { return true; } std::this_thread::sleep_for(std::chrono::milliseconds(10)); } return predicate(); } std::string JsonEscape(std::string const& value) { std::string out; for (char c : value) { switch (c) { case '"': out += "\\\""; break; case '\\': out += "\\\\"; break; case '\n': out += "\\n"; break; case '\r': out += "\\r"; break; case '\t': out += "\\t"; break; default: out.push_back(c); } } return out; } // Runs didOpen/didChange LSP frames through a RemoteEndPoint into WorkingFiles, // mirroring vscode-languageserver-node server TextDocuments manager tests. struct EndpointDocumentHarness { DummyLog log; WorkingFiles files; std::shared_ptr input_stream = std::make_shared(); std::shared_ptr output_stream = std::make_shared(); std::unique_ptr point; std::atomic handled_notifications {0}; EndpointDocumentHarness() { auto json_handler = std::make_shared(); auto endpoint = std::make_shared(log); // Exercise document-sync ordering under multiple workers: didOpen and // incremental didChange notifications must still be applied in wire order. point.reset(new RemoteEndPoint(json_handler, endpoint, log, lsp::JSONStreamStyle::Standard, 4)); point->registerHandler( [this](Notify_TextDocumentDidOpen::notify const& notification) { auto params = notification.params; files.OnOpen(params.textDocument); handled_notifications.fetch_add(1, std::memory_order_relaxed); }); point->registerHandler( [this](Notify_TextDocumentDidChange::notify const& notification) { files.OnChange(notification.params); handled_notifications.fetch_add(1, std::memory_order_relaxed); }); point->startProcessingMessages(input_stream, output_stream); } ~EndpointDocumentHarness() { point->stop(); } void Open(std::string const& uri, std::string const& text, int version) { input_stream->append(test::MakeLspFrame( R"({"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":")" + uri + R"(","languageId":"javascript","version":)" + std::to_string(version) + R"(,"text":")" + JsonEscape(text) + R"("}}})")); } void Change(std::string const& uri, int version, std::string const& content_changes_json) { input_stream->append(test::MakeLspFrame( R"({"jsonrpc":"2.0","method":"textDocument/didChange","params":{"textDocument":{"uri":")" + uri + R"(","version":)" + std::to_string(version) + R"(},"contentChanges":)" + content_changes_json + "}}")); } bool WaitForNotifications(int expected) { return WaitUntil( [this, expected]() { return handled_notifications.load(std::memory_order_relaxed) >= expected; }); } }; void ExpectEndpointDocument(EndpointDocumentHarness& harness, AbsolutePath const& path, std::string const& expected, int version) { auto file = harness.files.GetFileByFilename(path); Expect(file != nullptr, "endpoint-managed document must exist after didOpen"); if (file) { AssertDocument(harness.files, file, expected, version); } } void TestSeveralFullContentUpdatesThroughEndpoint() { EndpointDocumentHarness harness; AbsolutePath const path = MakePath("endpoint-full-updates.js"); std::string const uri = lsDocumentUri(path).raw_uri_; harness.Open(uri, "abc123", 1); harness.Change(uri, 2, R"([{"text":"hello"},{"text":"world"}])"); Expect(harness.WaitForNotifications(2), "full-update didChange frame must reach WorkingFiles"); ExpectEndpointDocument(harness, path, "world", 2); } void TestIncrementalRemovalThroughEndpoint() { EndpointDocumentHarness harness; AbsolutePath const path = MakePath("endpoint-incremental-remove.js"); std::string const uri = lsDocumentUri(path).raw_uri_; harness.Open(uri, "function abc() {\n console.log(\"hello, world!\");\n}", 1); harness.Change( uri, 2, R"([{"text":"","range":{"start":{"line":1,"character":20},"end":{"line":1,"character":28}}}])"); Expect(harness.WaitForNotifications(2), "incremental removal frame must reach WorkingFiles"); ExpectEndpointDocument(harness, path, "function abc() {\n console.log(\"hello\");\n}", 2); } void TestIncrementalAdditionThroughEndpoint() { EndpointDocumentHarness harness; AbsolutePath const path = MakePath("endpoint-incremental-add.js"); std::string const uri = lsDocumentUri(path).raw_uri_; harness.Open(uri, "function abc() {\n console.log(\"hello\");\n}", 1); harness.Change( uri, 2, R"([{"text":", world!","range":{"start":{"line":1,"character":20},"end":{"line":1,"character":20}}}])"); Expect(harness.WaitForNotifications(2), "incremental addition frame must reach WorkingFiles"); ExpectEndpointDocument(harness, path, "function abc() {\n console.log(\"hello, world!\");\n}", 2); } void TestIncrementalReplacementThroughEndpoint() { EndpointDocumentHarness harness; AbsolutePath const path = MakePath("endpoint-incremental-replace.js"); std::string const uri = lsDocumentUri(path).raw_uri_; harness.Open(uri, "function abc() {\n console.log(\"hello, world!\");\n}", 1); harness.Change( uri, 2, R"([{"text":"hello, test case!!!","range":{"start":{"line":1,"character":15},"end":{"line":1,"character":28}}}])"); Expect(harness.WaitForNotifications(2), "incremental replacement frame must reach WorkingFiles"); ExpectEndpointDocument(harness, path, "function abc() {\n console.log(\"hello, test case!!!\");\n}", 2); } void TestSeveralIncrementalChangesThroughEndpoint() { EndpointDocumentHarness harness; AbsolutePath const path = MakePath("endpoint-incremental-several.js"); std::string const uri = lsDocumentUri(path).raw_uri_; harness.Open(uri, "function abc() {\n console.log(\"hello, world!\");\n}", 1); // Positions of later edits are relative to the document state after // earlier edits within the same didChange, matching vscode semantics. harness.Change( uri, 2, R"([{"text":"defg","range":{"start":{"line":0,"character":12},"end":{"line":0,"character":12}}},)" R"({"text":"hello, test case!!!","range":{"start":{"line":1,"character":15},"end":{"line":1,"character":28}}},)" R"({"text":"hij","range":{"start":{"line":0,"character":16},"end":{"line":0,"character":16}}}])"); Expect(harness.WaitForNotifications(2), "multi-edit didChange frame must reach WorkingFiles"); ExpectEndpointDocument( harness, path, "function abcdefghij() {\n console.log(\"hello, test case!!!\");\n}", 2); } void TestDidOpenChangeCloseThroughEndpoint() { DummyLog log; WorkingFiles files; AbsolutePath const path = MakePath("endpoint.cpp"); auto json_handler = std::make_shared(); auto endpoint = std::make_shared(log); auto input_stream = std::make_shared(); auto output_stream = std::make_shared(); std::atomic opened {false}; std::atomic changed {false}; std::atomic closed {false}; RemoteEndPoint point(json_handler, endpoint, log); point.registerHandler( [&](Notify_TextDocumentDidOpen::notify const& notification) { auto params = notification.params; opened.store(files.OnOpen(params.textDocument) != nullptr, std::memory_order_relaxed); }); point.registerHandler( [&](Notify_TextDocumentDidChange::notify const& notification) { changed.store(files.OnChange(notification.params) != nullptr, std::memory_order_relaxed); }); point.registerHandler( [&](Notify_TextDocumentDidClose::notify const& notification) { closed.store(files.OnClose(notification.params.textDocument), std::memory_order_relaxed); }); point.startProcessingMessages(input_stream, output_stream); std::string const uri = lsDocumentUri(path).raw_uri_; input_stream->append(test::MakeLspFrame( R"({"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":")" + uri + R"(","languageId":"cpp","version":1,"text":"abc123"}}})")); Expect(WaitUntil([&]() { return opened.load(std::memory_order_relaxed); }), "didOpen must reach WorkingFiles"); input_stream->append(test::MakeLspFrame( R"({"jsonrpc":"2.0","method":"textDocument/didChange","params":{"textDocument":{"uri":")" + uri + R"(","version":2},"contentChanges":[{"text":"efg456"}]}})")); Expect(WaitUntil([&]() { return changed.load(std::memory_order_relaxed); }), "didChange must reach WorkingFiles"); auto file = files.GetFileByFilename(path); Expect(file != nullptr, "didOpen must make the endpoint document available by path"); if (file) { AssertDocument(files, file, "efg456", 2); } input_stream->append(test::MakeLspFrame( R"({"jsonrpc":"2.0","method":"textDocument/didClose","params":{"textDocument":{"uri":")" + uri + R"("}}})")); Expect(WaitUntil([&]() { return closed.load(std::memory_order_relaxed); }), "didClose must reach WorkingFiles"); point.stop(); std::string content; Expect(!files.GetFileBufferContent(path, content), "didClose must remove the endpoint document"); } // Adapted from clangd/test/version.test void TestDidChangeVersionPropagationThroughEndpoint() { DummyLog log; WorkingFiles files; auto json_handler = std::make_shared(); auto endpoint = std::make_shared(log); auto input_stream = std::make_shared(); auto output_stream = std::make_shared(); AbsolutePath const path = MakePath("version-endpoint.c"); std::atomic opened {false}; RemoteEndPoint point(json_handler, endpoint, log); point.registerHandler( [&](Notify_TextDocumentDidOpen::notify const& notification) { auto params = notification.params; opened.store(files.OnOpen(params.textDocument) != nullptr, std::memory_order_relaxed); }); point.registerHandler( [&](Notify_TextDocumentDidChange::notify const& notification) { files.OnChange(notification.params); }); point.startProcessingMessages(input_stream, output_stream); std::string const uri = lsDocumentUri(path).raw_uri_; input_stream->append(test::MakeLspFrame( R"({"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":")" + uri + R"(","languageId":"c","version":0,"text":""}}})")); Expect(WaitUntil([&]() { return opened.load(std::memory_order_relaxed); }), "version scenario didOpen must dispatch"); input_stream->append(test::MakeLspFrame( R"({"jsonrpc":"2.0","method":"textDocument/didChange","params":{"textDocument":{"uri":")" + uri + R"(","version":5},"contentChanges":[{"text":"a"}]}})")); Expect( WaitUntil( [&]() { auto current = files.GetFileByFilename(path); if (current == nullptr) { return false; } std::string content; return files.GetFileBufferContent(current, content) && content == "a" && current->version == 5; }), "version scenario didChange must apply explicit version and content"); auto file = files.GetFileByFilename(path); Expect(file != nullptr, "version scenario file must exist after didChange"); if (file) { AssertDocument(files, file, "a", 5); } input_stream->append(test::MakeLspFrame( R"({"jsonrpc":"2.0","method":"textDocument/didChange","params":{"textDocument":{"uri":")" + uri + R"("},"contentChanges":[{"text":"b"}]}})")); Expect( WaitUntil( [&]() { auto current = files.GetFileByFilename(path); if (current == nullptr) { return false; } std::string content; return files.GetFileBufferContent(current, content) && content == "b" && current->version == 5; }), "version scenario didChange without version must preserve previous version"); if (file) { AssertDocument(files, file, "b", 5); } point.stop(); } } // namespace int main(int argc, char** argv) { test::InitTestFilter(argc, argv); RUN_TEST(TestFullContentUpdates); RUN_TEST(TestIncrementalRemovals); RUN_TEST(TestIncrementalMultiLineRemovals); RUN_TEST(TestIncrementalAdditions); RUN_TEST(TestSingleLineReplacements); RUN_TEST(TestMultiLineReplacements); RUN_TEST(TestHugeMultiLineInsertion); RUN_TEST(TestSeveralIncrementalChangesInOneNotification); RUN_TEST(TestAppendDeleteAndCharacterReplace); RUN_TEST(TestEditStyleInsertReplaceAndMultiline); RUN_TEST(TestInvalidRangesClamp); RUN_TEST(TestDidOpenChangeCloseThroughEndpoint); RUN_TEST(TestSeveralFullContentUpdatesThroughEndpoint); RUN_TEST(TestIncrementalRemovalThroughEndpoint); RUN_TEST(TestIncrementalAdditionThroughEndpoint); RUN_TEST(TestIncrementalReplacementThroughEndpoint); RUN_TEST(TestSeveralIncrementalChangesThroughEndpoint); RUN_TEST(TestDidChangeVersionPropagationThroughEndpoint); return test::Failures() == 0 ? 0 : 1; } .