[clangd] Turn on missing-include diags by default

[kadircet]

Summary

By disabling include-cleaner analysis for Diagnostics tests by default.

clang-tools-extra/clangd/Config.h

struct {
       std::string Checks;
       llvm::StringMap<std::string> CheckOptions;
     } ClangTidy;
 
     /// Enable emitting diagnostics using stale preambles.
     bool AllowStalePreamble = false;
 
     IncludesPolicy UnusedIncludes = IncludesPolicy::Strict;
-    IncludesPolicy MissingIncludes = IncludesPolicy::None;
+    IncludesPolicy MissingIncludes = IncludesPolicy::Strict;
 
     /// IncludeCleaner will not diagnose usages of these headers matched by
     /// these regexes.
     struct {
       std::vector<std::function<bool(llvm::StringRef)>> IgnoreHeader;
     } Includes;
   } Diagnostics;
 

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

 //===-- ClangdTests.cpp - Clangd unit tests ---------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Annotations.h"
 #include "ClangdServer.h"
 #include "CodeComplete.h"
 #include "CompileCommands.h"
 #include "ConfigFragment.h"
+#include "Diagnostics.h"
 #include "GlobalCompilationDatabase.h"
 #include "Matchers.h"
 #include "SyncAPI.h"
 #include "TestFS.h"
 #include "TestTU.h"
 #include "TidyProvider.h"
 #include "refactor/Tweak.h"
 #include "support/MemoryTree.h"

 }
 #endif
 
 TEST(ClangdServer, TidyOverrideTest) {
   struct DiagsCheckingCallback : public ClangdServer::Callbacks {
   public:
     void onDiagnosticsReady(PathRef File, llvm::StringRef Version,
                             std::vector<Diag> Diagnostics) override {
+      bool HasTidyDiags = false;
+      for (auto &D : Diagnostics) {
+        if (D.Source == Diag::ClangTidy)
+          HasTidyDiags = true;
+      }
       std::lock_guard<std::mutex> Lock(Mutex);
-      HadDiagsInLastCallback = !Diagnostics.empty();
+      HadDiagsInLastCallback = HasTidyDiags;
     }
 
     std::mutex Mutex;
     bool HadDiagsInLastCallback = false;
   } DiagConsumer;
 
   MockFS FS;
   // These checks don't work well in clangd, even if configured they shouldn't

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

 //===--- DiagnosticsTests.cpp ------------------------------------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "/usr/local/google/home/kadircet/repos/llvm/clang-tools-extra/clang-tidy/ClangTidyOptions.h"
+#include "../clang-tidy/ClangTidyOptions.h"
 #include "Annotations.h"
 #include "Config.h"
 #include "Diagnostics.h"
 #include "Feature.h"
 #include "FeatureModule.h"
 #include "ParsedAST.h"
 #include "Protocol.h"
 #include "TestFS.h"

 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/TargetSelect.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cstddef>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 namespace {
 

 // that as much of the test is still compiled an run as possible.
 ::testing::Matcher<std::vector<clangd::Diag>>
 ifTidyChecks(::testing::Matcher<std::vector<clangd::Diag>> M) {
   if (!CLANGD_TIDY_CHECKS)
     return IsEmpty();
   return M;
 }
 
-TEST(DiagnosticsTest, DiagnosticRanges) {
+class DiagnosticsTest : public ::testing::Test {
+  std::optional<WithContextValue> Ctx;
+  void SetUp() override {
+    Config Cfg;
+    Cfg.Diagnostics.MissingIncludes = Config::IncludesPolicy::None;
+    Cfg.Diagnostics.UnusedIncludes = Config::IncludesPolicy::None;
+    Ctx.emplace(Config::Key, std::move(Cfg));
+  }
+};
+
+TEST_F(DiagnosticsTest, DiagnosticRanges) {
   // Check we report correct ranges, including various edge-cases.
   Annotations Test(R"cpp(
     // error-ok
     #define ID(X) X
     namespace test{};
     void $decl[[foo]]();
     int main() {
       struct Container { int* begin(); int* end(); } *container;
EXPECT_THAT(
                             "change 'fod' to 'foo'")))));
 }
 
 // Verify that the -Wswitch case-not-covered diagnostic range covers the
 // whole expression. This is important because the "populate-switch" tweak
 // fires for the full expression range (see tweaks/PopulateSwitchTests.cpp).
 // The quickfix flow only works end-to-end if the tweak can be triggered on
 // the diagnostic's range.
-TEST(DiagnosticsTest, WSwitch) {
+TEST_F(DiagnosticsTest, WSwitch) {
   Annotations Test(R"cpp(
     enum A { X };
     struct B { A a; };
     void foo(B b) {
       switch ([[b.a]]) {}
     }
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   TU.ExtraArgs = {"-Wswitch"};
   EXPECT_THAT(*TU.build().getDiagnostics(),
               ElementsAre(Diag(Test.range(),
                                "enumeration value 'X' not handled in switch")));
 }
 
-TEST(DiagnosticsTest, FlagsMatter) {
+TEST_F(DiagnosticsTest, FlagsMatter) {
   Annotations Test("[[void]] main() {} // error-ok");
   auto TU = TestTU::withCode(Test.code());
   EXPECT_THAT(*TU.build().getDiagnostics(),
               ElementsAre(AllOf(Diag(Test.range(), "'main' must return 'int'"),
                                 withFix(Fix(Test.range(), "int",
                                             "change 'void' to 'int'")))));
   // Same code built as C gets different diagnostics.
   TU.Filename = "Plain.c";
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
       ElementsAre(AllOf(
           Diag(Test.range(), "return type of 'main' is not 'int'"),
           withFix(Fix(Test.range(), "int", "change return type to 'int'")))));
 }
 
-TEST(DiagnosticsTest, DiagnosticPreamble) {
+TEST_F(DiagnosticsTest, DiagnosticPreamble) {
   Annotations Test(R"cpp(
     #include $[["not-found.h"]] // error-ok
   )cpp");
 
   auto TU = TestTU::withCode(Test.code());
   EXPECT_THAT(*TU.build().getDiagnostics(),
               ElementsAre(::testing::AllOf(
                   Diag(Test.range(), "'not-found.h' file not found"),
                   diagSource(Diag::Clang), diagName("pp_file_not_found"))));
 }
 
-TEST(DiagnosticsTest, DeduplicatedClangTidyDiagnostics) {
+TEST_F(DiagnosticsTest, DeduplicatedClangTidyDiagnostics) {
   Annotations Test(R"cpp(
     float foo = [[0.1f]];
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   // Enable alias clang-tidy checks, these check emits the same diagnostics
   // (except the check name).
   TU.ClangTidyProvider = addTidyChecks("readability-uppercase-literal-suffix,"
                                        "hicpp-uppercase-literal-suffix");
TEST_F(DiagnosticsTest, DeduplicatedClangTidyDiagnostics) {
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
       ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
           Diag(Test.range(),
                "floating point literal has suffix 'f', which is not uppercase"),
           diagSource(Diag::ClangTidy)))));
 }
 
-TEST(DiagnosticsTest, ClangTidy) {
+TEST_F(DiagnosticsTest, ClangTidy) {
   Annotations Test(R"cpp(
     #include $deprecated[["assert.h"]]
 
     #define $macrodef[[SQUARE]](X) (X)*(X)
     int $main[[main]]() {
       int y = 4;
       return SQUARE($macroarg[[++]]y);
       return $doubled[[sizeof]](sizeof(int));
EXPECT_THAT(
                 withFix(fixMessage(
                     "use a trailing return type for this function"))),
           Diag(Test.range("foo"),
                "function 'foo' is within a recursive call chain"),
           Diag(Test.range("bar"),
                "function 'bar' is within a recursive call chain"))));
 }
 
-TEST(DiagnosticsTest, ClangTidyEOF) {
+TEST_F(DiagnosticsTest, ClangTidyEOF) {
   // clang-format off
   Annotations Test(R"cpp(
   [[#]]include <b.h>
   #include "a.h")cpp");
   // clang-format on
   auto TU = TestTU::withCode(Test.code());
   TU.ExtraArgs = {"-isystem."};
   TU.AdditionalFiles["a.h"] = TU.AdditionalFiles["b.h"] = "";
   TU.ClangTidyProvider = addTidyChecks("llvm-include-order");
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
       ifTidyChecks(Contains(
           AllOf(Diag(Test.range(), "#includes are not sorted properly"),
                 diagSource(Diag::ClangTidy), diagName("llvm-include-order")))));
 }
 
-TEST(DiagnosticTest, TemplatesInHeaders) {
+TEST_F(DiagnosticsTest, TemplatesInHeaders) {
   // Diagnostics from templates defined in headers are placed at the expansion.
   Annotations Main(R"cpp(
     Derived<int> [[y]]; // error-ok
   )cpp");
   Annotations Header(R"cpp(
     template <typename T>
     struct Derived : [[T]] {};
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.HeaderCode = Header.code().str();
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
       ElementsAre(AllOf(
           Diag(Main.range(), "in template: base specifier must name a class"),
           withNote(Diag(Header.range(), "error occurred here"),
                    Diag(Main.range(), "in instantiation of template class "
                                       "'Derived<int>' requested here")))));
 }
 
-TEST(DiagnosticTest, MakeUnique) {
+TEST_F(DiagnosticsTest, MakeUnique) {
   // We usually miss diagnostics from header functions as we don't parse them.
   // std::make_unique is an exception.
   Annotations Main(R"cpp(
     struct S { S(char*); };
     auto x = std::[[make_unique]]<S>(42); // error-ok
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.HeaderCode = R"cpp(
     namespace std {
     // These mocks aren't quite right - we omit unique_ptr for simplicity.
     // forward is included to show its body is not needed to get the diagnostic.
     template <typename T> T&& forward(T& t);
     template <typename T, typename... A> T* make_unique(A&&... args) {
        return new T(std::forward<A>(args)...);
     }
     }
   )cpp";
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(
                   Diag(Main.range(),
                        "in template: "
                        "no matching constructor for initialization of 'S'")));
 }
 
-TEST(DiagnosticTest, MakeShared) {
+TEST_F(DiagnosticsTest, MakeShared) {
   // We usually miss diagnostics from header functions as we don't parse them.
   // std::make_shared is only parsed when --parse-forwarding-functions is set
   Annotations Main(R"cpp(
     struct S { S(char*); };
     auto x = std::[[make_shared]]<S>(42); // error-ok
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.HeaderCode = R"cpp(
TEST_F(DiagnosticsTest, MakeShared) {
   TU.ParseOpts.PreambleParseForwardingFunctions = true;
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(
                   Diag(Main.range(),
                        "in template: "
                        "no matching constructor for initialization of 'S'")));
 }
 
-TEST(DiagnosticTest, NoMultipleDiagnosticInFlight) {
+TEST_F(DiagnosticsTest, NoMultipleDiagnosticInFlight) {
   Annotations Main(R"cpp(
     template <typename T> struct Foo {
       T *begin();
       T *end();
     };
     struct LabelInfo {
       int a;
       bool b;
TEST_F(DiagnosticsTest, NoMultipleDiagnosticInFlight) {
   TU.ClangTidyProvider = addTidyChecks("modernize-loop-convert");
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
       ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
           Diag(Main.range(), "use range-based for loop instead"),
           diagSource(Diag::ClangTidy), diagName("modernize-loop-convert")))));
 }
 
-TEST(DiagnosticTest, RespectsDiagnosticConfig) {
+TEST_F(DiagnosticsTest, RespectsDiagnosticConfig) {
   Annotations Main(R"cpp(
     // error-ok
     void x() {
       [[unknown]]();
       $ret[[return]] 42;
     }
   )cpp");
   auto TU = TestTU::withCode(Main.code());
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
       ElementsAre(Diag(Main.range(), "use of undeclared identifier 'unknown'"),
                   Diag(Main.range("ret"),
                        "void function 'x' should not return a value")));
   Config Cfg;
   Cfg.Diagnostics.Suppress.insert("return-type");
   WithContextValue WithCfg(Config::Key, std::move(Cfg));
   EXPECT_THAT(*TU.build().getDiagnostics(),
               ElementsAre(Diag(Main.range(),
                                "use of undeclared identifier 'unknown'")));
 }
 
-TEST(DiagnosticTest, RespectsDiagnosticConfigInHeader) {
+TEST_F(DiagnosticsTest, RespectsDiagnosticConfigInHeader) {
   Annotations Header(R"cpp(
     int x = "42";  // error-ok
   )cpp");
   Annotations Main(R"cpp(
     #include "header.hpp"
   )cpp");
   auto TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles["header.hpp"] = std::string(Header.code());
   Config Cfg;
   Cfg.Diagnostics.Suppress.insert("init_conversion_failed");
   WithContextValue WithCfg(Config::Key, std::move(Cfg));
   EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
 }
 
-TEST(DiagnosticTest, ClangTidySuppressionComment) {
+TEST_F(DiagnosticsTest, ClangTidySuppressionComment) {
   Annotations Main(R"cpp(
     int main() {
       int i = 3;
       double d = 8 / i;  // NOLINT
       // NOLINTNEXTLINE
       double e = 8 / i;
       #define BAD 8 / i
       double f = BAD;  // NOLINT
EXPECT_THAT(
       *TU.build().getDiagnostics(),
       ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
           Diag(Main.range(), "result of integer division used in a floating "
                              "point context; possible loss of precision"),
           diagSource(Diag::ClangTidy),
           diagName("bugprone-integer-division")))));
 }
 
-TEST(DiagnosticTest, ClangTidySystemMacro) {
+TEST_F(DiagnosticsTest, ClangTidySystemMacro) {
   Annotations Main(R"cpp(
     #include "user.h"
     #include "system.h"
     int i = 3;
     double x = $inline[[8]] / i;
     double y = $user[[DIVIDE_USER]](i);
     double z = DIVIDE_SYS(i);
   )cpp");
TEST_F(DiagnosticsTest, ClangTidySystemMacro) {
   // Expect to see warning from user macros, but not system macros.
   // This matches clang-tidy --system-headers=0 (the default).
   EXPECT_THAT(*TU.build().getDiagnostics(),
               ifTidyChecks(
                   UnorderedElementsAre(Diag(Main.range("inline"), BadDivision),
                                        Diag(Main.range("user"), BadDivision))));
 }
 
-TEST(DiagnosticTest, ClangTidyWarningAsError) {
+TEST_F(DiagnosticsTest, ClangTidyWarningAsError) {
   Annotations Main(R"cpp(
     int main() {
       int i = 3;
       double f = [[8]] / i; // error-ok
     }
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.ClangTidyProvider =
if (!Opts.ExtraArgs)
       Opts.ExtraArgs.emplace();
     for (llvm::StringRef Arg : ExtraArgs)
       Opts.ExtraArgs->emplace_back(Arg);
     if (!Checks.empty())
       Opts.Checks = Checks;
   };
 }
 
-TEST(DiagnosticTest, ClangTidyEnablesClangWarning) {
+TEST_F(DiagnosticsTest, ClangTidyEnablesClangWarning) {
   Annotations Main(R"cpp( // error-ok
     static void [[foo]]() {}
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
   // This is always emitted as a clang warning, not a clang-tidy diagnostic.
   auto UnusedFooWarning =
       AllOf(Diag(Main.range(), "unused function 'foo'"),
             diagName("-Wunused-function"), diagSource(Diag::Clang),
TEST_F(DiagnosticsTest, ClangTidyEnablesClangWarning) {
 
   // We do allow clang-tidy config to disable warnings from the compile
   // command. It's unclear this is ideal, but it's hard to avoid.
   TU.ExtraArgs = {"-Wunused"};
   TU.ClangTidyProvider = addClangArgs({"-Wno-unused"}, {});
   EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
 }
 
-TEST(DiagnosticTest, LongFixMessages) {
+TEST_F(DiagnosticsTest, LongFixMessages) {
   // We limit the size of printed code.
   Annotations Source(R"cpp(
     int main() {
       // error-ok
       int somereallyreallyreallyreallyreallyreallyreallyreallylongidentifier;
       [[omereallyreallyreallyreallyreallyreallyreallyreallylongidentifier]]= 10;
     }
   )cpp");
n]] = 10; // error-ok
     }
   )cpp");
   TU.Code = std::string(Source.code());
   EXPECT_THAT(*TU.build().getDiagnostics(),
               ElementsAre(withFix(
                   Fix(Source.range(), "ident", "change 'ide\\…' to 'ident'"))));
 }
 
-TEST(DiagnosticTest, NewLineFixMessage) {
+TEST_F(DiagnosticsTest, NewLineFixMessage) {
   Annotations Source("int a;[[]]");
   TestTU TU = TestTU::withCode(Source.code());
   TU.ExtraArgs = {"-Wnewline-eof"};
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
       ElementsAre(withFix((Fix(Source.range(), "\n", "insert '\\n'")))));
 }
 
-TEST(DiagnosticTest, ClangTidySuppressionCommentTrumpsWarningAsError) {
+TEST_F(DiagnosticsTest, ClangTidySuppressionCommentTrumpsWarningAsError) {
   Annotations Main(R"cpp(
     int main() {
       int i = 3;
       double f = [[8]] / i;  // NOLINT
     }
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.ClangTidyProvider =
       addTidyChecks("bugprone-integer-division", "bugprone-integer-division");
   EXPECT_THAT(*TU.build().getDiagnostics(), UnorderedElementsAre());
 }
 
-TEST(DiagnosticTest, ClangTidyNoLiteralDataInMacroToken) {
+TEST_F(DiagnosticsTest, ClangTidyNoLiteralDataInMacroToken) {
   Annotations Main(R"cpp(
     #define SIGTERM 15
     using pthread_t = int;
     int pthread_kill(pthread_t thread, int sig);
     int func() {
       pthread_t thread;
       return pthread_kill(thread, 0);
     }
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.ClangTidyProvider = addTidyChecks("bugprone-bad-signal-to-kill-thread");
   EXPECT_THAT(*TU.build().getDiagnostics(), UnorderedElementsAre()); // no-crash
 }
 
-TEST(DiagnosticTest, ElseAfterReturnRange) {
+TEST_F(DiagnosticsTest, ElseAfterReturnRange) {
   Annotations Main(R"cpp(
     int foo(int cond) {
     if (cond == 1) {
       return 42;
     } [[else]] if (cond == 2) {
       return 43;
     }
     return 44;
     }
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.ClangTidyProvider = addTidyChecks("llvm-else-after-return");
   EXPECT_THAT(*TU.build().getDiagnostics(),
               ifTidyChecks(ElementsAre(
                   Diag(Main.range(), "do not use 'else' after 'return'"))));
 }
 
-TEST(DiagnosticTest, ClangTidySelfContainedDiags) {
+TEST_F(DiagnosticsTest, ClangTidySelfContainedDiags) {
   Annotations Main(R"cpp($MathHeader[[]]
     struct Foo{
       int A, B;
       Foo()$Fix[[]] {
         $A[[A = 1;]]
         $B[[B = 1;]]
       }
     };
EXPECT_THAT(
                                       "initializer of the constructor"),
                 withFix(equalToFix(ExpectedBFix))),
           AllOf(Diag(Main.range("C"), "variable 'C' is not initialized"),
                 withFix(equalToFix(ExpectedCFix))),
           AllOf(Diag(Main.range("D"), "variable 'D' is not initialized"),
                 withFix(equalToFix(ExpectedDFix))))));
 }
 
-TEST(DiagnosticsTest, Preprocessor) {
+TEST_F(DiagnosticsTest, Preprocessor) {
   // This looks like a preamble, but there's an #else in the middle!
   // Check that:
   //  - the #else doesn't generate diagnostics (we had this bug)
   //  - we get diagnostics from the taken branch
   //  - we get no diagnostics from the not taken branch
   Annotations Test(R"cpp(
     #ifndef FOO
     #define FOO
       int a = [[b]]; // error-ok
     #else
       int x = y;
     #endif
     )cpp");
   EXPECT_THAT(
       *TestTU::withCode(Test.code()).build().getDiagnostics(),
       ElementsAre(Diag(Test.range(), "use of undeclared identifier 'b'")));
 }
 
-TEST(DiagnosticsTest, IgnoreVerify) {
+TEST_F(DiagnosticsTest, IgnoreVerify) {
   auto TU = TestTU::withCode(R"cpp(
     int a; // expected-error {{}}
   )cpp");
   TU.ExtraArgs.push_back("-Xclang");
   TU.ExtraArgs.push_back("-verify");
   EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
 }
 
-TEST(DiagnosticTest, IgnoreBEFilelistOptions) {
+TEST_F(DiagnosticsTest, IgnoreBEFilelistOptions) {
   auto TU = TestTU::withCode("");
   TU.ExtraArgs.push_back("-Xclang");
   for (const auto *DisableOption :
        {"-fsanitize-ignorelist=null", "-fprofile-list=null",
         "-fxray-always-instrument=null", "-fxray-never-instrument=null",
         "-fxray-attr-list=null"}) {
     TU.ExtraArgs.push_back(DisableOption);
     EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
     TU.ExtraArgs.pop_back();
   }
 }
 
 // Recursive main-file include is diagnosed, and doesn't crash.
-TEST(DiagnosticsTest, RecursivePreamble) {
+TEST_F(DiagnosticsTest, RecursivePreamble) {
   auto TU = TestTU::withCode(R"cpp(
     #include "foo.h" // error-ok
     int symbol;
   )cpp");
   TU.Filename = "foo.h";
   EXPECT_THAT(*TU.build().getDiagnostics(),
               ElementsAre(diagName("pp_including_mainfile_in_preamble")));
   EXPECT_THAT(TU.build().getLocalTopLevelDecls(), SizeIs(1));
 }
 
 // Recursive main-file include with #pragma once guard is OK.
-TEST(DiagnosticsTest, RecursivePreamblePragmaOnce) {
+TEST_F(DiagnosticsTest, RecursivePreamblePragmaOnce) {
   auto TU = TestTU::withCode(R"cpp(
     #pragma once
     #include "foo.h"
     int symbol;
   )cpp");
   TU.Filename = "foo.h";
   EXPECT_THAT(*TU.build().getDiagnostics(),
               Not(Contains(diagName("pp_including_mainfile_in_preamble"))));
   EXPECT_THAT(TU.build().getLocalTopLevelDecls(), SizeIs(1));
 }
 
 // Recursive main-file include with #ifndef guard should be OK.
 // However, it's not yet recognized (incomplete at end of preamble).
-TEST(DiagnosticsTest, RecursivePreambleIfndefGuard) {
+TEST_F(DiagnosticsTest, RecursivePreambleIfndefGuard) {
   auto TU = TestTU::withCode(R"cpp(
     #ifndef FOO
     #define FOO
     #include "foo.h" // error-ok
     int symbol;
     #endif
   )cpp");
   TU.Filename = "foo.h";
   // FIXME: should be no errors here.
   EXPECT_THAT(*TU.build().getDiagnostics(),
               ElementsAre(diagName("pp_including_mainfile_in_preamble")));
   EXPECT_THAT(TU.build().getLocalTopLevelDecls(), SizeIs(1));
 }
 
-TEST(DiagnosticsTest, PreambleWithPragmaAssumeNonnull) {
+TEST_F(DiagnosticsTest, PreambleWithPragmaAssumeNonnull) {
   auto TU = TestTU::withCode(R"cpp(
 #pragma clang assume_nonnull begin
 void foo(int *x);
 #pragma clang assume_nonnull end
 )cpp");
   auto AST = TU.build();
   EXPECT_THAT(*AST.getDiagnostics(), IsEmpty());
   const auto *X = cast<FunctionDecl>(findDecl(AST, "foo")).getParamDecl(0);
   ASSERT_TRUE(X->getOriginalType()->getNullability() ==
               NullabilityKind::NonNull);
 }
 
-TEST(DiagnosticsTest, PreambleHeaderWithBadPragmaAssumeNonnull) {
+TEST_F(DiagnosticsTest, PreambleHeaderWithBadPragmaAssumeNonnull) {
   Annotations Header(R"cpp(
 #pragma clang assume_nonnull begin  // error-ok
 void foo(int *X);
 )cpp");
   auto TU = TestTU::withCode(R"cpp(
 #include "foo.h"  // unterminated assume_nonnull should not affect bar.
 void bar(int *Y);
 )cpp");
   TU.AdditionalFiles = {{"foo.h", std::string(Header.code())}};
   auto AST = TU.build();
   EXPECT_THAT(*AST.getDiagnostics(),
               ElementsAre(diagName("pp_eof_in_assume_nonnull")));
   const auto *X = cast<FunctionDecl>(findDecl(AST, "foo")).getParamDecl(0);
   ASSERT_TRUE(X->getOriginalType()->getNullability() ==
               NullabilityKind::NonNull);
   const auto *Y = cast<FunctionDecl>(findDecl(AST, "bar")).getParamDecl(0);
   ASSERT_FALSE(Y->getOriginalType()->getNullability());
 }
 
-TEST(DiagnosticsTest, InsideMacros) {
+TEST_F(DiagnosticsTest, InsideMacros) {
   Annotations Test(R"cpp(
     #define TEN 10
     #define RET(x) return x + 10
 
     int* foo() {
       RET($foo[[0]]); // error-ok
     }
     int* bar() {
       return $bar[[TEN]];
     }
     )cpp");
   EXPECT_THAT(*TestTU::withCode(Test.code()).build().getDiagnostics(),
               ElementsAre(Diag(Test.range("foo"),
                                "cannot initialize return object of type "
                                "'int *' with an rvalue of type 'int'"),
                           Diag(Test.range("bar"),
                                "cannot initialize return object of type "
                                "'int *' with an rvalue of type 'int'")));
 }
 
-TEST(DiagnosticsTest, NoFixItInMacro) {
+TEST_F(DiagnosticsTest, NoFixItInMacro) {
   Annotations Test(R"cpp(
     #define Define(name) void name() {}
 
     [[Define]](main) // error-ok
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   EXPECT_THAT(*TU.build().getDiagnostics(),
               ElementsAre(AllOf(Diag(Test.range(), "'main' must return 'int'"),
                                 Not(withFix(_)))));
 }
 
-TEST(DiagnosticsTest, PragmaSystemHeader) {
+TEST_F(DiagnosticsTest, PragmaSystemHeader) {
   Annotations Test("#pragma clang [[system_header]]\n");
   auto TU = TestTU::withCode(Test.code());
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
       ElementsAre(AllOf(
           Diag(Test.range(), "#pragma system_header ignored in main file"))));
   TU.Filename = "TestTU.h";
   EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
 }
 
-TEST(ClangdTest, MSAsm) {
+TEST_F(DiagnosticsTest, MSAsm) {
   // Parsing MS assembly tries to use the target MCAsmInfo, which we don't link.
   // We used to crash here. Now clang emits a diagnostic, which we filter out.
   llvm::InitializeAllTargetInfos(); // As in ClangdMain
   auto TU = TestTU::withCode("void fn() { __asm { cmp cl,64 } }");
   TU.ExtraArgs = {"-fms-extensions"};
   EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
 }
 
-TEST(DiagnosticsTest, ToLSP) {
+TEST_F(DiagnosticsTest, ToLSP) {
   URIForFile MainFile =
       URIForFile::canonicalize(testPath("foo/bar/main.cpp"), "");
   URIForFile HeaderFile =
       URIForFile::canonicalize(testPath("foo/bar/header.h"), "");
 
   clangd::Diag D;
   D.ID = clang::diag::err_undeclared_var_use;
   D.Tags = {DiagnosticTag::Unnecessary};
for (const auto &S : Syms) {
     Sym.CanonicalDeclaration.FileURI = S.DeclaringFile.c_str();
     Sym.Definition.FileURI = S.DeclaringFile.c_str();
     Sym.IncludeHeaders.emplace_back(S.IncludeHeader, 1, Symbol::Include);
     Slab.insert(Sym);
   }
   return MemIndex::build(std::move(Slab).build(), RefSlab(), RelationSlab());
 }
 
-TEST(IncludeFixerTest, IncompleteType) {
+TEST_F(DiagnosticsTest, IncludeFixerIncompleteType) {
   auto TU = TestTU::withHeaderCode("namespace ns { class X; } ns::X *x;");
   TU.ExtraArgs.push_back("-std=c++20");
   auto Index = buildIndexWithSymbol(
       {SymbolWithHeader{"ns::X", "unittest:///x.h", "\"x.h\""}});
   TU.ExternalIndex = Index.get();
 
   std::vector<std::pair<llvm::StringRef, llvm::StringRef>> Tests{
       {"incomplete_nested_name_spec", "[[ns::X::]]Nested n;"},
EXPECT_THAT(
         *TU.build().getDiagnostics(),
         ElementsAre(AllOf(diagName(Case.first), hasRange(Main.range()),
                           withFix(Fix(Range{}, "#include \"x.h\"\n",
                                       "Include \"x.h\" for symbol ns::X")))))
         << Case.second;
   }
 }
 
-TEST(IncludeFixerTest, IncompleteEnum) {
+TEST_F(DiagnosticsTest, IncludeFixerIncompleteEnum) {
   Symbol Sym = enm("X");
   Sym.Flags |= Symbol::IndexedForCodeCompletion;
   Sym.CanonicalDeclaration.FileURI = Sym.Definition.FileURI = "unittest:///x.h";
   Sym.IncludeHeaders.emplace_back("\"x.h\"", 1, Symbol::Include);
   SymbolSlab::Builder Slab;
   Slab.insert(Sym);
   auto Index =
       MemIndex::build(std::move(Slab).build(), RefSlab(), RelationSlab());
for (auto Case : Tests) {
     EXPECT_THAT(*TU.build().getDiagnostics(),
                 Contains(AllOf(diagName(Case.first), hasRange(Main.range()),
                                withFix(Fix(Range{}, "#include \"x.h\"\n",
                                            "Include \"x.h\" for symbol X")))))
         << Case.second;
   }
 }
 
-TEST(IncludeFixerTest, NoSuggestIncludeWhenNoDefinitionInHeader) {
+TEST_F(DiagnosticsTest, IncludeFixerNoSuggestIncludeWhenNoDefinitionInHeader) {
   Annotations Test(R"cpp(// error-ok
 $insert[[]]namespace ns {
   class X;
 }
 class Y : $base[[public ns::X]] {};
 int main() {
   ns::X *x;
   x$access[[->]]f();
int main() {
 
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(
                   Diag(Test.range("base"), "base class has incomplete type"),
                   Diag(Test.range("access"),
                        "member access into incomplete type 'ns::X'")));
 }
 
-TEST(IncludeFixerTest, Typo) {
+TEST_F(DiagnosticsTest, IncludeFixerTypo) {
   Annotations Test(R"cpp(// error-ok
 $insert[[]]namespace ns {
 void foo() {
   $unqualified1[[X]] x;
   // No fix if the unresolved type is used as specifier. (ns::)X::Nested will be
   // considered the unresolved type.
   $unqualified2[[X]]::Nested n;
 }
EXPECT_THAT(
                 withFix(Fix(Test.range("insert"), "#include \"foo.h\"\n",
                             "Include \"foo.h\" for symbol ns::Foo"))),
           AllOf(Diag(Test.range("base"), "expected class name"),
                 diagName("expected_class_name"),
                 withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                             "Include \"x.h\" for symbol ns::X")))));
 }
 
-TEST(IncludeFixerTest, TypoInMacro) {
+TEST_F(DiagnosticsTest, IncludeFixerTypoInMacro) {
   auto TU = TestTU::withCode(R"cpp(// error-ok
 #define ID(T) T
 X a1;
 ID(X a2);
 ns::X a3;
 ID(ns::X a4);
 namespace ns{};
 ns::X a5;
 ID(ns::X a6);
 )cpp");
   auto Index = buildIndexWithSymbol(
       {SymbolWithHeader{"X", "unittest:///x.h", "\"x.h\""},
        SymbolWithHeader{"ns::X", "unittest:///ns.h", "\"x.h\""}});
   TU.ExternalIndex = Index.get();
   // FIXME: -fms-compatibility (which is default on windows) breaks the
   // ns::X cases when the namespace is undeclared. Find out why!
   TU.ExtraArgs = {"-fno-ms-compatibility"};
   EXPECT_THAT(*TU.build().getDiagnostics(), Each(withFix(_)));
 }
 
-TEST(IncludeFixerTest, MultipleMatchedSymbols) {
+TEST_F(DiagnosticsTest, IncludeFixerMultipleMatchedSymbols) {
   Annotations Test(R"cpp(// error-ok
 $insert[[]]namespace na {
 namespace nb {
 void foo() {
   $unqualified[[X]] x;
 }
 }
 }
EXPECT_THAT(*TU.build().getDiagnostics(),
                   Diag(Test.range("unqualified"), "unknown type name 'X'"),
                   diagName("unknown_typename"),
                   withFix(Fix(Test.range("insert"), "#include \"a.h\"\n",
                               "Include \"a.h\" for symbol na::X"),
                           Fix(Test.range("insert"), "#include \"b.h\"\n",
                               "Include \"b.h\" for symbol na::nb::X")))));
 }
 
-TEST(IncludeFixerTest, NoCrashMemberAccess) {
+TEST_F(DiagnosticsTest, IncludeFixerNoCrashMemberAccess) {
   Annotations Test(R"cpp(// error-ok
     struct X { int  xyz; };
     void g() { X x; x.$[[xy]]; }
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   auto Index = buildIndexWithSymbol(
       SymbolWithHeader{"na::X", "unittest:///a.h", "\"a.h\""});
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
       UnorderedElementsAre(Diag(Test.range(), "no member named 'xy' in 'X'")));
 }
 
-TEST(IncludeFixerTest, UseCachedIndexResults) {
+TEST_F(DiagnosticsTest, IncludeFixerUseCachedIndexResults) {
   // As index results for the identical request are cached, more than 5 fixes
   // are generated.
   Annotations Test(R"cpp(// error-ok
 $insert[[]]void foo() {
   $x1[[X]] x;
   $x2[[X]] x;
   $x3[[X]] x;
   $x4[[X]] x;
for (const auto &D : *Parsed.getDiagnostics()) {
     if (D.Fixes.size() != 1) {
       ADD_FAILURE() << "D.Fixes.size() != 1";
       continue;
     }
     EXPECT_EQ(D.Fixes[0].Message, std::string("Include \"a.h\" for symbol X"));
   }
 }
 
-TEST(IncludeFixerTest, UnresolvedNameAsSpecifier) {
+TEST_F(DiagnosticsTest, IncludeFixerUnresolvedNameAsSpecifier) {
   Annotations Test(R"cpp(// error-ok
 $insert[[]]namespace ns {
 }
 void g() {  ns::$[[scope]]::X_Y();  }
   )cpp");
   TestTU TU;
   TU.Code = std::string(Test.code());
   // FIXME: Figure out why this is needed and remove it, PR43662.
   TU.ExtraArgs.push_back("-fno-ms-compatibility");
   auto Index = buildIndexWithSymbol(
       SymbolWithHeader{"ns::scope::X_Y", "unittest:///x.h", "\"x.h\""});
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
       UnorderedElementsAre(
           AllOf(Diag(Test.range(), "no member named 'scope' in namespace 'ns'"),
                 diagName("no_member"),
                 withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                             "Include \"x.h\" for symbol ns::scope::X_Y")))));
 }
 
-TEST(IncludeFixerTest, UnresolvedSpecifierWithSemaCorrection) {
+TEST_F(DiagnosticsTest, IncludeFixerUnresolvedSpecifierWithSemaCorrection) {
   Annotations Test(R"cpp(// error-ok
 $insert[[]]namespace clang {
 void f() {
   // "clangd::" will be corrected to "clang::" by Sema.
   $q1[[clangd]]::$x[[X]] x;
   $q2[[clangd]]::$ns[[ns]]::Y y;
 }
 }
EXPECT_THAT(
           AllOf(Diag(Test.range("ns"),
                      "no member named 'ns' in namespace 'clang'"),
                 diagName("no_member"),
                 withFix(
                     Fix(Test.range("insert"), "#include \"y.h\"\n",
                         "Include \"y.h\" for symbol clang::clangd::ns::Y")))));
 }
 
-TEST(IncludeFixerTest, SpecifiedScopeIsNamespaceAlias) {
+TEST_F(DiagnosticsTest, IncludeFixerSpecifiedScopeIsNamespaceAlias) {
   Annotations Test(R"cpp(// error-ok
 $insert[[]]namespace a {}
 namespace b = a;
 namespace c {
   b::$[[X]] x;
 }
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   auto Index = buildIndexWithSymbol(
       SymbolWithHeader{"a::X", "unittest:///x.h", "\"x.h\""});
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(AllOf(
                   Diag(Test.range(), "no type named 'X' in namespace 'a'"),
                   diagName("typename_nested_not_found"),
                   withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                               "Include \"x.h\" for symbol a::X")))));
 }
 
-TEST(IncludeFixerTest, NoCrashOnTemplateInstantiations) {
+TEST_F(DiagnosticsTest, IncludeFixerNoCrashOnTemplateInstantiations) {
   Annotations Test(R"cpp(
     template <typename T> struct Templ {
       template <typename U>
       typename U::type operator=(const U &);
     };
 
     struct A {
       Templ<char> s;
       A() { [[a]]; /*error-ok*/ } // crash if we compute scopes lazily.
     };
   )cpp");
 
   auto TU = TestTU::withCode(Test.code());
   auto Index = buildIndexWithSymbol({});
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
       ElementsAre(Diag(Test.range(), "use of undeclared identifier 'a'")));
 }
 
-TEST(IncludeFixerTest, HeaderNamedInDiag) {
+TEST_F(DiagnosticsTest, IncludeFixerHeaderNamedInDiag) {
   Annotations Test(R"cpp(
     $insert[[]]int main() {
       [[printf]]("");
     }
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   TU.ExtraArgs = {"-xc", "-std=c99",
                   "-Wno-error=implicit-function-declaration"};
EXPECT_THAT(
       *TU.build().getDiagnostics(),
       ElementsAre(AllOf(
           Diag(Test.range(), "implicitly declaring library function 'printf' "
                              "with type 'int (const char *, ...)'"),
           withFix(Fix(Test.range("insert"), "#include <stdio.h>\n",
                       "Include <stdio.h> for symbol printf")))));
 }
 
-TEST(IncludeFixerTest, CImplicitFunctionDecl) {
+TEST_F(DiagnosticsTest, IncludeFixerCImplicitFunctionDecl) {
   Annotations Test("void x() { [[foo]](); }");
   auto TU = TestTU::withCode(Test.code());
   TU.Filename = "test.c";
   TU.ExtraArgs = {"-std=c99", "-Wno-error=implicit-function-declaration"};
 
   Symbol Sym = func("foo");
   Sym.Flags |= Symbol::IndexedForCodeCompletion;
   Sym.CanonicalDeclaration.FileURI = "unittest:///foo.h";
TEST_F(DiagnosticsTest, IncludeFixerCImplicitFunctionDecl) {
   TU.ExtraArgs = {"-std=c89", "-Wall"};
   EXPECT_THAT(*TU.build().getDiagnostics(),
               ElementsAre(AllOf(
                   Diag(Test.range(), "implicit declaration of function 'foo'"),
                   withFix(Fix(Range{}, "#include \"foo.h\"\n",
                               "Include \"foo.h\" for symbol foo")))));
 }
 
-TEST(DiagsInHeaders, DiagInsideHeader) {
+TEST_F(DiagnosticsTest, DiagInsideHeader) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     void foo() {})cpp");
   Annotations Header("[[no_type_spec]]; // error-ok");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", std::string(Header.code())}};
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(AllOf(
                   Diag(Main.range(), "in included file: a type specifier is "
                                      "required for all declarations"),
                   withNote(Diag(Header.range(), "error occurred here")))));
 }
 
-TEST(DiagsInHeaders, DiagInTransitiveInclude) {
+TEST_F(DiagnosticsTest, DiagInTransitiveInclude) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     void foo() {})cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", "#include \"b.h\""},
                         {"b.h", "no_type_spec; // error-ok"}};
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(Diag(Main.range(),
                                         "in included file: a type specifier is "
                                         "required for all declarations")));
 }
 
-TEST(DiagsInHeaders, DiagInMultipleHeaders) {
+TEST_F(DiagnosticsTest, DiagInMultipleHeaders) {
   Annotations Main(R"cpp(
     #include $a[["a.h"]]
     #include $b[["b.h"]]
     void foo() {})cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", "no_type_spec; // error-ok"},
                         {"b.h", "no_type_spec; // error-ok"}};
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(
                   Diag(Main.range("a"), "in included file: a type specifier is "
                                         "required for all declarations"),
                   Diag(Main.range("b"), "in included file: a type specifier is "
                                         "required for all declarations")));
 }
 
-TEST(DiagsInHeaders, PreferExpansionLocation) {
+TEST_F(DiagnosticsTest, PreferExpansionLocation) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     #include "b.h"
     void foo() {})cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {
       {"a.h", "#include \"b.h\"\n"},
       {"b.h", "#ifndef X\n#define X\nno_type_spec; // error-ok\n#endif"}};
   EXPECT_THAT(*TU.build().getDiagnostics(),
               Contains(Diag(Main.range(), "in included file: a type specifier "
                                           "is required for all declarations")));
 }
 
-TEST(DiagsInHeaders, PreferExpansionLocationMacros) {
+TEST_F(DiagnosticsTest, PreferExpansionLocationMacros) {
   Annotations Main(R"cpp(
     #define X
     #include "a.h"
     #undef X
     #include [["b.h"]]
     void foo() {})cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {
       {"a.h", "#include \"c.h\"\n"},
       {"b.h", "#include \"c.h\"\n"},
       {"c.h", "#ifndef X\n#define X\nno_type_spec; // error-ok\n#endif"}};
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(Diag(Main.range(),
                                         "in included file: a type specifier is "
                                         "required for all declarations")));
 }
 
-TEST(DiagsInHeaders, LimitDiagsOutsideMainFile) {
+TEST_F(DiagnosticsTest, LimitDiagsOutsideMainFile) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     #include "b.h"
     void foo() {})cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", "#include \"c.h\"\n"},
                         {"b.h", "#include \"c.h\"\n"},
                         {"c.h", R"cpp(
TU.AdditionalFiles = {{"a.h", "#include \"c.h\"\n"},
       no_type_spec_10;
       #endif)cpp"}};
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(Diag(Main.range(),
                                         "in included file: a type specifier is "
                                         "required for all declarations")));
 }
 
-TEST(DiagsInHeaders, OnlyErrorOrFatal) {
+TEST_F(DiagnosticsTest, OnlyErrorOrFatal) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     void foo() {})cpp");
   Annotations Header(R"cpp(
     [[no_type_spec]]; // error-ok
     int x = 5/0;)cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", std::string(Header.code())}};
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(AllOf(
                   Diag(Main.range(), "in included file: a type specifier is "
                                      "required for all declarations"),
                   withNote(Diag(Header.range(), "error occurred here")))));
 }
 
-TEST(DiagsInHeaders, OnlyDefaultErrorOrFatal) {
+TEST_F(DiagnosticsTest, OnlyDefaultErrorOrFatal) {
   Annotations Main(R"cpp(
     #include [["a.h"]] // get unused "foo" warning when building preamble.
     )cpp");
   Annotations Header(R"cpp(
     namespace { void foo() {} }
     void func() {foo();} ;)cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", std::string(Header.code())}};
   // promote warnings to errors.
   TU.ExtraArgs = {"-Werror", "-Wunused"};
   EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
 }
 
-TEST(DiagsInHeaders, FromNonWrittenSources) {
+TEST_F(DiagnosticsTest, FromNonWrittenSources) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     void foo() {})cpp");
   Annotations Header(R"cpp(
     int x = 5/0;
     int b = [[FOO]]; // error-ok)cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", std::string(Header.code())}};
   TU.ExtraArgs = {"-DFOO=NOOO"};
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(AllOf(
                   Diag(Main.range(),
                        "in included file: use of undeclared identifier 'NOOO'"),
                   withNote(Diag(Header.range(), "error occurred here")))));
 }
 
-TEST(DiagsInHeaders, ErrorFromMacroExpansion) {
+TEST_F(DiagnosticsTest, ErrorFromMacroExpansion) {
   Annotations Main(R"cpp(
   void bar() {
     int fo; // error-ok
     #include [["a.h"]]
   })cpp");
   Annotations Header(R"cpp(
   #define X foo
   X;)cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", std::string(Header.code())}};
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(
                   Diag(Main.range(), "in included file: use of undeclared "
                                      "identifier 'foo'; did you mean 'fo'?")));
 }
 
-TEST(DiagsInHeaders, ErrorFromMacroArgument) {
+TEST_F(DiagnosticsTest, ErrorFromMacroArgument) {
   Annotations Main(R"cpp(
   void bar() {
     int fo; // error-ok
     #include [["a.h"]]
   })cpp");
   Annotations Header(R"cpp(
   #define X(arg) arg
   X(foo);)cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", std::string(Header.code())}};
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(
                   Diag(Main.range(), "in included file: use of undeclared "
                                      "identifier 'foo'; did you mean 'fo'?")));
 }
 
-TEST(IgnoreDiags, FromNonWrittenInclude) {
+TEST_F(DiagnosticsTest, FromNonWrittenInclude) {
   TestTU TU;
   TU.ExtraArgs.push_back("--include=a.h");
   TU.AdditionalFiles = {{"a.h", "void main();"}};
   // The diagnostic "main must return int" is from the header, we don't attempt
   // to render it in the main file as there is no written location there.
   EXPECT_THAT(*TU.build().getDiagnostics(), UnorderedElementsAre());
 }
 
-TEST(ToLSPDiag, RangeIsInMain) {
+TEST_F(DiagnosticsTest, RangeIsInMain) {
   ClangdDiagnosticOptions Opts;
   clangd::Diag D;
   D.Range = {pos(1, 2), pos(3, 4)};
   D.Notes.emplace_back();
   Note &N = D.Notes.back();
   N.Range = {pos(2, 3), pos(3, 4)};
 
   D.InsideMainFile = true;
   N.InsideMainFile = false;
   toLSPDiags(D, {}, Opts,
              [&](clangd::Diagnostic LSPDiag, ArrayRef<clangd::Fix>) {
                EXPECT_EQ(LSPDiag.range, D.Range);
              });
 
   D.InsideMainFile = false;
   N.InsideMainFile = true;
   toLSPDiags(D, {}, Opts,
              [&](clangd::Diagnostic LSPDiag, ArrayRef<clangd::Fix>) {
                EXPECT_EQ(LSPDiag.range, N.Range);
              });
 }
 
-TEST(ParsedASTTest, ModuleSawDiag) {
+TEST_F(DiagnosticsTest, ModuleSawDiag) {
   static constexpr const llvm::StringLiteral KDiagMsg = "StampedDiag";
   struct DiagModifierModule final : public FeatureModule {
     struct Listener : public FeatureModule::ASTListener {
       void sawDiagnostic(const clang::Diagnostic &Info,
                          clangd::Diag &Diag) override {
         Diag.Message = KDiagMsg.str();
       }
     };
TEST_F(DiagnosticsTest, ModuleSawDiag) {
   TU.Code = Code.code().str();
   TU.FeatureModules = &FMS;
 
   auto AST = TU.build();
   EXPECT_THAT(*AST.getDiagnostics(),
               testing::Contains(Diag(Code.range(), KDiagMsg.str())));
 }
 
-TEST(Preamble, EndsOnNonEmptyLine) {
+TEST_F(DiagnosticsTest, EndsOnNonEmptyLine) {
   TestTU TU;
   TU.ExtraArgs = {"-Wnewline-eof"};
 
   {
     TU.Code = "#define FOO\n  void bar();\n";
     auto AST = TU.build();
     EXPECT_THAT(*AST.getDiagnostics(), IsEmpty());
   }
   {
     Annotations Code("#define FOO[[]]");
     TU.Code = Code.code().str();
     auto AST = TU.build();
     EXPECT_THAT(
         *AST.getDiagnostics(),
         testing::Contains(Diag(Code.range(), "no newline at end of file")));
   }
 }
 
-TEST(Diagnostics, Tags) {
+TEST_F(DiagnosticsTest, Tags) {
   TestTU TU;
   TU.ExtraArgs = {"-Wunused", "-Wdeprecated"};
   Annotations Test(R"cpp(
   void bar() __attribute__((deprecated));
   void foo() {
     int $unused[[x]];
     $deprecated[[bar]]();
   })cpp");
TEST_F(DiagnosticsTest, Tags) {
   TU.ClangTidyProvider = addTidyChecks("modernize-use-using");
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
       ifTidyChecks(UnorderedElementsAre(
           AllOf(Diag(Test.range("typedef"), "use 'using' instead of 'typedef'"),
                 withTag(DiagnosticTag::Deprecated)))));
 }
 
-TEST(DiagnosticsTest, IncludeCleaner) {
+TEST_F(DiagnosticsTest, IncludeCleaner) {
   Annotations Test(R"cpp(
 $fix[[  $diag[[#include "unused.h"]]
 ]]
   #include "used.h"
 
   #include "ignore.h"
 
   #include <system_header.h>
]]
   WithContextValue SuppressAllWithCfg(Config::Key, std::move(Cfg));
   EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
   Cfg.Diagnostics.SuppressAll = false;
   Cfg.Diagnostics.Suppress = {"unused-includes"};
   WithContextValue SuppressFilterWithCfg(Config::Key, std::move(Cfg));
   EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
 }
 
-TEST(DiagnosticsTest, FixItFromHeader) {
+TEST_F(DiagnosticsTest, FixItFromHeader) {
   llvm::StringLiteral Header(R"cpp(
     void foo(int *);
     void foo(int *, int);)cpp");
   Annotations Source(R"cpp(
   /*error-ok*/
     void bar() {
       int x;
       $diag[[foo]]($fix[[]]x, 1);
     })cpp");
   TestTU TU;
   TU.Code = Source.code().str();
   TU.HeaderCode = Header.str();
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
       UnorderedElementsAre(AllOf(
           Diag(Source.range("diag"), "no matching function for call to 'foo'"),
           withFix(Fix(Source.range("fix"), "&",
                       "candidate function not viable: no known conversion from "
                       "'int' to 'int *' for 1st argument; take the address of "
                       "the argument with &")))));
 }
 
-TEST(DiagnosticsTest, UnusedInHeader) {
+TEST_F(DiagnosticsTest, UnusedInHeader) {
   // Clang diagnoses unused static inline functions outside headers.
   auto TU = TestTU::withCode("static inline void foo(void) {}");
   TU.ExtraArgs.push_back("-Wunused-function");
   TU.Filename = "test.c";
   EXPECT_THAT(*TU.build().getDiagnostics(),
               ElementsAre(withID(diag::warn_unused_function)));
   // Sema should recognize a *.h file open in clangd as a header.
   // https://github.com/clangd/vscode-clangd/issues/360
   TU.Filename = "test.h";
   EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang