clang-tools  12.0.0git
GlobalCompilationDatabaseTests.cpp
Go to the documentation of this file.
1 //===-- GlobalCompilationDatabaseTests.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 
10 
11 #include "Matchers.h"
12 #include "TestFS.h"
13 #include "support/Path.h"
14 #include "clang/Tooling/CompilationDatabase.h"
15 #include "llvm/ADT/Optional.h"
16 #include "llvm/ADT/SmallString.h"
17 #include "llvm/ADT/StringExtras.h"
18 #include "llvm/ADT/StringRef.h"
19 #include "llvm/Support/FileSystem.h"
20 #include "llvm/Support/FormatVariadic.h"
21 #include "llvm/Support/MemoryBuffer.h"
22 #include "llvm/Support/Path.h"
23 #include "llvm/Support/raw_ostream.h"
24 #include "gmock/gmock.h"
25 #include "gtest/gtest.h"
26 #include <fstream>
27 #include <string>
28 
29 namespace clang {
30 namespace clangd {
31 namespace {
32 using ::testing::AllOf;
33 using ::testing::Contains;
34 using ::testing::ElementsAre;
35 using ::testing::EndsWith;
36 using ::testing::HasSubstr;
37 using ::testing::IsEmpty;
38 using ::testing::Not;
39 using ::testing::StartsWith;
40 using ::testing::UnorderedElementsAre;
41 
42 TEST(GlobalCompilationDatabaseTest, FallbackCommand) {
43  DirectoryBasedGlobalCompilationDatabase DB(None);
44  auto Cmd = DB.getFallbackCommand(testPath("foo/bar.cc"));
45  EXPECT_EQ(Cmd.Directory, testPath("foo"));
46  EXPECT_THAT(Cmd.CommandLine, ElementsAre("clang", testPath("foo/bar.cc")));
47  EXPECT_EQ(Cmd.Output, "");
48 
49  // .h files have unknown language, so they are parsed liberally as obj-c++.
50  Cmd = DB.getFallbackCommand(testPath("foo/bar.h"));
51  EXPECT_THAT(Cmd.CommandLine, ElementsAre("clang", "-xobjective-c++-header",
52  testPath("foo/bar.h")));
53  Cmd = DB.getFallbackCommand(testPath("foo/bar"));
54  EXPECT_THAT(Cmd.CommandLine, ElementsAre("clang", "-xobjective-c++-header",
55  testPath("foo/bar")));
56 }
57 
58 static tooling::CompileCommand cmd(llvm::StringRef File, llvm::StringRef Arg) {
59  return tooling::CompileCommand(
60  testRoot(), File, {"clang", std::string(Arg), std::string(File)}, "");
61 }
62 
63 class OverlayCDBTest : public ::testing::Test {
64  class BaseCDB : public GlobalCompilationDatabase {
65  public:
66  llvm::Optional<tooling::CompileCommand>
67  getCompileCommand(llvm::StringRef File) const override {
68  if (File == testPath("foo.cc"))
69  return cmd(File, "-DA=1");
70  return None;
71  }
72 
73  tooling::CompileCommand
74  getFallbackCommand(llvm::StringRef File) const override {
75  return cmd(File, "-DA=2");
76  }
77 
78  llvm::Optional<ProjectInfo> getProjectInfo(PathRef File) const override {
79  return ProjectInfo{testRoot()};
80  }
81  };
82 
83 protected:
84  OverlayCDBTest() : Base(std::make_unique<BaseCDB>()) {}
85  std::unique_ptr<GlobalCompilationDatabase> Base;
86 };
87 
88 TEST_F(OverlayCDBTest, GetCompileCommand) {
89  OverlayCDB CDB(Base.get());
90  EXPECT_THAT(CDB.getCompileCommand(testPath("foo.cc"))->CommandLine,
91  AllOf(Contains(testPath("foo.cc")), Contains("-DA=1")));
92  EXPECT_EQ(CDB.getCompileCommand(testPath("missing.cc")), llvm::None);
93 
94  auto Override = cmd(testPath("foo.cc"), "-DA=3");
95  CDB.setCompileCommand(testPath("foo.cc"), Override);
96  EXPECT_THAT(CDB.getCompileCommand(testPath("foo.cc"))->CommandLine,
97  Contains("-DA=3"));
98  EXPECT_EQ(CDB.getCompileCommand(testPath("missing.cc")), llvm::None);
99  CDB.setCompileCommand(testPath("missing.cc"), Override);
100  EXPECT_THAT(CDB.getCompileCommand(testPath("missing.cc"))->CommandLine,
101  Contains("-DA=3"));
102 }
103 
104 TEST_F(OverlayCDBTest, GetFallbackCommand) {
105  OverlayCDB CDB(Base.get(), {"-DA=4"});
106  EXPECT_THAT(CDB.getFallbackCommand(testPath("bar.cc")).CommandLine,
107  ElementsAre("clang", "-DA=2", testPath("bar.cc"), "-DA=4"));
108 }
109 
110 TEST_F(OverlayCDBTest, NoBase) {
111  OverlayCDB CDB(nullptr, {"-DA=6"});
112  EXPECT_EQ(CDB.getCompileCommand(testPath("bar.cc")), None);
113  auto Override = cmd(testPath("bar.cc"), "-DA=5");
114  CDB.setCompileCommand(testPath("bar.cc"), Override);
115  EXPECT_THAT(CDB.getCompileCommand(testPath("bar.cc"))->CommandLine,
116  Contains("-DA=5"));
117 
118  EXPECT_THAT(CDB.getFallbackCommand(testPath("foo.cc")).CommandLine,
119  ElementsAre("clang", testPath("foo.cc"), "-DA=6"));
120 }
121 
122 TEST_F(OverlayCDBTest, Watch) {
123  OverlayCDB Inner(nullptr);
124  OverlayCDB Outer(&Inner);
125 
126  std::vector<std::vector<std::string>> Changes;
127  auto Sub = Outer.watch([&](const std::vector<std::string> &ChangedFiles) {
128  Changes.push_back(ChangedFiles);
129  });
130 
131  Inner.setCompileCommand("A.cpp", tooling::CompileCommand());
132  Outer.setCompileCommand("B.cpp", tooling::CompileCommand());
133  Inner.setCompileCommand("A.cpp", llvm::None);
134  Outer.setCompileCommand("C.cpp", llvm::None);
135  EXPECT_THAT(Changes, ElementsAre(ElementsAre("A.cpp"), ElementsAre("B.cpp"),
136  ElementsAre("A.cpp"), ElementsAre("C.cpp")));
137 }
138 
139 TEST_F(OverlayCDBTest, Adjustments) {
140  OverlayCDB CDB(Base.get(), {"-DFallback"},
141  [](const std::vector<std::string> &Cmd, llvm::StringRef File) {
142  auto Ret = Cmd;
143  Ret.push_back(
144  ("-DAdjust_" + llvm::sys::path::filename(File)).str());
145  return Ret;
146  });
147  // Command from underlying gets adjusted.
148  auto Cmd = CDB.getCompileCommand(testPath("foo.cc")).getValue();
149  EXPECT_THAT(Cmd.CommandLine, ElementsAre("clang", "-DA=1", testPath("foo.cc"),
150  "-DAdjust_foo.cc"));
151 
152  // Command from overlay gets adjusted.
153  tooling::CompileCommand BarCommand;
154  BarCommand.Filename = testPath("bar.cc");
155  BarCommand.CommandLine = {"clang++", "-DB=1", testPath("bar.cc")};
156  CDB.setCompileCommand(testPath("bar.cc"), BarCommand);
157  Cmd = CDB.getCompileCommand(testPath("bar.cc")).getValue();
158  EXPECT_THAT(
159  Cmd.CommandLine,
160  ElementsAre("clang++", "-DB=1", testPath("bar.cc"), "-DAdjust_bar.cc"));
161 
162  // Fallback gets adjusted.
163  Cmd = CDB.getFallbackCommand("baz.cc");
164  EXPECT_THAT(Cmd.CommandLine, ElementsAre("clang", "-DA=2", "baz.cc",
165  "-DFallback", "-DAdjust_baz.cc"));
166 }
167 
168 // Allows placement of files for tests and cleans them up after.
169 class ScratchFS {
170  llvm::SmallString<128> Root;
171 
172 public:
173  ScratchFS() {
174  EXPECT_FALSE(llvm::sys::fs::createUniqueDirectory("clangd-cdb-test", Root))
175  << "Failed to create unique directory";
176  }
177 
178  ~ScratchFS() {
179  EXPECT_FALSE(llvm::sys::fs::remove_directories(Root))
180  << "Failed to cleanup " << Root;
181  }
182 
183  llvm::StringRef root() const { return Root; }
184 
185  void write(PathRef RelativePath, llvm::StringRef Contents) {
186  std::string AbsPath = path(RelativePath);
187  EXPECT_FALSE(llvm::sys::fs::create_directories(
188  llvm::sys::path::parent_path(AbsPath)))
189  << "Failed to create directories for: " << AbsPath;
190 
191  std::error_code EC;
192  llvm::raw_fd_ostream OS(AbsPath, EC);
193  EXPECT_FALSE(EC) << "Failed to open " << AbsPath << " for writing";
194  OS << llvm::formatv(Contents.data(),
195  llvm::sys::path::convert_to_slash(Root));
196  OS.close();
197 
198  EXPECT_FALSE(OS.has_error());
199  }
200 
201  std::string path(PathRef RelativePath) const {
202  llvm::SmallString<128> AbsPath(Root);
203  llvm::sys::path::append(AbsPath, RelativePath);
204  llvm::sys::path::native(AbsPath);
205  return AbsPath.str().str();
206  }
207 };
208 
209 TEST(GlobalCompilationDatabaseTest, DiscoveryWithNestedCDBs) {
210  const char *const CDBOuter =
211  R"cdb(
212  [
213  {
214  "file": "a.cc",
215  "command": "",
216  "directory": "{0}",
217  },
218  {
219  "file": "build/gen.cc",
220  "command": "",
221  "directory": "{0}",
222  },
223  {
224  "file": "build/gen2.cc",
225  "command": "",
226  "directory": "{0}",
227  }
228  ]
229  )cdb";
230  const char *const CDBInner =
231  R"cdb(
232  [
233  {
234  "file": "gen.cc",
235  "command": "",
236  "directory": "{0}/build",
237  }
238  ]
239  )cdb";
240  ScratchFS FS;
241  FS.write("compile_commands.json", CDBOuter);
242  FS.write("build/compile_commands.json", CDBInner);
243 
244  // Note that gen2.cc goes missing with our following model, not sure this
245  // happens in practice though.
246  {
247  DirectoryBasedGlobalCompilationDatabase DB(llvm::None);
248  std::vector<std::string> DiscoveredFiles;
249  auto Sub =
250  DB.watch([&DiscoveredFiles](const std::vector<std::string> Changes) {
251  DiscoveredFiles = Changes;
252  });
253 
254  DB.getCompileCommand(FS.path("build/../a.cc"));
255  EXPECT_THAT(DiscoveredFiles, UnorderedElementsAre(AllOf(
256  EndsWith("a.cc"), Not(HasSubstr("..")))));
257  DiscoveredFiles.clear();
258 
259  DB.getCompileCommand(FS.path("build/gen.cc"));
260  EXPECT_THAT(DiscoveredFiles, UnorderedElementsAre(EndsWith("gen.cc")));
261  }
262 
263  // With a custom compile commands dir.
264  {
265  DirectoryBasedGlobalCompilationDatabase DB(FS.root().str());
266  std::vector<std::string> DiscoveredFiles;
267  auto Sub =
268  DB.watch([&DiscoveredFiles](const std::vector<std::string> Changes) {
269  DiscoveredFiles = Changes;
270  });
271 
272  DB.getCompileCommand(FS.path("a.cc"));
273  EXPECT_THAT(DiscoveredFiles,
274  UnorderedElementsAre(EndsWith("a.cc"), EndsWith("gen.cc"),
275  EndsWith("gen2.cc")));
276  DiscoveredFiles.clear();
277 
278  DB.getCompileCommand(FS.path("build/gen.cc"));
279  EXPECT_THAT(DiscoveredFiles, IsEmpty());
280  }
281 }
282 
283 TEST(GlobalCompilationDatabaseTest, BuildDir) {
284  ScratchFS FS;
285  auto Command = [&](llvm::StringRef Relative) {
286  return DirectoryBasedGlobalCompilationDatabase(llvm::None)
287  .getCompileCommand(FS.path(Relative))
288  .getValueOr(tooling::CompileCommand())
289  .CommandLine;
290  };
291  EXPECT_THAT(Command("x/foo.cc"), IsEmpty());
292  FS.write("x/build/compile_flags.txt", "-DXYZZY");
293  EXPECT_THAT(Command("x/foo.cc"), Contains("-DXYZZY"));
294  EXPECT_THAT(Command("bar.cc"), IsEmpty())
295  << "x/build/compile_flags.txt only applicable to x/";
296 }
297 
298 TEST(GlobalCompilationDatabaseTest, NonCanonicalFilenames) {
299  OverlayCDB DB(nullptr);
300  std::vector<std::string> DiscoveredFiles;
301  auto Sub =
302  DB.watch([&DiscoveredFiles](const std::vector<std::string> Changes) {
303  DiscoveredFiles = Changes;
304  });
305 
306  llvm::SmallString<128> Root(testRoot());
307  llvm::sys::path::append(Root, "build", "..", "a.cc");
308  DB.setCompileCommand(Root.str(), tooling::CompileCommand());
309  EXPECT_THAT(DiscoveredFiles, UnorderedElementsAre(testPath("a.cc")));
310  DiscoveredFiles.clear();
311 
312  llvm::SmallString<128> File(testRoot());
313  llvm::sys::path::append(File, "blabla", "..", "a.cc");
314 
315  EXPECT_TRUE(DB.getCompileCommand(File));
316  EXPECT_TRUE(DB.getProjectInfo(File));
317 }
318 
319 } // namespace
320 } // namespace clangd
321 } // namespace clang
tooling::Replacements Changes
Definition: Format.cpp:109
MockFS FS
llvm::StringRef PathRef
A typedef to represent a ref to file path.
Definition: Path.h:23
Documents should not be synced at all.
std::vector< llvm::StringRef > CommandLine
llvm::StringRef Contents
std::pair< Context, Canceler > Outer
TEST_F(BackgroundIndexTest, NoCrashOnErrorFile)
TEST(BackgroundQueueTest, Priority)
std::string testPath(PathRef File, llvm::sys::path::Style Style)
Definition: TestFS.cpp:82
llvm::raw_string_ostream OS
Definition: TraceTests.cpp:162
const char * testRoot()
Definition: TestFS.cpp:74
std::pair< Context, Canceler > Inner
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
std::unique_ptr< GlobalCompilationDatabase > Base