clang-tools-extra/clangd/unittests/GlobalCompilationDatabaseTests.cpp

   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
   9 #include "GlobalCompilationDatabase.h"
  10
  11 #include "CompileCommands.h"
  12 #include "Config.h"
  13 #include "TestFS.h"
  14 #include "support/Path.h"
  15 #include "support/ThreadsafeFS.h"
  16 #include "clang/Tooling/CompilationDatabase.h"
  17 #include "llvm/ADT/STLExtras.h"
  18 #include "llvm/ADT/SmallString.h"
  19 #include "llvm/ADT/StringRef.h"
  20 #include "llvm/Support/FormatVariadic.h"
  21 #include "llvm/Support/Path.h"
  22 #include "gmock/gmock.h"
  23 #include "gtest/gtest.h"
  24 #include <chrono>
  25 #include <fstream>
  26 #include <optional>
  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::UnorderedElementsAre;
  40
  41 TEST(GlobalCompilationDatabaseTest, FallbackCommand) {
  42   MockFS TFS;
  43   DirectoryBasedGlobalCompilationDatabase DB(TFS);
  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     std::optional<tooling::CompileCommand>
  67     getCompileCommand(llvm::StringRef File) const override {
  68       if (File == testPath("foo.cc"))
  69         return cmd(File, "-DA=1");
  70       return std::nullopt;
  71     }
  72
  73     tooling::CompileCommand
  74     getFallbackCommand(llvm::StringRef File) const override {
  75       return cmd(File, "-DA=2");
  76     }
  77
  78     std::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")), std::nullopt);
  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")), std::nullopt);
  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")), std::nullopt);
 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", std::nullopt);
 134   Outer.setCompileCommand("C.cpp", std::nullopt);
 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                  [](tooling::CompileCommand &Cmd, llvm::StringRef File) {
 142                    Cmd.CommandLine.push_back(
 143                        ("-DAdjust_" + llvm::sys::path::filename(File)).str());
 144                  });
 145   // Command from underlying gets adjusted.
 146   auto Cmd = *CDB.getCompileCommand(testPath("foo.cc"));
 147   EXPECT_THAT(Cmd.CommandLine, ElementsAre("clang", "-DA=1", testPath("foo.cc"),
 148                                            "-DAdjust_foo.cc"));
 149
 150   // Command from overlay gets adjusted.
 151   tooling::CompileCommand BarCommand;
 152   BarCommand.Filename = testPath("bar.cc");
 153   BarCommand.CommandLine = {"clang++", "-DB=1", testPath("bar.cc")};
 154   CDB.setCompileCommand(testPath("bar.cc"), BarCommand);
 155   Cmd = *CDB.getCompileCommand(testPath("bar.cc"));
 156   EXPECT_THAT(
 157       Cmd.CommandLine,
 158       ElementsAre("clang++", "-DB=1", testPath("bar.cc"), "-DAdjust_bar.cc"));
 159
 160   // Fallback gets adjusted.
 161   Cmd = CDB.getFallbackCommand("baz.cc");
 162   EXPECT_THAT(Cmd.CommandLine, ElementsAre("clang", "-DA=2", "baz.cc",
 163                                            "-DFallback", "-DAdjust_baz.cc"));
 164 }
 165
 166 TEST(GlobalCompilationDatabaseTest, DiscoveryWithNestedCDBs) {
 167   const char *const CDBOuter =
 168       R"cdb(
 169       [
 170         {
 171           "file": "a.cc",
 172           "command": "",
 173           "directory": "{0}",
 174         },
 175         {
 176           "file": "build/gen.cc",
 177           "command": "",
 178           "directory": "{0}",
 179         },
 180         {
 181           "file": "build/gen2.cc",
 182           "command": "",
 183           "directory": "{0}",
 184         }
 185       ]
 186       )cdb";
 187   const char *const CDBInner =
 188       R"cdb(
 189       [
 190         {
 191           "file": "gen.cc",
 192           "command": "",
 193           "directory": "{0}/build",
 194         }
 195       ]
 196       )cdb";
 197   MockFS FS;
 198   FS.Files[testPath("compile_commands.json")] =
 199       llvm::formatv(CDBOuter, llvm::sys::path::convert_to_slash(testRoot()));
 200   FS.Files[testPath("build/compile_commands.json")] =
 201       llvm::formatv(CDBInner, llvm::sys::path::convert_to_slash(testRoot()));
 202   FS.Files[testPath("foo/compile_flags.txt")] = "-DFOO";
 203
 204   // Note that gen2.cc goes missing with our following model, not sure this
 205   // happens in practice though.
 206   {
 207     SCOPED_TRACE("Default ancestor scanning");
 208     DirectoryBasedGlobalCompilationDatabase DB(FS);
 209     std::vector<std::string> DiscoveredFiles;
 210     auto Sub =
 211         DB.watch([&DiscoveredFiles](const std::vector<std::string> Changes) {
 212           DiscoveredFiles = Changes;
 213         });
 214
 215     DB.getCompileCommand(testPath("build/../a.cc"));
 216     ASSERT_TRUE(DB.blockUntilIdle(timeoutSeconds(10)));
 217     EXPECT_THAT(DiscoveredFiles, UnorderedElementsAre(AllOf(
 218                                      EndsWith("a.cc"), Not(HasSubstr("..")))));
 219     DiscoveredFiles.clear();
 220
 221     DB.getCompileCommand(testPath("build/gen.cc"));
 222     ASSERT_TRUE(DB.blockUntilIdle(timeoutSeconds(10)));
 223     EXPECT_THAT(DiscoveredFiles, UnorderedElementsAre(EndsWith("gen.cc")));
 224   }
 225
 226   {
 227     SCOPED_TRACE("With config");
 228     DirectoryBasedGlobalCompilationDatabase::Options Opts(FS);
 229     Opts.ContextProvider = [&](llvm::StringRef Path) {
 230       Config Cfg;
 231       if (Path.endswith("a.cc")) {
 232         // a.cc uses another directory's CDB, so it won't be discovered.
 233         Cfg.CompileFlags.CDBSearch.Policy = Config::CDBSearchSpec::FixedDir;
 234         Cfg.CompileFlags.CDBSearch.FixedCDBPath = testPath("foo");
 235       } else if (Path.endswith("gen.cc")) {
 236         // gen.cc has CDB search disabled, so it won't be discovered.
 237         Cfg.CompileFlags.CDBSearch.Policy = Config::CDBSearchSpec::NoCDBSearch;
 238       } else if (Path.endswith("gen2.cc")) {
 239         // gen2.cc explicitly lists this directory, so it will be discovered.
 240         Cfg.CompileFlags.CDBSearch.Policy = Config::CDBSearchSpec::FixedDir;
 241         Cfg.CompileFlags.CDBSearch.FixedCDBPath = testRoot();
 242       }
 243       return Context::current().derive(Config::Key, std::move(Cfg));
 244     };
 245     DirectoryBasedGlobalCompilationDatabase DB(Opts);
 246     std::vector<std::string> DiscoveredFiles;
 247     auto Sub =
 248         DB.watch([&DiscoveredFiles](const std::vector<std::string> Changes) {
 249           DiscoveredFiles = Changes;
 250         });
 251
 252     // Does not use the root CDB, so no broadcast.
 253     auto Cmd = DB.getCompileCommand(testPath("build/../a.cc"));
 254     ASSERT_TRUE(Cmd);
 255     EXPECT_THAT(Cmd->CommandLine, Contains("-DFOO")) << "a.cc uses foo/ CDB";
 256     ASSERT_TRUE(DB.blockUntilIdle(timeoutSeconds(10)));
 257     EXPECT_THAT(DiscoveredFiles, IsEmpty()) << "Root CDB not discovered yet";
 258
 259     // No special config for b.cc, so we trigger broadcast of the root CDB.
 260     DB.getCompileCommand(testPath("b.cc"));
 261     ASSERT_TRUE(DB.blockUntilIdle(timeoutSeconds(10)));
 262     EXPECT_THAT(DiscoveredFiles, ElementsAre(testPath("build/gen2.cc")));
 263     DiscoveredFiles.clear();
 264
 265     // No CDB search so no discovery/broadcast triggered for build/ CDB.
 266     DB.getCompileCommand(testPath("build/gen.cc"));
 267     ASSERT_TRUE(DB.blockUntilIdle(timeoutSeconds(10)));
 268     EXPECT_THAT(DiscoveredFiles, IsEmpty());
 269   }
 270
 271   {
 272     SCOPED_TRACE("With custom compile commands dir");
 273     DirectoryBasedGlobalCompilationDatabase::Options Opts(FS);
 274     Opts.CompileCommandsDir = testRoot();
 275     DirectoryBasedGlobalCompilationDatabase DB(Opts);
 276     std::vector<std::string> DiscoveredFiles;
 277     auto Sub =
 278         DB.watch([&DiscoveredFiles](const std::vector<std::string> Changes) {
 279           DiscoveredFiles = Changes;
 280         });
 281
 282     DB.getCompileCommand(testPath("a.cc"));
 283     ASSERT_TRUE(DB.blockUntilIdle(timeoutSeconds(10)));
 284     EXPECT_THAT(DiscoveredFiles,
 285                 UnorderedElementsAre(EndsWith("a.cc"), EndsWith("gen.cc"),
 286                                      EndsWith("gen2.cc")));
 287     DiscoveredFiles.clear();
 288
 289     DB.getCompileCommand(testPath("build/gen.cc"));
 290     ASSERT_TRUE(DB.blockUntilIdle(timeoutSeconds(10)));
 291     EXPECT_THAT(DiscoveredFiles, IsEmpty());
 292   }
 293 }
 294
 295 TEST(GlobalCompilationDatabaseTest, BuildDir) {
 296   MockFS FS;
 297   auto Command = [&](llvm::StringRef Relative) {
 298     DirectoryBasedGlobalCompilationDatabase::Options Opts(FS);
 299     return DirectoryBasedGlobalCompilationDatabase(Opts)
 300         .getCompileCommand(testPath(Relative))
 301         .value_or(tooling::CompileCommand())
 302         .CommandLine;
 303   };
 304   EXPECT_THAT(Command("x/foo.cc"), IsEmpty());
 305   const char *const CDB =
 306       R"cdb(
 307       [
 308         {
 309           "file": "{0}/x/foo.cc",
 310           "command": "clang -DXYZZY {0}/x/foo.cc",
 311           "directory": "{0}",
 312         },
 313         {
 314           "file": "{0}/bar.cc",
 315           "command": "clang -DXYZZY {0}/bar.cc",
 316           "directory": "{0}",
 317         }
 318       ]
 319       )cdb";
 320   FS.Files[testPath("x/build/compile_commands.json")] =
 321       llvm::formatv(CDB, llvm::sys::path::convert_to_slash(testRoot()));
 322   EXPECT_THAT(Command("x/foo.cc"), Contains("-DXYZZY"));
 323   EXPECT_THAT(Command("bar.cc"), IsEmpty())
 324       << "x/build/compile_flags.json only applicable to x/";
 325 }
 326
 327 TEST(GlobalCompilationDatabaseTest, CompileFlagsDirectory) {
 328   MockFS FS;
 329   FS.Files[testPath("x/compile_flags.txt")] = "-DFOO";
 330   DirectoryBasedGlobalCompilationDatabase CDB(FS);
 331   auto Commands = CDB.getCompileCommand(testPath("x/y.cpp"));
 332   ASSERT_TRUE(Commands.has_value());
 333   EXPECT_THAT(Commands->CommandLine, Contains("-DFOO"));
 334   // Make sure we pick the right working directory.
 335   EXPECT_EQ(testPath("x"), Commands->Directory);
 336 }
 337
 338 MATCHER_P(hasArg, Flag, "") {
 339   if (!arg) {
 340     *result_listener << "command is null";
 341     return false;
 342   }
 343   if (!llvm::is_contained(arg->CommandLine, Flag)) {
 344     *result_listener << "flags are " << printArgv(arg->CommandLine);
 345     return false;
 346   }
 347   return true;
 348 }
 349
 350 TEST(GlobalCompilationDatabaseTest, Config) {
 351   MockFS FS;
 352   FS.Files[testPath("x/compile_flags.txt")] = "-DX";
 353   FS.Files[testPath("x/y/z/compile_flags.txt")] = "-DZ";
 354
 355   Config::CDBSearchSpec Spec;
 356   DirectoryBasedGlobalCompilationDatabase::Options Opts(FS);
 357   Opts.ContextProvider = [&](llvm::StringRef Path) {
 358     Config C;
 359     C.CompileFlags.CDBSearch = Spec;
 360     return Context::current().derive(Config::Key, std::move(C));
 361   };
 362   DirectoryBasedGlobalCompilationDatabase CDB(Opts);
 363
 364   // Default ancestor behavior.
 365   EXPECT_FALSE(CDB.getCompileCommand(testPath("foo.cc")));
 366   EXPECT_THAT(CDB.getCompileCommand(testPath("x/foo.cc")), hasArg("-DX"));
 367   EXPECT_THAT(CDB.getCompileCommand(testPath("x/y/foo.cc")), hasArg("-DX"));
 368   EXPECT_THAT(CDB.getCompileCommand(testPath("x/y/z/foo.cc")), hasArg("-DZ"));
 369
 370   Spec.Policy = Config::CDBSearchSpec::NoCDBSearch;
 371   EXPECT_FALSE(CDB.getCompileCommand(testPath("foo.cc")));
 372   EXPECT_FALSE(CDB.getCompileCommand(testPath("x/foo.cc")));
 373   EXPECT_FALSE(CDB.getCompileCommand(testPath("x/y/foo.cc")));
 374   EXPECT_FALSE(CDB.getCompileCommand(testPath("x/y/z/foo.cc")));
 375
 376   Spec.Policy = Config::CDBSearchSpec::FixedDir;
 377   Spec.FixedCDBPath = testPath("w"); // doesn't exist
 378   EXPECT_FALSE(CDB.getCompileCommand(testPath("foo.cc")));
 379   EXPECT_FALSE(CDB.getCompileCommand(testPath("x/foo.cc")));
 380   EXPECT_FALSE(CDB.getCompileCommand(testPath("x/y/foo.cc")));
 381   EXPECT_FALSE(CDB.getCompileCommand(testPath("x/y/z/foo.cc")));
 382
 383   Spec.FixedCDBPath = testPath("x/y/z");
 384   EXPECT_THAT(CDB.getCompileCommand(testPath("foo.cc")), hasArg("-DZ"));
 385   EXPECT_THAT(CDB.getCompileCommand(testPath("x/foo.cc")), hasArg("-DZ"));
 386   EXPECT_THAT(CDB.getCompileCommand(testPath("x/y/foo.cc")), hasArg("-DZ"));
 387   EXPECT_THAT(CDB.getCompileCommand(testPath("x/y/z/foo.cc")), hasArg("-DZ"));
 388 }
 389
 390 TEST(GlobalCompilationDatabaseTest, NonCanonicalFilenames) {
 391   OverlayCDB DB(nullptr);
 392   std::vector<std::string> DiscoveredFiles;
 393   auto Sub =
 394       DB.watch([&DiscoveredFiles](const std::vector<std::string> Changes) {
 395         DiscoveredFiles = Changes;
 396       });
 397
 398   llvm::SmallString<128> Root(testRoot());
 399   llvm::sys::path::append(Root, "build", "..", "a.cc");
 400   DB.setCompileCommand(Root.str(), tooling::CompileCommand());
 401   EXPECT_THAT(DiscoveredFiles, UnorderedElementsAre(testPath("a.cc")));
 402   DiscoveredFiles.clear();
 403
 404   llvm::SmallString<128> File(testRoot());
 405   llvm::sys::path::append(File, "blabla", "..", "a.cc");
 406
 407   EXPECT_TRUE(DB.getCompileCommand(File));
 408   EXPECT_FALSE(DB.getProjectInfo(File));
 409 }
 410
 411 TEST_F(OverlayCDBTest, GetProjectInfo) {
 412   OverlayCDB DB(Base.get());
 413   Path File = testPath("foo.cc");
 414   Path Header = testPath("foo.h");
 415
 416   EXPECT_EQ(DB.getProjectInfo(File)->SourceRoot, testRoot());
 417   EXPECT_EQ(DB.getProjectInfo(Header)->SourceRoot, testRoot());
 418
 419   // Shouldn't change after an override.
 420   DB.setCompileCommand(File, tooling::CompileCommand());
 421   EXPECT_EQ(DB.getProjectInfo(File)->SourceRoot, testRoot());
 422   EXPECT_EQ(DB.getProjectInfo(Header)->SourceRoot, testRoot());
 423 }
 424 } // namespace
 425
 426 // Friend test has access to internals.
 427 class DirectoryBasedGlobalCompilationDatabaseCacheTest
 428     : public ::testing::Test {
 429 protected:
 430   std::shared_ptr<const tooling::CompilationDatabase>
 431   lookupCDB(const DirectoryBasedGlobalCompilationDatabase &GDB,
 432             llvm::StringRef Path,
 433             std::chrono::steady_clock::time_point FreshTime) {
 434     DirectoryBasedGlobalCompilationDatabase::CDBLookupRequest Req;
 435     Req.FileName = Path;
 436     Req.FreshTime = Req.FreshTimeMissing = FreshTime;
 437     if (auto Result = GDB.lookupCDB(Req))
 438       return std::move(Result->CDB);
 439     return nullptr;
 440   }
 441 };
 442
 443 // Matches non-null CDBs which include the specified flag.
 444 MATCHER_P2(hasFlag, Flag, Path, "") {
 445   if (arg == nullptr)
 446     return false;
 447   auto Cmds = arg->getCompileCommands(Path);
 448   if (Cmds.empty()) {
 449     *result_listener << "yields no commands";
 450     return false;
 451   }
 452   if (!llvm::is_contained(Cmds.front().CommandLine, Flag)) {
 453     *result_listener << "flags are: " << printArgv(Cmds.front().CommandLine);
 454     return false;
 455   }
 456   return true;
 457 }
 458
 459 auto hasFlag(llvm::StringRef Flag) {
 460   return hasFlag(Flag, "mock_file_name.cc");
 461 }
 462
 463 TEST_F(DirectoryBasedGlobalCompilationDatabaseCacheTest, Cacheable) {
 464   MockFS FS;
 465   auto Stale = std::chrono::steady_clock::now() - std::chrono::minutes(1);
 466   auto Fresh = std::chrono::steady_clock::now() + std::chrono::hours(24);
 467
 468   DirectoryBasedGlobalCompilationDatabase GDB(FS);
 469   FS.Files["compile_flags.txt"] = "-DROOT";
 470   auto Root = lookupCDB(GDB, testPath("foo/test.cc"), Stale);
 471   EXPECT_THAT(Root, hasFlag("-DROOT"));
 472
 473   // Add a compilation database to a subdirectory - CDB loaded.
 474   FS.Files["foo/compile_flags.txt"] = "-DFOO";
 475   EXPECT_EQ(Root, lookupCDB(GDB, testPath("foo/test.cc"), Stale))
 476       << "cache still valid";
 477   auto Foo = lookupCDB(GDB, testPath("foo/test.cc"), Fresh);
 478   EXPECT_THAT(Foo, hasFlag("-DFOO")) << "new cdb loaded";
 479   EXPECT_EQ(Foo, lookupCDB(GDB, testPath("foo/test.cc"), Stale))
 480       << "new cdb in cache";
 481
 482   // Mtime changed, but no content change - CDB not reloaded.
 483   ++FS.Timestamps["foo/compile_flags.txt"];
 484   auto FooAgain = lookupCDB(GDB, testPath("foo/test.cc"), Fresh);
 485   EXPECT_EQ(Foo, FooAgain) << "Same content, read but not reloaded";
 486   // Content changed, but not size or mtime - CDB not reloaded.
 487   FS.Files["foo/compile_flags.txt"] = "-DBAR";
 488   auto FooAgain2 = lookupCDB(GDB, testPath("foo/test.cc"), Fresh);
 489   EXPECT_EQ(Foo, FooAgain2) << "Same filesize, change not detected";
 490   // Mtime change forces a re-read, and we notice the different content.
 491   ++FS.Timestamps["foo/compile_flags.txt"];
 492   auto Bar = lookupCDB(GDB, testPath("foo/test.cc"), Fresh);
 493   EXPECT_THAT(Bar, hasFlag("-DBAR")) << "refreshed with mtime change";
 494
 495   // Size and content both change - CDB reloaded.
 496   FS.Files["foo/compile_flags.txt"] = "-DFOOBAR";
 497   EXPECT_EQ(Bar, lookupCDB(GDB, testPath("foo/test.cc"), Stale))
 498       << "cache still valid";
 499   auto FooBar = lookupCDB(GDB, testPath("foo/test.cc"), Fresh);
 500   EXPECT_THAT(FooBar, hasFlag("-DFOOBAR")) << "cdb reloaded";
 501
 502   // compile_commands.json takes precedence over compile_flags.txt.
 503   FS.Files["foo/compile_commands.json"] =
 504       llvm::formatv(R"json([{
 505     "file": "{0}/foo/mock_file.cc",
 506     "command": "clang -DBAZ mock_file.cc",
 507     "directory": "{0}/foo",
 508   }])json",
 509                     llvm::sys::path::convert_to_slash(testRoot()));
 510   EXPECT_EQ(FooBar, lookupCDB(GDB, testPath("foo/test.cc"), Stale))
 511       << "cache still valid";
 512   auto Baz = lookupCDB(GDB, testPath("foo/test.cc"), Fresh);
 513   EXPECT_THAT(Baz, hasFlag("-DBAZ", testPath("foo/mock_file.cc")))
 514       << "compile_commands overrides compile_flags";
 515
 516   // Removing compile_commands.json reveals compile_flags.txt again.
 517   // However this *does* cause a CDB reload (we cache only one CDB per dir).
 518   FS.Files.erase("foo/compile_commands.json");
 519   auto FoobarAgain = lookupCDB(GDB, testPath("foo/test.cc"), Fresh);
 520   EXPECT_THAT(FoobarAgain, hasFlag("-DFOOBAR")) << "reloaded compile_flags";
 521   EXPECT_NE(FoobarAgain, FooBar) << "CDB discarded (shadowed within directory)";
 522
 523   // Removing the directory's CDB leaves the parent CDB active.
 524   // The parent CDB is *not* reloaded (we cache the CDB per-directory).
 525   FS.Files.erase("foo/compile_flags.txt");
 526   EXPECT_EQ(Root, lookupCDB(GDB, testPath("foo/test.cc"), Fresh))
 527       << "CDB retained (shadowed by another directory)";
 528 }
 529
 530 } // namespace clangd
 531 } // namespace clang