| 1 |
//===--- MarshallingTests.cpp ------------------------------------*- C++-*-===// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
|
| 9 |
#include "../TestTU.h" |
| 10 |
#include "Index.pb.h" |
| 11 |
#include "TestFS.h" |
| 12 |
#include "index/Index.h" |
| 13 |
#include "index/Ref.h" |
| 14 |
#include "index/Relation.h" |
| 15 |
#include "index/Serialization.h" |
| 16 |
#include "index/Symbol.h" |
| 17 |
#include "index/SymbolID.h" |
| 18 |
#include "index/SymbolLocation.h" |
| 19 |
#include "index/SymbolOrigin.h" |
| 20 |
#include "index/remote/marshalling/Marshalling.h" |
| 21 |
#include "clang/Index/IndexSymbol.h" |
| 22 |
#include "llvm/ADT/SmallString.h" |
| 23 |
#include "llvm/ADT/StringRef.h" |
| 24 |
#include "llvm/ADT/Twine.h" |
| 25 |
#include "llvm/Support/Error.h" |
| 26 |
#include "llvm/Support/Path.h" |
| 27 |
#include "llvm/Support/StringSaver.h" |
| 28 |
#include "gmock/gmock.h" |
| 29 |
#include "gtest/gtest.h" |
| 30 |
#include <cstring> |
| 31 |
|
| 32 |
namespace clang { |
| 33 |
namespace clangd { |
| 34 |
namespace remote { |
| 35 |
namespace { |
| 36 |
|
| 37 |
using llvm::sys::path::convert_to_slash; |
| 38 |
|
| 39 |
const char *testPathURI(llvm::StringRef Path, |
| 40 |
llvm::UniqueStringSaver &Strings) { |
| 41 |
auto URI = URI::createFile(testPath(Path)); |
| 42 |
return Strings.save(URI.toString()).begin(); |
| 43 |
} |
| 44 |
|
| 45 |
clangd::Symbol createSymbol(llvm::StringRef PathPrefix, |
| 46 |
llvm::UniqueStringSaver &Strings) { |
| 47 |
clangd::Symbol Sym; |
| 48 |
Sym.ID = llvm::cantFail(SymbolID::fromStr("057557CEBF6E6B2D")); |
| 49 |
|
| 50 |
index::SymbolInfo Info; |
| 51 |
Info.Kind = index::SymbolKind::Function; |
| 52 |
Info.SubKind = index::SymbolSubKind::AccessorGetter; |
| 53 |
Info.Lang = index::SymbolLanguage::CXX; |
| 54 |
Info.Properties = static_cast<index::SymbolPropertySet>( |
| 55 |
index::SymbolProperty::TemplateSpecialization); |
| 56 |
Sym.SymInfo = Info; |
| 57 |
|
| 58 |
Sym.Name = Strings.save("Foo"); |
| 59 |
Sym.Scope = Strings.save("llvm::foo::bar::"); |
| 60 |
|
| 61 |
clangd::SymbolLocation Location; |
| 62 |
Location.Start.setLine(1); |
| 63 |
Location.Start.setColumn(15); |
| 64 |
Location.End.setLine(3); |
| 65 |
Location.End.setColumn(121); |
| 66 |
Location.FileURI = testPathURI(PathPrefix.str() + "Definition.cpp", Strings); |
| 67 |
Sym.Definition = Location; |
| 68 |
|
| 69 |
Location.Start.setLine(42); |
| 70 |
Location.Start.setColumn(31); |
| 71 |
Location.End.setLine(20); |
| 72 |
Location.End.setColumn(400); |
| 73 |
Location.FileURI = testPathURI(PathPrefix.str() + "Declaration.h", Strings); |
| 74 |
Sym.CanonicalDeclaration = Location; |
| 75 |
|
| 76 |
Sym.References = 9000; |
| 77 |
Sym.Origin = clangd::SymbolOrigin::Static; |
| 78 |
Sym.Signature = Strings.save("(int X, char Y, Type T)"); |
| 79 |
Sym.TemplateSpecializationArgs = Strings.save("<int, char, bool, Type>"); |
| 80 |
Sym.CompletionSnippetSuffix = |
| 81 |
Strings.save("({1: int X}, {2: char Y}, {3: Type T})"); |
| 82 |
Sym.Documentation = Strings.save("This is my amazing Foo constructor!"); |
| 83 |
Sym.ReturnType = Strings.save("Foo"); |
| 84 |
|
| 85 |
Sym.Flags = clangd::Symbol::SymbolFlag::IndexedForCodeCompletion; |
| 86 |
|
| 87 |
return Sym; |
| 88 |
} |
| 89 |
|
| 90 |
TEST(RemoteMarshallingTest, URITranslation) { |
| 91 |
llvm::BumpPtrAllocator Arena; |
| 92 |
llvm::UniqueStringSaver Strings(Arena); |
| 93 |
Marshaller ProtobufMarshaller( |
| 94 |
testPath("remote/machine/projects/llvm-project/"), |
| 95 |
testPath("home/my-projects/llvm-project/")); |
| 96 |
clangd::Ref Original; |
| 97 |
Original.Location.FileURI = |
| 98 |
testPathURI("remote/machine/projects/llvm-project/clang-tools-extra/" |
| 99 |
"clangd/unittests/remote/MarshallingTests.cpp", |
| 100 |
Strings); |
| 101 |
auto Serialized = ProtobufMarshaller.toProtobuf(Original); |
| 102 |
ASSERT_TRUE(bool(Serialized)); |
| 103 |
EXPECT_EQ(Serialized->location().file_path(), |
| 104 |
"clang-tools-extra/clangd/unittests/remote/MarshallingTests.cpp"); |
| 105 |
auto Deserialized = ProtobufMarshaller.fromProtobuf(*Serialized); |
| 106 |
ASSERT_TRUE(bool(Deserialized)); |
| 107 |
EXPECT_STREQ(Deserialized->Location.FileURI, |
| 108 |
testPathURI("home/my-projects/llvm-project/clang-tools-extra/" |
| 109 |
"clangd/unittests/remote/MarshallingTests.cpp", |
| 110 |
Strings)); |
| 111 |
|
| 112 |
// Can't have empty paths. |
| 113 |
*Serialized->mutable_location()->mutable_file_path() = std::string(); |
| 114 |
Deserialized = ProtobufMarshaller.fromProtobuf(*Serialized); |
| 115 |
EXPECT_FALSE(bool(Deserialized)); |
| 116 |
llvm::consumeError(Deserialized.takeError()); |
| 117 |
|
| 118 |
clangd::Ref WithInvalidURI; |
| 119 |
// Invalid URI results in serialization failure. |
| 120 |
WithInvalidURI.Location.FileURI = "This is not a URI"; |
| 121 |
auto DeserializedRef = ProtobufMarshaller.toProtobuf(WithInvalidURI); |
| 122 |
EXPECT_FALSE(bool(DeserializedRef)); |
| 123 |
llvm::consumeError(DeserializedRef.takeError()); |
| 124 |
|
| 125 |
// Can not use URIs with scheme different from "file". |
| 126 |
auto UnittestURI = |
| 127 |
URI::create(testPath("project/lib/HelloWorld.cpp"), "unittest"); |
| 128 |
ASSERT_TRUE(bool(UnittestURI)); |
| 129 |
WithInvalidURI.Location.FileURI = |
| 130 |
Strings.save(UnittestURI->toString()).begin(); |
| 131 |
auto DeserializedSymbol = ProtobufMarshaller.toProtobuf(WithInvalidURI); |
| 132 |
EXPECT_FALSE(bool(DeserializedSymbol)); |
| 133 |
llvm::consumeError(DeserializedSymbol.takeError()); |
| 134 |
|
| 135 |
// Paths transmitted over the wire can not be absolute, they have to be |
| 136 |
// relative. |
| 137 |
Ref WithAbsolutePath; |
| 138 |
*WithAbsolutePath.mutable_location()->mutable_file_path() = |
| 139 |
"/usr/local/user/home/HelloWorld.cpp"; |
| 140 |
Deserialized = ProtobufMarshaller.fromProtobuf(WithAbsolutePath); |
| 141 |
EXPECT_FALSE(bool(Deserialized)); |
| 142 |
llvm::consumeError(Deserialized.takeError()); |
| 143 |
} |
| 144 |
|
| 145 |
TEST(RemoteMarshallingTest, SymbolSerialization) { |
| 146 |
llvm::BumpPtrAllocator Arena; |
| 147 |
llvm::UniqueStringSaver Strings(Arena); |
| 148 |
|
| 149 |
clangd::Symbol Sym = createSymbol("home/", Strings); |
| 150 |
Marshaller ProtobufMarshaller(testPath("home/"), testPath("home/")); |
| 151 |
|
| 152 |
// Check that symbols are exactly the same if the path to indexed project is |
| 153 |
// the same on indexing machine and the client. |
| 154 |
auto Serialized = ProtobufMarshaller.toProtobuf(Sym); |
| 155 |
ASSERT_TRUE(bool(Serialized)); |
| 156 |
auto Deserialized = ProtobufMarshaller.fromProtobuf(*Serialized); |
| 157 |
ASSERT_TRUE(bool(Deserialized)); |
| 158 |
// Origin is overwritten when deserializing. |
| 159 |
Sym.Origin = SymbolOrigin::Remote; |
| 160 |
EXPECT_EQ(toYAML(Sym), toYAML(*Deserialized)); |
| 161 |
// Serialized paths are relative and have UNIX slashes. |
| 162 |
EXPECT_EQ(convert_to_slash(Serialized->definition().file_path(), |
| 163 |
llvm::sys::path::Style::posix), |
| 164 |
Serialized->definition().file_path()); |
| 165 |
EXPECT_TRUE( |
| 166 |
llvm::sys::path::is_relative(Serialized->definition().file_path())); |
| 167 |
|
| 168 |
// Missing definition is OK. |
| 169 |
Sym.Definition = clangd::SymbolLocation(); |
| 170 |
Serialized = ProtobufMarshaller.toProtobuf(Sym); |
| 171 |
ASSERT_TRUE(bool(Serialized)); |
| 172 |
ASSERT_TRUE(bool(ProtobufMarshaller.fromProtobuf(*Serialized))); |
| 173 |
|
| 174 |
// Relative path is absolute. |
| 175 |
*Serialized->mutable_canonical_declaration()->mutable_file_path() = |
| 176 |
convert_to_slash("/path/to/Declaration.h"); |
| 177 |
Deserialized = ProtobufMarshaller.fromProtobuf(*Serialized); |
| 178 |
EXPECT_FALSE(bool(Deserialized)); |
| 179 |
llvm::consumeError(Deserialized.takeError()); |
| 180 |
|
| 181 |
// Fail with an invalid URI. |
| 182 |
Sym.Definition.FileURI = "Not A URI"; |
| 183 |
Serialized = ProtobufMarshaller.toProtobuf(Sym); |
| 184 |
EXPECT_FALSE(bool(Serialized)); |
| 185 |
llvm::consumeError(Serialized.takeError()); |
| 186 |
|
| 187 |
// Schemes other than "file" can not be used. |
| 188 |
auto UnittestURI = URI::create(testPath("home/SomePath.h"), "unittest"); |
| 189 |
ASSERT_TRUE(bool(UnittestURI)); |
| 190 |
Sym.Definition.FileURI = Strings.save(UnittestURI->toString()).begin(); |
| 191 |
Serialized = ProtobufMarshaller.toProtobuf(Sym); |
| 192 |
EXPECT_FALSE(bool(Serialized)); |
| 193 |
llvm::consumeError(Serialized.takeError()); |
| 194 |
|
| 195 |
// Passing root that is not prefix of the original file path. |
| 196 |
Sym.Definition.FileURI = testPathURI("home/File.h", Strings); |
| 197 |
// Check that the symbol is valid and passing the correct path works. |
| 198 |
Serialized = ProtobufMarshaller.toProtobuf(Sym); |
| 199 |
ASSERT_TRUE(bool(Serialized)); |
| 200 |
Deserialized = ProtobufMarshaller.fromProtobuf(*Serialized); |
| 201 |
ASSERT_TRUE(bool(Deserialized)); |
| 202 |
EXPECT_STREQ(Deserialized->Definition.FileURI, |
| 203 |
testPathURI("home/File.h", Strings)); |
| 204 |
// Fail with a wrong root. |
| 205 |
Marshaller WrongMarshaller(testPath("nothome/"), testPath("home/")); |
| 206 |
Serialized = WrongMarshaller.toProtobuf(Sym); |
| 207 |
EXPECT_FALSE(Serialized); |
| 208 |
llvm::consumeError(Serialized.takeError()); |
| 209 |
} |
| 210 |
|
| 211 |
TEST(RemoteMarshallingTest, RefSerialization) { |
| 212 |
clangd::Ref Ref; |
| 213 |
Ref.Kind = clangd::RefKind::Spelled | clangd::RefKind::Declaration; |
| 214 |
|
| 215 |
llvm::BumpPtrAllocator Arena; |
| 216 |
llvm::UniqueStringSaver Strings(Arena); |
| 217 |
|
| 218 |
clangd::SymbolLocation Location; |
| 219 |
Location.Start.setLine(124); |
| 220 |
Location.Start.setColumn(21); |
| 221 |
Location.End.setLine(3213); |
| 222 |
Location.End.setColumn(541); |
| 223 |
Location.FileURI = testPathURI( |
| 224 |
"llvm-project/llvm/clang-tools-extra/clangd/Protocol.h", Strings); |
| 225 |
Ref.Location = Location; |
| 226 |
|
| 227 |
Marshaller ProtobufMarshaller(testPath("llvm-project/"), |
| 228 |
testPath("llvm-project/")); |
| 229 |
|
| 230 |
auto Serialized = ProtobufMarshaller.toProtobuf(Ref); |
| 231 |
ASSERT_TRUE(bool(Serialized)); |
| 232 |
auto Deserialized = ProtobufMarshaller.fromProtobuf(*Serialized); |
| 233 |
ASSERT_TRUE(bool(Deserialized)); |
| 234 |
EXPECT_EQ(toYAML(Ref), toYAML(*Deserialized)); |
| 235 |
} |
| 236 |
|
| 237 |
TEST(RemoteMarshallingTest, IncludeHeaderURIs) { |
| 238 |
llvm::BumpPtrAllocator Arena; |
| 239 |
llvm::UniqueStringSaver Strings(Arena); |
| 240 |
|
| 241 |
clangd::Symbol Sym = createSymbol("remote/", Strings); |
| 242 |
|
| 243 |
clangd::Symbol::IncludeHeaderWithReferences Header; |
| 244 |
// Add only valid headers. |
| 245 |
Header.IncludeHeader = |
| 246 |
Strings.save(URI::createFile(testPath("project/Header.h")).toString()); |
| 247 |
Header.References = 21; |
| 248 |
Sym.IncludeHeaders.push_back(Header); |
| 249 |
Header.IncludeHeader = Strings.save("<iostream>"); |
| 250 |
Header.References = 100; |
| 251 |
Sym.IncludeHeaders.push_back(Header); |
| 252 |
Header.IncludeHeader = Strings.save("\"cstdio\""); |
| 253 |
Header.References = 200; |
| 254 |
Sym.IncludeHeaders.push_back(Header); |
| 255 |
|
| 256 |
Marshaller ProtobufMarshaller(testPath(""), testPath("")); |
| 257 |
|
| 258 |
auto Serialized = ProtobufMarshaller.toProtobuf(Sym); |
| 259 |
ASSERT_TRUE(bool(Serialized)); |
| 260 |
EXPECT_EQ(static_cast<size_t>(Serialized->headers_size()), |
| 261 |
Sym.IncludeHeaders.size()); |
| 262 |
auto Deserialized = ProtobufMarshaller.fromProtobuf(*Serialized); |
| 263 |
ASSERT_TRUE(bool(Deserialized)); |
| 264 |
Sym.Origin = SymbolOrigin::Remote; |
| 265 |
EXPECT_EQ(toYAML(Sym), toYAML(*Deserialized)); |
| 266 |
|
| 267 |
// This is an absolute path to a header: can not be transmitted over the wire. |
| 268 |
Header.IncludeHeader = Strings.save(testPath("project/include/Common.h")); |
| 269 |
Header.References = 42; |
| 270 |
Sym.IncludeHeaders.push_back(Header); |
| 271 |
Serialized = ProtobufMarshaller.toProtobuf(Sym); |
| 272 |
EXPECT_FALSE(bool(Serialized)); |
| 273 |
llvm::consumeError(Serialized.takeError()); |
| 274 |
|
| 275 |
// Remove last invalid header. |
| 276 |
Sym.IncludeHeaders.pop_back(); |
| 277 |
// This is not a valid header: can not be transmitted over the wire; |
| 278 |
Header.IncludeHeader = Strings.save("NotAHeader"); |
| 279 |
Header.References = 5; |
| 280 |
Sym.IncludeHeaders.push_back(Header); |
| 281 |
Serialized = ProtobufMarshaller.toProtobuf(Sym); |
| 282 |
EXPECT_FALSE(bool(Serialized)); |
| 283 |
llvm::consumeError(Serialized.takeError()); |
| 284 |
|
| 285 |
// Try putting an invalid header into already serialized symbol. |
| 286 |
Sym.IncludeHeaders.pop_back(); |
| 287 |
Serialized = ProtobufMarshaller.toProtobuf(Sym); |
| 288 |
ASSERT_TRUE(bool(Serialized)); |
| 289 |
HeaderWithReferences InvalidHeader; |
| 290 |
InvalidHeader.set_header(convert_to_slash("/absolute/path/Header.h")); |
| 291 |
InvalidHeader.set_references(9000); |
| 292 |
*Serialized->add_headers() = InvalidHeader; |
| 293 |
Deserialized = ProtobufMarshaller.fromProtobuf(*Serialized); |
| 294 |
EXPECT_FALSE(bool(Deserialized)); |
| 295 |
llvm::consumeError(Deserialized.takeError()); |
| 296 |
} |
| 297 |
|
| 298 |
TEST(RemoteMarshallingTest, LookupRequestSerialization) { |
| 299 |
clangd::LookupRequest Request; |
| 300 |
Request.IDs.insert(llvm::cantFail(SymbolID::fromStr("0000000000000001"))); |
| 301 |
Request.IDs.insert(llvm::cantFail(SymbolID::fromStr("0000000000000002"))); |
| 302 |
|
| 303 |
Marshaller ProtobufMarshaller(testPath("remote/"), testPath("local/")); |
| 304 |
|
| 305 |
auto Serialized = ProtobufMarshaller.toProtobuf(Request); |
| 306 |
EXPECT_EQ(static_cast<unsigned>(Serialized.ids_size()), Request.IDs.size()); |
| 307 |
auto Deserialized = ProtobufMarshaller.fromProtobuf(&Serialized); |
| 308 |
ASSERT_TRUE(bool(Deserialized)); |
| 309 |
EXPECT_EQ(Deserialized->IDs, Request.IDs); |
| 310 |
} |
| 311 |
|
| 312 |
TEST(RemoteMarshallingTest, LookupRequestFailingSerialization) { |
| 313 |
clangd::LookupRequest Request; |
| 314 |
Marshaller ProtobufMarshaller(testPath("remote/"), testPath("local/")); |
| 315 |
auto Serialized = ProtobufMarshaller.toProtobuf(Request); |
| 316 |
Serialized.add_ids("Invalid Symbol ID"); |
| 317 |
auto Deserialized = ProtobufMarshaller.fromProtobuf(&Serialized); |
| 318 |
EXPECT_FALSE(bool(Deserialized)); |
| 319 |
llvm::consumeError(Deserialized.takeError()); |
| 320 |
} |
| 321 |
|
| 322 |
TEST(RemoteMarshallingTest, FuzzyFindRequestSerialization) { |
| 323 |
clangd::FuzzyFindRequest Request; |
| 324 |
Request.ProximityPaths = {testPath("local/Header.h"), |
| 325 |
testPath("local/subdir/OtherHeader.h"), |
| 326 |
testPath("remote/File.h"), "Not a Path."}; |
| 327 |
Marshaller ProtobufMarshaller(testPath("remote/"), testPath("local/")); |
| 328 |
auto Serialized = ProtobufMarshaller.toProtobuf(Request); |
| 329 |
EXPECT_EQ(Serialized.proximity_paths_size(), 2); |
| 330 |
auto Deserialized = ProtobufMarshaller.fromProtobuf(&Serialized); |
| 331 |
ASSERT_TRUE(bool(Deserialized)); |
| 332 |
EXPECT_THAT(Deserialized->ProximityPaths, |
| 333 |
testing::ElementsAre(testPath("remote/Header.h"), |
| 334 |
testPath("remote/subdir/OtherHeader.h"))); |
| 335 |
} |
| 336 |
|
| 337 |
TEST(RemoteMarshallingTest, RefsRequestSerialization) { |
| 338 |
clangd::RefsRequest Request; |
| 339 |
Request.IDs.insert(llvm::cantFail(SymbolID::fromStr("0000000000000001"))); |
| 340 |
Request.IDs.insert(llvm::cantFail(SymbolID::fromStr("0000000000000002"))); |
| 341 |
|
| 342 |
Request.Limit = 9000; |
| 343 |
Request.Filter = RefKind::Spelled | RefKind::Declaration; |
| 344 |
|
| 345 |
Marshaller ProtobufMarshaller(testPath("remote/"), testPath("local/")); |
| 346 |
|
| 347 |
auto Serialized = ProtobufMarshaller.toProtobuf(Request); |
| 348 |
EXPECT_EQ(static_cast<unsigned>(Serialized.ids_size()), Request.IDs.size()); |
| 349 |
EXPECT_EQ(Serialized.limit(), Request.Limit); |
| 350 |
auto Deserialized = ProtobufMarshaller.fromProtobuf(&Serialized); |
| 351 |
ASSERT_TRUE(bool(Deserialized)); |
| 352 |
EXPECT_EQ(Deserialized->IDs, Request.IDs); |
| 353 |
ASSERT_TRUE(Deserialized->Limit); |
| 354 |
EXPECT_EQ(*Deserialized->Limit, Request.Limit); |
| 355 |
EXPECT_EQ(Deserialized->Filter, Request.Filter); |
| 356 |
} |
| 357 |
|
| 358 |
TEST(RemoteMarshallingTest, RefsRequestFailingSerialization) { |
| 359 |
clangd::RefsRequest Request; |
| 360 |
Marshaller ProtobufMarshaller(testPath("remote/"), testPath("local/")); |
| 361 |
auto Serialized = ProtobufMarshaller.toProtobuf(Request); |
| 362 |
Serialized.add_ids("Invalid Symbol ID"); |
| 363 |
auto Deserialized = ProtobufMarshaller.fromProtobuf(&Serialized); |
| 364 |
EXPECT_FALSE(bool(Deserialized)); |
| 365 |
llvm::consumeError(Deserialized.takeError()); |
| 366 |
} |
| 367 |
|
| 368 |
TEST(RemoteMarshallingTest, RelationsRequestSerialization) { |
| 369 |
clangd::RelationsRequest Request; |
| 370 |
Request.Subjects.insert( |
| 371 |
llvm::cantFail(SymbolID::fromStr("0000000000000001"))); |
| 372 |
Request.Subjects.insert( |
| 373 |
llvm::cantFail(SymbolID::fromStr("0000000000000002"))); |
| 374 |
|
| 375 |
Request.Limit = 9000; |
| 376 |
Request.Predicate = RelationKind::BaseOf; |
| 377 |
|
| 378 |
Marshaller ProtobufMarshaller(testPath("remote/"), testPath("local/")); |
| 379 |
|
| 380 |
auto Serialized = ProtobufMarshaller.toProtobuf(Request); |
| 381 |
EXPECT_EQ(static_cast<unsigned>(Serialized.subjects_size()), |
| 382 |
Request.Subjects.size()); |
| 383 |
EXPECT_EQ(Serialized.limit(), Request.Limit); |
| 384 |
EXPECT_EQ(static_cast<RelationKind>(Serialized.predicate()), |
| 385 |
Request.Predicate); |
| 386 |
auto Deserialized = ProtobufMarshaller.fromProtobuf(&Serialized); |
| 387 |
ASSERT_TRUE(bool(Deserialized)); |
| 388 |
EXPECT_EQ(Deserialized->Subjects, Request.Subjects); |
| 389 |
ASSERT_TRUE(Deserialized->Limit); |
| 390 |
EXPECT_EQ(*Deserialized->Limit, Request.Limit); |
| 391 |
EXPECT_EQ(Deserialized->Predicate, Request.Predicate); |
| 392 |
} |
| 393 |
|
| 394 |
TEST(RemoteMarshallingTest, RelationsRequestFailingSerialization) { |
| 395 |
RelationsRequest Serialized; |
| 396 |
Serialized.add_subjects("ZZZZZZZZZZZZZZZZ"); |
| 397 |
Marshaller ProtobufMarshaller(testPath("remote/"), testPath("local/")); |
| 398 |
auto Deserialized = ProtobufMarshaller.fromProtobuf(&Serialized); |
| 399 |
EXPECT_FALSE(bool(Deserialized)); |
| 400 |
llvm::consumeError(Deserialized.takeError()); |
| 401 |
} |
| 402 |
|
| 403 |
TEST(RemoteMarshallingTest, RelationsSerializion) { |
| 404 |
llvm::BumpPtrAllocator Arena; |
| 405 |
llvm::UniqueStringSaver Strings(Arena); |
| 406 |
|
| 407 |
clangd::Symbol Sym = createSymbol("remote/", Strings); |
| 408 |
SymbolID ID = llvm::cantFail(SymbolID::fromStr("0000000000000002")); |
| 409 |
Marshaller ProtobufMarshaller(testPath("remote/"), testPath("local/")); |
| 410 |
auto Serialized = ProtobufMarshaller.toProtobuf(ID, Sym); |
| 411 |
ASSERT_TRUE(bool(Serialized)); |
| 412 |
auto Deserialized = ProtobufMarshaller.fromProtobuf(*Serialized); |
| 413 |
ASSERT_TRUE(bool(Deserialized)); |
| 414 |
EXPECT_THAT(Deserialized->first, ID); |
| 415 |
EXPECT_THAT(Deserialized->second.ID, Sym.ID); |
| 416 |
} |
| 417 |
|
| 418 |
TEST(RemoteMarshallingTest, RelativePathToURITranslation) { |
| 419 |
Marshaller ProtobufMarshaller(/*RemoteIndexRoot=*/"", |
| 420 |
/*LocalIndexRoot=*/testPath("home/project/")); |
| 421 |
auto URIString = ProtobufMarshaller.relativePathToURI("lib/File.cpp"); |
| 422 |
ASSERT_TRUE(bool(URIString)); |
| 423 |
// RelativePath can not be absolute. |
| 424 |
URIString = ProtobufMarshaller.relativePathToURI("/lib/File.cpp"); |
| 425 |
EXPECT_FALSE(bool(URIString)); |
| 426 |
llvm::consumeError(URIString.takeError()); |
| 427 |
// RelativePath can not be empty. |
| 428 |
URIString = ProtobufMarshaller.relativePathToURI(std::string()); |
| 429 |
EXPECT_FALSE(bool(URIString)); |
| 430 |
llvm::consumeError(URIString.takeError()); |
| 431 |
} |
| 432 |
|
| 433 |
TEST(RemoteMarshallingTest, URIToRelativePathTranslation) { |
| 434 |
llvm::BumpPtrAllocator Arena; |
| 435 |
llvm::UniqueStringSaver Strings(Arena); |
| 436 |
Marshaller ProtobufMarshaller(/*RemoteIndexRoot=*/testPath("remote/project/"), |
| 437 |
/*LocalIndexRoot=*/""); |
| 438 |
auto RelativePath = ProtobufMarshaller.uriToRelativePath( |
| 439 |
testPathURI("remote/project/lib/File.cpp", Strings)); |
| 440 |
ASSERT_TRUE(bool(RelativePath)); |
| 441 |
// RemoteIndexRoot has to be a prefix of the file path. |
| 442 |
Marshaller WrongMarshaller( |
| 443 |
/*RemoteIndexRoot=*/testPath("remote/other/project/"), |
| 444 |
/*LocalIndexRoot=*/""); |
| 445 |
RelativePath = WrongMarshaller.uriToRelativePath( |
| 446 |
testPathURI("remote/project/lib/File.cpp", Strings)); |
| 447 |
EXPECT_FALSE(bool(RelativePath)); |
| 448 |
llvm::consumeError(RelativePath.takeError()); |
| 449 |
} |
| 450 |
|
| 451 |
} // namespace |
| 452 |
} // namespace remote |
| 453 |
} // namespace clangd |
| 454 |
} // namespace clang |