[clang][dataflow] Replace TEST_F with TEST where possible

[samestep]

Summary

Many of our tests are currently written using TEST_F where the test fixture class doesn't have any SetUp or TearDown methods, and just one helper method. In those cases, this patch deletes the class and pulls its method out into a standalone function, using TEST instead of TEST_F.

There are still a few test files leftover in clang/unittests/Analysis/FlowSensitive/ that use TEST_F:

• DataflowAnalysisContextTest.cpp because the class contains a Context field which is used
• DataflowEnvironmentTest.cpp because the class contains an Environment field which is used
• SolverTest.cpp because the class contains a Vals field which is used
• TypeErasedDataflowAnalysisTest.cpp because there are several different classes which all share the same method name

[ymandel]

Thanks!

[sgatev]

Thanks!

clang/unittests/Analysis/FlowSensitive/ChromiumCheckModelTest.cpp

public:
   void transfer(const Stmt *S, NoopLattice &, Environment &Env) {
     M.transfer(S, Env);
   }
 
 private:
   Model M;
 };
 
-class ChromiumCheckModelTest : public ::testing::TestWithParam<std::string> {
-protected:
-  template <typename Matcher>
-  void runDataflow(llvm::StringRef Code, Matcher Match) {
-    const tooling::FileContentMappings FileContents = {
-        {"check.h", ChromiumCheckHeader}, {"othercheck.h", OtherCheckHeader}};
 
-    ASSERT_THAT_ERROR(
-        test::checkDataflow<ModelAdaptorAnalysis<ChromiumCheckModel>>(
-            Code, "target",
-            [](ASTContext &C, Environment &) {
-              return ModelAdaptorAnalysis<ChromiumCheckModel>(C);
-            },
-            [&Match](
-                llvm::ArrayRef<
-                    std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
-                    Results,
-                ASTContext &ASTCtx) { Match(Results, ASTCtx); },
-            {"-fsyntax-only", "-fno-delayed-template-parsing", "-std=c++17"},
-            FileContents),
-        llvm::Succeeded());
-  }
-};
 
-TEST_F(ChromiumCheckModelTest, CheckSuccessImpliesConditionHolds) {
+TEST(ChromiumCheckModelTest, CheckSuccessImpliesConditionHolds) {
   auto Expectations =
       [](llvm::ArrayRef<
              std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
              Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results, ElementsAre(Pair("p", _)));
         const Environment &Env = Results[0].second.Env;
 
std::string Code = R"(
     }
   )";
   runDataflow(ReplacePattern(Code, "$check", "CHECK"), Expectations);
   runDataflow(ReplacePattern(Code, "$check", "DCHECK"), Expectations);
   runDataflow(ReplacePattern(Code, "$check", "PCHECK"), Expectations);
   runDataflow(ReplacePattern(Code, "$check", "DPCHECK"), Expectations);
 }
 
-TEST_F(ChromiumCheckModelTest, UnrelatedCheckIgnored) {
+TEST(ChromiumCheckModelTest, UnrelatedCheckIgnored) {
   auto Expectations =
       [](llvm::ArrayRef<
              std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
              Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results, ElementsAre(Pair("p", _)));
         const Environment &Env = Results[0].second.Env;
 

clang/unittests/Analysis/FlowSensitive/MatchSwitchTest.cpp

public:
   static BooleanLattice initialElement() { return BooleanLattice::bottom(); }
 
   void transfer(const Stmt *S, BooleanLattice &L, Environment &Env) {
     TransferState<BooleanLattice> State(L, Env);
     TransferSwitch(*S, getASTContext(), State);
   }
 };
 
-class MatchSwitchTest : public ::testing::Test {
-protected:
-  template <typename Matcher>
-  void RunDataflow(llvm::StringRef Code, Matcher Expectations) {
-    ASSERT_THAT_ERROR(
-        test::checkDataflow<TestAnalysis>(
-            Code, "fun",
-            [](ASTContext &C, Environment &) { return TestAnalysis(C); },
-            [&Expectations](
-                llvm::ArrayRef<std::pair<
-                    std::string, DataflowAnalysisState<TestAnalysis::Lattice>>>
-                    Results,
-                ASTContext &) { EXPECT_THAT(Results, Expectations); },
-            {"-fsyntax-only", "-std=c++17"}),
-        llvm::Succeeded());
-  }
-};
 
-TEST_F(MatchSwitchTest, JustX) {
+TEST(MatchSwitchTest, JustX) {
   std::string Code = R"(
     void fun() {
       int X = 1;
       (void)X;
       // [[p]]
     }
   )";
   RunDataflow(Code,
               UnorderedElementsAre(Pair("p", Holds(BooleanLattice(true)))));
 }
 
-TEST_F(MatchSwitchTest, JustFoo) {
+TEST(MatchSwitchTest, JustFoo) {
   std::string Code = R"(
     void Foo();
     void fun() {
       Foo();
       // [[p]]
     }
   )";
   RunDataflow(Code,
               UnorderedElementsAre(Pair("p", Holds(BooleanLattice(false)))));
 }
 
-TEST_F(MatchSwitchTest, XThenFoo) {
+TEST(MatchSwitchTest, XThenFoo) {
   std::string Code = R"(
     void Foo();
     void fun() {
       int X = 1;
       (void)X;
       Foo();
       // [[p]]
     }
   )";
   RunDataflow(Code,
               UnorderedElementsAre(Pair("p", Holds(BooleanLattice(false)))));
 }
 
-TEST_F(MatchSwitchTest, FooThenX) {
+TEST(MatchSwitchTest, FooThenX) {
   std::string Code = R"(
     void Foo();
     void fun() {
       Foo();
       int X = 1;
       (void)X;
       // [[p]]
     }
   )";
   RunDataflow(Code,
               UnorderedElementsAre(Pair("p", Holds(BooleanLattice(true)))));
 }
 
-TEST_F(MatchSwitchTest, Neither) {
+TEST(MatchSwitchTest, Neither) {
   std::string Code = R"(
     void Bar();
     void fun(bool b) {
       Bar();
       // [[p]]
     }
   )";
   RunDataflow(Code,
               UnorderedElementsAre(Pair("p", Holds(BooleanLattice(false)))));
 }
 
-TEST_F(MatchSwitchTest, ReturnNonVoid) {
+TEST(MatchSwitchTest, ReturnNonVoid) {
   using namespace ast_matchers;
 
   auto Unit =
       tooling::buildASTFromCode("void f() { int x = 42; }", "input.cc",
                                 std::make_shared<PCHContainerOperations>());
   auto &Context = Unit->getASTContext();
   const auto *S =
       selectFirst<FunctionDecl>(

clang/unittests/Analysis/FlowSensitive/MultiVarConstantPropagationTest.cpp

 MATCHER_P(HoldsCPLattice, m,
           ((negation ? "doesn't hold" : "holds") +
            llvm::StringRef(" a lattice element that ") +
            ::testing::DescribeMatcher<ConstantPropagationLattice>(m, negation))
               .str()) {
   return ExplainMatchResult(m, arg.Lattice, result_listener);
 }
 
-class MultiVarConstantPropagationTest : public ::testing::Test {
-protected:
-  template <typename Matcher>
-  void RunDataflow(llvm::StringRef Code, Matcher Expectations) {
-    ASSERT_THAT_ERROR(
-        test::checkDataflow<ConstantPropagationAnalysis>(
-            Code, "fun",
-            [](ASTContext &C, Environment &) {
-              return ConstantPropagationAnalysis(C);
-            },
-            [&Expectations](
-                llvm::ArrayRef<std::pair<
-                    std::string, DataflowAnalysisState<
-                                     ConstantPropagationAnalysis::Lattice>>>
-                    Results,
-                ASTContext &) { EXPECT_THAT(Results, Expectations); },
-            {"-fsyntax-only", "-std=c++17"}),
-        llvm::Succeeded());
-  }
-};
+                  std::string,
+                  DataflowAnalysisState<ConstantPropagationAnalysis::Lattice>>>
 
-TEST_F(MultiVarConstantPropagationTest, JustInit) {
+TEST(MultiVarConstantPropagationTest, JustInit) {
   std::string Code = R"(
     void fun() {
       int target = 1;
       // [[p]]
     }
   )";
   RunDataflow(Code, UnorderedElementsAre(
                         Pair("p", HoldsCPLattice(UnorderedElementsAre(Pair(
                                       Var("target"), HasConstantVal(1)))))));
 }
 
-TEST_F(MultiVarConstantPropagationTest, Assignment) {
+TEST(MultiVarConstantPropagationTest, Assignment) {
   std::string Code = R"(
     void fun() {
       int target = 1;
       // [[p1]]
       target = 2;
       // [[p2]]
     }
   )";
   RunDataflow(Code, UnorderedElementsAre(
                         Pair("p1", HoldsCPLattice(UnorderedElementsAre(Pair(
                                        Var("target"), HasConstantVal(1))))),
                         Pair("p2", HoldsCPLattice(UnorderedElementsAre(Pair(
                                        Var("target"), HasConstantVal(2)))))));
 }
 
-TEST_F(MultiVarConstantPropagationTest, AssignmentCall) {
+TEST(MultiVarConstantPropagationTest, AssignmentCall) {
   std::string Code = R"(
     int g();
     void fun() {
       int target;
       target = g();
       // [[p]]
     }
   )";
   RunDataflow(Code, UnorderedElementsAre(
                         Pair("p", HoldsCPLattice(UnorderedElementsAre(
                                       Pair(Var("target"), Varies()))))));
 }
 
-TEST_F(MultiVarConstantPropagationTest, AssignmentBinOp) {
+TEST(MultiVarConstantPropagationTest, AssignmentBinOp) {
   std::string Code = R"(
     void fun() {
       int target;
       target = 2 + 3;
       // [[p]]
     }
   )";
   RunDataflow(Code, UnorderedElementsAre(
                         Pair("p", HoldsCPLattice(UnorderedElementsAre(Pair(
                                       Var("target"), HasConstantVal(5)))))));
 }
 
-TEST_F(MultiVarConstantPropagationTest, PlusAssignment) {
+TEST(MultiVarConstantPropagationTest, PlusAssignment) {
   std::string Code = R"(
     void fun() {
       int target = 1;
       // [[p1]]
       target += 2;
       // [[p2]]
     }
   )";
   RunDataflow(Code, UnorderedElementsAre(
                         Pair("p1", HoldsCPLattice(UnorderedElementsAre(Pair(
                                        Var("target"), HasConstantVal(1))))),
                         Pair("p2", HoldsCPLattice(UnorderedElementsAre(
                                        Pair(Var("target"), Varies()))))));
 }
 
-TEST_F(MultiVarConstantPropagationTest, SameAssignmentInBranches) {
+TEST(MultiVarConstantPropagationTest, SameAssignmentInBranches) {
   std::string Code = R"cc(
     void fun(bool b) {
       int target;
       // [[p1]]
       if (b) {
         target = 2;
         // [[pT]]
       } else {
RunDataflow(Code,
                                  Pair(Var("target"), HasConstantVal(2))))),
                   Pair("pF", HoldsCPLattice(UnorderedElementsAre(
                                  Pair(Var("target"), HasConstantVal(2))))),
                   Pair("p2", HoldsCPLattice(UnorderedElementsAre(
                                  Pair(Var("target"), HasConstantVal(2)))))));
 }
 
 // Verifies that the analysis tracks multiple variables simultaneously.
-TEST_F(MultiVarConstantPropagationTest, TwoVariables) {
+TEST(MultiVarConstantPropagationTest, TwoVariables) {
   std::string Code = R"(
     void fun() {
       int target = 1;
       // [[p1]]
       int other = 2;
       // [[p2]]
       target = 3;
       // [[p3]]
     }
   )";
   RunDataflow(Code,
               UnorderedElementsAre(
                   Pair("p1", HoldsCPLattice(UnorderedElementsAre(
                                  Pair(Var("target"), HasConstantVal(1))))),
                   Pair("p2", HoldsCPLattice(UnorderedElementsAre(
                                  Pair(Var("target"), HasConstantVal(1)),
                                  Pair(Var("other"), HasConstantVal(2))))),
                   Pair("p3", HoldsCPLattice(UnorderedElementsAre(
                                  Pair(Var("target"), HasConstantVal(3)),
                                  Pair(Var("other"), HasConstantVal(2)))))));
 }
 
-TEST_F(MultiVarConstantPropagationTest, TwoVariablesInBranches) {
+TEST(MultiVarConstantPropagationTest, TwoVariablesInBranches) {
   std::string Code = R"cc(
     void fun(bool b) {
       int target;
       int other;
       // [[p1]]
       if (b) {
         target = 2;
         // [[pT]]
RunDataflow(Code, UnorderedElementsAre(
                         Pair("pF", HoldsCPLattice(UnorderedElementsAre(
                                        Pair(Var("other"), HasConstantVal(3)),
                                        Pair(Var("target"), Varies())))),
                         Pair("p2", HoldsCPLattice(UnorderedElementsAre(
                                        Pair(Var("target"), Varies()),
                                        Pair(Var("other"), Varies()))))));
 }
 
-TEST_F(MultiVarConstantPropagationTest, SameAssignmentInBranch) {
+TEST(MultiVarConstantPropagationTest, SameAssignmentInBranch) {
   std::string Code = R"cc(
     void fun(bool b) {
       int target = 1;
       // [[p1]]
       if (b) {
         target = 1;
       }
       (void)0;
       // [[p2]]
     }
   )cc";
   RunDataflow(Code, UnorderedElementsAre(
                         Pair("p1", HoldsCPLattice(UnorderedElementsAre(Pair(
                                        Var("target"), HasConstantVal(1))))),
                         Pair("p2", HoldsCPLattice(UnorderedElementsAre(Pair(
                                        Var("target"), HasConstantVal(1)))))));
 }
 
-TEST_F(MultiVarConstantPropagationTest, NewVarInBranch) {
+TEST(MultiVarConstantPropagationTest, NewVarInBranch) {
   std::string Code = R"cc(
     void fun(bool b) {
       if (b) {
         int target;
         // [[p1]]
         target = 1;
         // [[p2]]
       } else {
RunDataflow(Code, UnorderedElementsAre(
                         Pair("p2", HoldsCPLattice(UnorderedElementsAre(Pair(
                                        Var("target"), HasConstantVal(1))))),
                         Pair("p3", HoldsCPLattice(UnorderedElementsAre(
                                        Pair(Var("target"), Varies())))),
                         Pair("p4", HoldsCPLattice(UnorderedElementsAre(Pair(
                                        Var("target"), HasConstantVal(1)))))));
 }
 
-TEST_F(MultiVarConstantPropagationTest, DifferentAssignmentInBranches) {
+TEST(MultiVarConstantPropagationTest, DifferentAssignmentInBranches) {
   std::string Code = R"cc(
     void fun(bool b) {
       int target;
       // [[p1]]
       if (b) {
         target = 1;
         // [[pT]]
       } else {
RunDataflow(Code, UnorderedElementsAre(
                         Pair("pT", HoldsCPLattice(UnorderedElementsAre(Pair(
                                        Var("target"), HasConstantVal(1))))),
                         Pair("pF", HoldsCPLattice(UnorderedElementsAre(Pair(
                                        Var("target"), HasConstantVal(2))))),
                         Pair("p2", HoldsCPLattice(UnorderedElementsAre(
                                        Pair(Var("target"), Varies()))))));
 }
 
-TEST_F(MultiVarConstantPropagationTest, DifferentAssignmentInBranch) {
+TEST(MultiVarConstantPropagationTest, DifferentAssignmentInBranch) {
   std::string Code = R"cc(
     void fun(bool b) {
       int target = 1;
       // [[p1]]
       if (b) {
         target = 3;
       }
       (void)0;

clang/unittests/Analysis/FlowSensitive/SingleVarConstantPropagationTest.cpp

 MATCHER_P(HoldsCPLattice, m,
           ((negation ? "doesn't hold" : "holds") +
            llvm::StringRef(" a lattice element that ") +
            ::testing::DescribeMatcher<ConstantPropagationLattice>(m, negation))
               .str()) {
   return ExplainMatchResult(m, arg.Lattice, result_listener);
 }
 
-class ConstantPropagationTest : public ::testing::Test {
-protected:
-  template <typename Matcher>
-  void RunDataflow(llvm::StringRef Code, Matcher Expectations) {
-    ASSERT_THAT_ERROR(
-        test::checkDataflow<ConstantPropagationAnalysis>(
-            Code, "fun",
-            [](ASTContext &C, Environment &) {
-              return ConstantPropagationAnalysis(C);
-            },
-            [&Expectations](
-                llvm::ArrayRef<std::pair<
-                    std::string, DataflowAnalysisState<
-                                     ConstantPropagationAnalysis::Lattice>>>
-                    Results,
-                ASTContext &) { EXPECT_THAT(Results, Expectations); },
-            {"-fsyntax-only", "-std=c++17"}),
-        llvm::Succeeded());
-  }
-};
 
-TEST_F(ConstantPropagationTest, JustInit) {
+TEST(ConstantPropagationTest, JustInit) {
   std::string Code = R"(
     void fun() {
       int target = 1;
       // [[p]]
     }
   )";
   RunDataflow(
       Code, UnorderedElementsAre(Pair("p", HoldsCPLattice(HasConstantVal(1)))));
 }
 
 // Verifies that the analysis tracks the last variable seen.
-TEST_F(ConstantPropagationTest, TwoVariables) {
+TEST(ConstantPropagationTest, TwoVariables) {
   std::string Code = R"(
     void fun() {
       int target = 1;
       // [[p1]]
       int other = 2;
       // [[p2]]
       target = 3;
       // [[p3]]
     }
   )";
   RunDataflow(Code, UnorderedElementsAre(
                         Pair("p1", HoldsCPLattice(HasConstantVal(1))),
                         Pair("p2", HoldsCPLattice(HasConstantVal(2))),
                         Pair("p3", HoldsCPLattice(HasConstantVal(3)))));
 }
 
-TEST_F(ConstantPropagationTest, Assignment) {
+TEST(ConstantPropagationTest, Assignment) {
   std::string Code = R"(
     void fun() {
       int target = 1;
       // [[p1]]
       target = 2;
       // [[p2]]
     }
   )";
   RunDataflow(Code, UnorderedElementsAre(
                         Pair("p1", HoldsCPLattice(HasConstantVal(1))),
                         Pair("p2", HoldsCPLattice(HasConstantVal(2)))));
 }
 
-TEST_F(ConstantPropagationTest, AssignmentCall) {
+TEST(ConstantPropagationTest, AssignmentCall) {
   std::string Code = R"(
     int g();
     void fun() {
       int target;
       target = g();
       // [[p]]
     }
   )";
   RunDataflow(Code, UnorderedElementsAre(Pair("p", HoldsCPLattice(Varies()))));
 }
 
-TEST_F(ConstantPropagationTest, AssignmentBinOp) {
+TEST(ConstantPropagationTest, AssignmentBinOp) {
   std::string Code = R"(
     void fun() {
       int target;
       target = 2 + 3;
       // [[p]]
     }
   )";
   RunDataflow(
       Code, UnorderedElementsAre(Pair("p", HoldsCPLattice(HasConstantVal(5)))));
 }
 
-TEST_F(ConstantPropagationTest, PlusAssignment) {
+TEST(ConstantPropagationTest, PlusAssignment) {
   std::string Code = R"(
     void fun() {
       int target = 1;
       // [[p1]]
       target += 2;
       // [[p2]]
     }
   )";
   RunDataflow(
       Code, UnorderedElementsAre(Pair("p1", HoldsCPLattice(HasConstantVal(1))),
                                  Pair("p2", HoldsCPLattice(Varies()))));
 }
 
-TEST_F(ConstantPropagationTest, SameAssignmentInBranches) {
+TEST(ConstantPropagationTest, SameAssignmentInBranches) {
   std::string Code = R"cc(
     void fun(bool b) {
       int target;
       // [[p1]]
       if (b) {
         target = 2;
         // [[pT]]
       } else {
         target = 2;
         // [[pF]]
       }
       (void)0;
       // [[p2]]
     }
   )cc";
   RunDataflow(Code, UnorderedElementsAre(
                         Pair("p1", HoldsCPLattice(IsUnknown())),
                         Pair("pT", HoldsCPLattice(HasConstantVal(2))),
                         Pair("pF", HoldsCPLattice(HasConstantVal(2))),
                         Pair("p2", HoldsCPLattice(HasConstantVal(2)))));
 }
 
-TEST_F(ConstantPropagationTest, SameAssignmentInBranch) {
+TEST(ConstantPropagationTest, SameAssignmentInBranch) {
   std::string Code = R"cc(
     void fun(bool b) {
       int target = 1;
       // [[p1]]
       if (b) {
         target = 1;
       }
       (void)0;
       // [[p2]]
     }
   )cc";
   RunDataflow(Code, UnorderedElementsAre(
                         Pair("p1", HoldsCPLattice(HasConstantVal(1))),
                         Pair("p2", HoldsCPLattice(HasConstantVal(1)))));
 }
 
-TEST_F(ConstantPropagationTest, NewVarInBranch) {
+TEST(ConstantPropagationTest, NewVarInBranch) {
   std::string Code = R"cc(
     void fun(bool b) {
       if (b) {
         int target;
         // [[p1]]
         target = 1;
         // [[p2]]
       } else {
         int target;
         // [[p3]]
         target = 1;
         // [[p4]]
       }
     }
   )cc";
   RunDataflow(Code, UnorderedElementsAre(
                         Pair("p1", HoldsCPLattice(IsUnknown())),
                         Pair("p2", HoldsCPLattice(HasConstantVal(1))),
                         Pair("p3", HoldsCPLattice(IsUnknown())),
                         Pair("p4", HoldsCPLattice(HasConstantVal(1)))));
 }
 
-TEST_F(ConstantPropagationTest, DifferentAssignmentInBranches) {
+TEST(ConstantPropagationTest, DifferentAssignmentInBranches) {
   std::string Code = R"cc(
     void fun(bool b) {
       int target;
       // [[p1]]
       if (b) {
         target = 1;
         // [[pT]]
       } else {
         target = 2;
         // [[pF]]
       }
       (void)0;
       // [[p2]]
     }
   )cc";
   RunDataflow(
       Code, UnorderedElementsAre(Pair("p1", HoldsCPLattice(IsUnknown())),
                                  Pair("pT", HoldsCPLattice(HasConstantVal(1))),
                                  Pair("pF", HoldsCPLattice(HasConstantVal(2))),
                                  Pair("p2", HoldsCPLattice(Varies()))));
 }
 
-TEST_F(ConstantPropagationTest, DifferentAssignmentInBranch) {
+TEST(ConstantPropagationTest, DifferentAssignmentInBranch) {
   std::string Code = R"cc(
     void fun(bool b) {
       int target = 1;
       // [[p1]]
       if (b) {
         target = 3;
       }
       (void)0;

clang/unittests/Analysis/FlowSensitive/TestingSupportTest.cpp

if (Func == nullptr)
       continue;
     if (Func->isTemplated())
       continue;
     return Func;
   }
   return nullptr;
 }
 
-class BuildStatementToAnnotationMappingTest : public ::testing::Test {
-public:
-  void
-  runTest(llvm::StringRef Code, llvm::StringRef TargetName,
-          std::function<void(const llvm::DenseMap<const Stmt *, std::string> &)>
-              RunChecks) {
-    llvm::Annotations AnnotatedCode(Code);
-    auto Unit = tooling::buildASTFromCodeWithArgs(
-        AnnotatedCode.code(), {"-fsyntax-only", "-std=c++17"});
-    auto &Context = Unit->getASTContext();
-    const FunctionDecl *Func = findTargetFunc(Context, hasName(TargetName));
-    ASSERT_NE(Func, nullptr);
+void runTest(
+    llvm::StringRef Code, llvm::StringRef TargetName,
 
-    llvm::Expected<llvm::DenseMap<const Stmt *, std::string>> Mapping =
-        test::buildStatementToAnnotationMapping(Func, AnnotatedCode);
-    ASSERT_TRUE(static_cast<bool>(Mapping));
 
-    RunChecks(Mapping.get());
-  }
-};
 
-TEST_F(BuildStatementToAnnotationMappingTest, ReturnStmt) {
+TEST(BuildStatementToAnnotationMappingTest, ReturnStmt) {
   runTest(R"(
     int target() {
       return 42;
       /*[[ok]]*/
     }
   )",
           "target",
           [](const llvm::DenseMap<const Stmt *, std::string> &Annotations) {

clang/unittests/Analysis/FlowSensitive/TransferTest.cpp

 using namespace test;
 using ::testing::_;
 using ::testing::ElementsAre;
 using ::testing::IsNull;
 using ::testing::NotNull;
 using ::testing::Pair;
 using ::testing::SizeIs;
 
-class TransferTest : public ::testing::Test {
-protected:
-  template <typename Matcher>
-  void runDataflow(llvm::StringRef Code, Matcher Match,
-                   LangStandard::Kind Std = LangStandard::lang_cxx17,
-                   bool ApplyBuiltinTransfer = true,
-                   llvm::StringRef TargetFun = "target") {
-    ASSERT_THAT_ERROR(
-        test::checkDataflow<NoopAnalysis>(
-            Code, TargetFun,
-            [ApplyBuiltinTransfer](ASTContext &C, Environment &) {
-              return NoopAnalysis(C, ApplyBuiltinTransfer);
-            },
-            [&Match](
-                llvm::ArrayRef<
-                    std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
-                    Results,
-                ASTContext &ASTCtx) { Match(Results, ASTCtx); },
-            {"-fsyntax-only", "-fno-delayed-template-parsing",
-             "-std=" +
-                 std::string(
-                     LangStandard::getLangStandardForKind(Std).getName())}),
-        llvm::Succeeded());
-  }
-};
 
-TEST_F(TransferTest, IntVarDeclNotTrackedWhenTransferDisabled) {
+TEST(TransferTest, IntVarDeclNotTrackedWhenTransferDisabled) {
   std::string Code = R"(
     void target() {
       int Foo;
       // [[p]]
     }
   )";
   runDataflow(
       Code,
       [](llvm::ArrayRef<
              std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
              Results,
          ASTContext &ASTCtx) {
         ASSERT_THAT(Results, ElementsAre(Pair("p", _)));
         const Environment &Env = Results[0].second.Env;
 
         const ValueDecl *FooDecl = findValueDecl(ASTCtx, "Foo");
         ASSERT_THAT(FooDecl, NotNull());
 
         EXPECT_EQ(Env.getStorageLocation(*FooDecl, SkipPast::None), nullptr);
       },
       LangStandard::lang_cxx17,
       /*ApplyBuiltinTransfer=*/false);
 }
 
-TEST_F(TransferTest, BoolVarDecl) {
+TEST(TransferTest, BoolVarDecl) {
   std::string Code = R"(
     void target() {
       bool Foo;
       // [[p]]
     }
   )";
   runDataflow(Code,
               [](llvm::ArrayRef<
runDataflow(Code,
                     Env.getStorageLocation(*FooDecl, SkipPast::None);
                 ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc));
 
                 const Value *FooVal = Env.getValue(*FooLoc);
                 EXPECT_TRUE(isa_and_nonnull<BoolValue>(FooVal));
               });
 }
 
-TEST_F(TransferTest, IntVarDecl) {
+TEST(TransferTest, IntVarDecl) {
   std::string Code = R"(
     void target() {
       int Foo;
       // [[p]]
     }
   )";
   runDataflow(Code,
               [](llvm::ArrayRef<
runDataflow(Code,
                     Env.getStorageLocation(*FooDecl, SkipPast::None);
                 ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc));
 
                 const Value *FooVal = Env.getValue(*FooLoc);
                 EXPECT_TRUE(isa_and_nonnull<IntegerValue>(FooVal));
               });
 }
 
-TEST_F(TransferTest, StructVarDecl) {
+TEST(TransferTest, StructVarDecl) {
   std::string Code = R"(
     struct A {
       int Bar;
     };
 
     void target() {
       A Foo;
       // [[p]]
runDataflow(
             cast<ScalarStorageLocation>(&FooLoc->getChild(*BarDecl));
 
         const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
         const auto *BarVal = cast<IntegerValue>(FooVal->getChild(*BarDecl));
         EXPECT_EQ(Env.getValue(*BarLoc), BarVal);
       });
 }
 
-TEST_F(TransferTest, StructVarDeclWithInit) {
+TEST(TransferTest, StructVarDeclWithInit) {
   std::string Code = R"(
     struct A {
       int Bar;
     };
 
     A Gen();
 
     void target() {
runDataflow(
             cast<ScalarStorageLocation>(&FooLoc->getChild(*BarDecl));
 
         const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
         const auto *BarVal = cast<IntegerValue>(FooVal->getChild(*BarDecl));
         EXPECT_EQ(Env.getValue(*BarLoc), BarVal);
       });
 }
 
-TEST_F(TransferTest, ClassVarDecl) {
+TEST(TransferTest, ClassVarDecl) {
   std::string Code = R"(
     class A {
       int Bar;
     };
 
     void target() {
       A Foo;
       // [[p]]
runDataflow(
             cast<ScalarStorageLocation>(&FooLoc->getChild(*BarDecl));
 
         const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
         const auto *BarVal = cast<IntegerValue>(FooVal->getChild(*BarDecl));
         EXPECT_EQ(Env.getValue(*BarLoc), BarVal);
       });
 }
 
-TEST_F(TransferTest, ReferenceVarDecl) {
+TEST(TransferTest, ReferenceVarDecl) {
   std::string Code = R"(
     struct A {};
 
     A &getA();
 
     void target() {
       A &Foo = getA();
       // [[p]]
runDataflow(
         const StorageLocation &FooReferentLoc = FooVal->getReferentLoc();
         EXPECT_TRUE(isa<AggregateStorageLocation>(&FooReferentLoc));
 
         const Value *FooReferentVal = Env.getValue(FooReferentLoc);
         EXPECT_TRUE(isa_and_nonnull<StructValue>(FooReferentVal));
       });
 }
 
-TEST_F(TransferTest, SelfReferentialReferenceVarDecl) {
+TEST(TransferTest, SelfReferentialReferenceVarDecl) {
   std::string Code = R"(
     struct A;
 
     struct B {};
 
     struct C {
       A &FooRef;
       A *FooPtr;
runDataflow(Code, [](llvm::ArrayRef<std::pair<
 
     const auto *BazPtrVal =
         cast<PointerValue>(BarReferentVal->getChild(*BazPtrDecl));
     const StorageLocation &BazPtrPointeeLoc = BazPtrVal->getPointeeLoc();
     EXPECT_THAT(Env.getValue(BazPtrPointeeLoc), NotNull());
   });
 }
 
-TEST_F(TransferTest, PointerVarDecl) {
+TEST(TransferTest, PointerVarDecl) {
   std::string Code = R"(
     struct A {};
 
     A *getA();
 
     void target() {
       A *Foo = getA();
       // [[p]]
runDataflow(
         const StorageLocation &FooPointeeLoc = FooVal->getPointeeLoc();
         EXPECT_TRUE(isa<AggregateStorageLocation>(&FooPointeeLoc));
 
         const Value *FooPointeeVal = Env.getValue(FooPointeeLoc);
         EXPECT_TRUE(isa_and_nonnull<StructValue>(FooPointeeVal));
       });
 }
 
-TEST_F(TransferTest, SelfReferentialPointerVarDecl) {
+TEST(TransferTest, SelfReferentialPointerVarDecl) {
   std::string Code = R"(
     struct A;
 
     struct B {};
 
     struct C {
       A &FooRef;
       A *FooPtr;
runDataflow(
 
         const auto *BazPtrVal =
             cast<PointerValue>(BarPointeeVal->getChild(*BazPtrDecl));
         const StorageLocation &BazPtrPointeeLoc = BazPtrVal->getPointeeLoc();
         EXPECT_THAT(Env.getValue(BazPtrPointeeLoc), NotNull());
       });
 }
 
-TEST_F(TransferTest, MultipleVarsDecl) {
+TEST(TransferTest, MultipleVarsDecl) {
   std::string Code = R"(
     void target() {
       int Foo, Bar;
       (void)0;
       // [[p]]
     }
   )";
   runDataflow(Code,
runDataflow(Code,
                 const Value *FooVal = Env.getValue(*FooLoc);
                 EXPECT_TRUE(isa_and_nonnull<IntegerValue>(FooVal));
 
                 const Value *BarVal = Env.getValue(*BarLoc);
                 EXPECT_TRUE(isa_and_nonnull<IntegerValue>(BarVal));
               });
 }
 
-TEST_F(TransferTest, JoinVarDecl) {
+TEST(TransferTest, JoinVarDecl) {
   std::string Code = R"(
     void target(bool B) {
       int Foo;
       // [[p1]]
       if (B) {
         int Bar;
         // [[p2]]
       } else {
runDataflow(Code, [](llvm::ArrayRef<std::pair<
 
     const Environment &Env4 = Results[0].second.Env;
     EXPECT_EQ(Env4.getStorageLocation(*FooDecl, SkipPast::None), FooLoc);
     EXPECT_THAT(Env4.getStorageLocation(*BarDecl, SkipPast::None), IsNull());
     EXPECT_THAT(Env4.getStorageLocation(*BazDecl, SkipPast::None), IsNull());
   });
 }
 
-TEST_F(TransferTest, BinaryOperatorAssign) {
+TEST(TransferTest, BinaryOperatorAssign) {
   std::string Code = R"(
     void target() {
       int Foo;
       int Bar;
       (Bar) = (Foo);
       // [[p]]
     }
   )";
runDataflow(Code,
 
                 const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
                 ASSERT_THAT(BarDecl, NotNull());
 
                 EXPECT_EQ(Env.getValue(*BarDecl, SkipPast::None), FooVal);
               });
 }
 
-TEST_F(TransferTest, VarDeclInitAssign) {
+TEST(TransferTest, VarDeclInitAssign) {
   std::string Code = R"(
     void target() {
       int Foo;
       int Bar = Foo;
       // [[p]]
     }
   )";
   runDataflow(Code,
runDataflow(Code,
 
                 const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
                 ASSERT_THAT(BarDecl, NotNull());
 
                 EXPECT_EQ(Env.getValue(*BarDecl, SkipPast::None), FooVal);
               });
 }
 
-TEST_F(TransferTest, VarDeclInitAssignChained) {
+TEST(TransferTest, VarDeclInitAssignChained) {
   std::string Code = R"(
     void target() {
       int Foo;
       int Bar;
       int Baz = (Bar = Foo);
       // [[p]]
     }
   )";
runDataflow(Code,
                 const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
                 ASSERT_THAT(BazDecl, NotNull());
 
                 EXPECT_EQ(Env.getValue(*BarDecl, SkipPast::None), FooVal);
                 EXPECT_EQ(Env.getValue(*BazDecl, SkipPast::None), FooVal);
               });
 }
 
-TEST_F(TransferTest, VarDeclInitAssignPtrDeref) {
+TEST(TransferTest, VarDeclInitAssignPtrDeref) {
   std::string Code = R"(
     void target() {
       int Foo;
       int *Bar;
       *(Bar) = Foo;
       int Baz = *(Bar);
       // [[p]]
     }
runDataflow(Code,
 
                 const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
                 ASSERT_THAT(BazDecl, NotNull());
 
                 EXPECT_EQ(Env.getValue(*BazDecl, SkipPast::None), FooVal);
               });
 }
 
-TEST_F(TransferTest, AssignToAndFromReference) {
+TEST(TransferTest, AssignToAndFromReference) {
   std::string Code = R"(
     void target() {
       int Foo;
       int Bar;
       int &Baz = Foo;
       // [[p1]]
       Baz = Bar;
       int Qux = Baz;
runDataflow(
         EXPECT_EQ(Env2.getValue(*QuxDecl, SkipPast::None), BarVal);
 
         const ValueDecl *QuuxDecl = findValueDecl(ASTCtx, "Quux");
         ASSERT_THAT(QuuxDecl, NotNull());
         EXPECT_EQ(Env2.getValue(*QuuxDecl, SkipPast::Reference), BarVal);
       });
 }
 
-TEST_F(TransferTest, MultipleParamDecls) {
+TEST(TransferTest, MultipleParamDecls) {
   std::string Code = R"(
     void target(int Foo, int Bar) {
       (void)0;
       // [[p]]
     }
   )";
   runDataflow(Code,
               [](llvm::ArrayRef<
runDataflow(Code,
                     Env.getStorageLocation(*BarDecl, SkipPast::None);
                 ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(BarLoc));
 
                 const Value *BarVal = Env.getValue(*BarLoc);
                 EXPECT_TRUE(isa_and_nonnull<IntegerValue>(BarVal));
               });
 }
 
-TEST_F(TransferTest, StructParamDecl) {
+TEST(TransferTest, StructParamDecl) {
   std::string Code = R"(
     struct A {
       int Bar;
     };
 
     void target(A Foo) {
       (void)0;
       // [[p]]
runDataflow(
             cast<ScalarStorageLocation>(&FooLoc->getChild(*BarDecl));
 
         const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
         const auto *BarVal = cast<IntegerValue>(FooVal->getChild(*BarDecl));
         EXPECT_EQ(Env.getValue(*BarLoc), BarVal);
       });
 }
 
-TEST_F(TransferTest, ReferenceParamDecl) {
+TEST(TransferTest, ReferenceParamDecl) {
   std::string Code = R"(
     struct A {};
 
     void target(A &Foo) {
       (void)0;
       // [[p]]
     }
   )";
runDataflow(
         const StorageLocation &FooReferentLoc = FooVal->getReferentLoc();
         EXPECT_TRUE(isa<AggregateStorageLocation>(&FooReferentLoc));
 
         const Value *FooReferentVal = Env.getValue(FooReferentLoc);
         EXPECT_TRUE(isa_and_nonnull<StructValue>(FooReferentVal));
       });
 }
 
-TEST_F(TransferTest, PointerParamDecl) {
+TEST(TransferTest, PointerParamDecl) {
   std::string Code = R"(
     struct A {};
 
     void target(A *Foo) {
       (void)0;
       // [[p]]
     }
   )";
runDataflow(
         const StorageLocation &FooPointeeLoc = FooVal->getPointeeLoc();
         EXPECT_TRUE(isa<AggregateStorageLocation>(&FooPointeeLoc));
 
         const Value *FooPointeeVal = Env.getValue(FooPointeeLoc);
         EXPECT_TRUE(isa_and_nonnull<StructValue>(FooPointeeVal));
       });
 }
 
-TEST_F(TransferTest, StructMember) {
+TEST(TransferTest, StructMember) {
   std::string Code = R"(
     struct A {
       int Bar;
     };
 
     void target(A Foo) {
       int Baz = Foo.Bar;
       // [[p]]
runDataflow(
 
         const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
         ASSERT_THAT(BazDecl, NotNull());
 
         EXPECT_EQ(Env.getValue(*BazDecl, SkipPast::None), BarVal);
       });
 }
 
-TEST_F(TransferTest, DerivedBaseMemberClass) {
+TEST(TransferTest, DerivedBaseMemberClass) {
   std::string Code = R"(
     class A {
       int ADefault;
     protected:
       int AProtected;
     private:
       int APrivate;
     public:
static void derivedBaseMemberExpectations(
 
   const auto &FooLoc = *cast<AggregateStorageLocation>(
       Env.getStorageLocation(*FooDecl, SkipPast::None));
   const auto &FooVal = *cast<StructValue>(Env.getValue(FooLoc));
   EXPECT_THAT(FooVal.getChild(*BarDecl), NotNull());
   EXPECT_EQ(Env.getValue(FooLoc.getChild(*BarDecl)), FooVal.getChild(*BarDecl));
 }
 
-TEST_F(TransferTest, DerivedBaseMemberStructDefault) {
+TEST(TransferTest, DerivedBaseMemberStructDefault) {
   std::string Code = R"(
     struct A {
       int Bar;
     };
     struct B : public A {
     };
 
     void target() {
       B Foo;
       // [[p]]
     }
   )";
   runDataflow(Code, derivedBaseMemberExpectations);
 }
 
-TEST_F(TransferTest, DerivedBaseMemberPrivateFriend) {
+TEST(TransferTest, DerivedBaseMemberPrivateFriend) {
   // Include an access to `Foo.Bar` to verify the analysis doesn't crash on that
   // access.
   std::string Code = R"(
     struct A {
     private:
       friend void target();
       int Bar;
     };
     struct B : public A {
     };
 
     void target() {
       B Foo;
       (void)Foo.Bar;
       // [[p]]
     }
   )";
   runDataflow(Code, derivedBaseMemberExpectations);
 }
 
-TEST_F(TransferTest, ClassMember) {
+TEST(TransferTest, ClassMember) {
   std::string Code = R"(
     class A {
     public:
       int Bar;
     };
 
     void target(A Foo) {
       int Baz = Foo.Bar;
runDataflow(
 
         const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
         ASSERT_THAT(BazDecl, NotNull());
 
         EXPECT_EQ(Env.getValue(*BazDecl, SkipPast::None), BarVal);
       });
 }
 
-TEST_F(TransferTest, BaseClassInitializer) {
+TEST(TransferTest, BaseClassInitializer) {
   using ast_matchers::cxxConstructorDecl;
   using ast_matchers::hasName;
   using ast_matchers::ofClass;
 
   std::string Code = R"(
     class A {
     public:
       A(int I) : Bar(I) {}
ASSERT_THAT_ERROR(
           },
           {"-fsyntax-only", "-fno-delayed-template-parsing",
            "-std=" + std::string(LangStandard::getLangStandardForKind(
                                      LangStandard::lang_cxx17)
                                      .getName())}),
       llvm::Succeeded());
 }
 
-TEST_F(TransferTest, ReferenceMember) {
+TEST(TransferTest, ReferenceMember) {
   std::string Code = R"(
     struct A {
       int &Bar;
     };
 
     void target(A Foo) {
       int Baz = Foo.Bar;
       // [[p]]
runDataflow(
 
         const ValueDecl *BazDecl = findValueDecl(ASTCtx, "Baz");
         ASSERT_THAT(BazDecl, NotNull());
 
         EXPECT_EQ(Env.getValue(*BazDecl, SkipPast::None), BarReferentVal);
       });
 }
 
-TEST_F(TransferTest, StructThisMember) {
+TEST(TransferTest, StructThisMember) {
   std::string Code = R"(
     struct A {
       int Bar;
 
       struct B {
         int Baz;
       };
 
runDataflow(
         EXPECT_EQ(Env.getValue(*BazLoc), BazVal);
 
         const ValueDecl *QuuxDecl = findValueDecl(ASTCtx, "Quux");
         ASSERT_THAT(QuuxDecl, NotNull());
         EXPECT_EQ(Env.getValue(*QuuxDecl, SkipPast::None), BazVal);
       });
 }
 
-TEST_F(TransferTest, ClassThisMember) {
+TEST(TransferTest, ClassThisMember) {
   std::string Code = R"(
     class A {
       int Bar;
 
       class B {
       public:
         int Baz;
       };
runDataflow(
         EXPECT_EQ(Env.getValue(*BazLoc), BazVal);
 
         const ValueDecl *QuuxDecl = findValueDecl(ASTCtx, "Quux");
         ASSERT_THAT(QuuxDecl, NotNull());
         EXPECT_EQ(Env.getValue(*QuuxDecl, SkipPast::None), BazVal);
       });
 }
 
-TEST_F(TransferTest, StructThisInLambda) {
+TEST(TransferTest, StructThisInLambda) {
   std::string ThisCaptureCode = R"(
     struct A {
       void frob() {
         [this]() {
           int Foo = Bar;
           // [[p1]]
         }();
       }
runDataflow(
         ASSERT_THAT(Results, ElementsAre(Pair("p3", _)));
         const Environment &Env = Results[0].second.Env;
 
         EXPECT_THAT(Env.getThisPointeeStorageLocation(), IsNull());
       },
       LangStandard::lang_cxx17, /*ApplyBuiltinTransfer=*/true, "operator()");
 }
 
-TEST_F(TransferTest, ConstructorInitializer) {
+TEST(TransferTest, ConstructorInitializer) {
   std::string Code = R"(
     struct target {
       int Bar;
 
       target(int Foo) : Bar(Foo) {
         int Qux = Bar;
         // [[p]]
       }
runDataflow(Code,
                     cast<IntegerValue>(Env.getValue(*FooDecl, SkipPast::None));
 
                 const ValueDecl *QuxDecl = findValueDecl(ASTCtx, "Qux");
                 ASSERT_THAT(QuxDecl, NotNull());
                 EXPECT_EQ(Env.getValue(*QuxDecl, SkipPast::None), FooVal);
               });
 }
 
-TEST_F(TransferTest, DefaultInitializer) {
+TEST(TransferTest, DefaultInitializer) {
   std::string Code = R"(
     struct target {
       int Bar;
       int Baz = Bar;
 
       target(int Foo) : Bar(Foo) {
         int Qux = Baz;
         // [[p]]
runDataflow(Code,
                     cast<IntegerValue>(Env.getValue(*FooDecl, SkipPast::None));
 
                 const ValueDecl *QuxDecl = findValueDecl(ASTCtx, "Qux");
                 ASSERT_THAT(QuxDecl, NotNull());
                 EXPECT_EQ(Env.getValue(*QuxDecl, SkipPast::None), FooVal);
               });
 }
 
-TEST_F(TransferTest, DefaultInitializerReference) {
+TEST(TransferTest, DefaultInitializerReference) {
   std::string Code = R"(
     struct target {
       int &Bar;
       int &Baz = Bar;
 
       target(int &Foo) : Bar(Foo) {
         int &Qux = Baz;
         // [[p]]
runDataflow(
         ASSERT_THAT(QuxDecl, NotNull());
 
         const auto *QuxVal =
             cast<ReferenceValue>(Env.getValue(*QuxDecl, SkipPast::None));
         EXPECT_EQ(&QuxVal->getReferentLoc(), &FooVal->getReferentLoc());
       });
 }
 
-TEST_F(TransferTest, TemporaryObject) {
+TEST(TransferTest, TemporaryObject) {
   std::string Code = R"(
     struct A {
       int Bar;
     };
 
     void target() {
       A Foo = A();
       // [[p]]
runDataflow(
             cast<ScalarStorageLocation>(&FooLoc->getChild(*BarDecl));
 
         const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
         const auto *BarVal = cast<IntegerValue>(FooVal->getChild(*BarDecl));
         EXPECT_EQ(Env.getValue(*BarLoc), BarVal);
       });
 }
 
-TEST_F(TransferTest, ElidableConstructor) {
+TEST(TransferTest, ElidableConstructor) {
   // This test is effectively the same as TransferTest.TemporaryObject, but
   // the code is compiled as C++ 14.
   std::string Code = R"(
     struct A {
       int Bar;
     };
 
     void target() {
runDataflow(
 
         const auto *FooVal = cast<StructValue>(Env.getValue(*FooLoc));
         const auto *BarVal = cast<IntegerValue>(FooVal->getChild(*BarDecl));
         EXPECT_EQ(Env.getValue(*BarLoc), BarVal);
       },
       LangStandard::lang_cxx14);
 }
 
-TEST_F(TransferTest, AssignmentOperator) {
+TEST(TransferTest, AssignmentOperator) {
   std::string Code = R"(
     struct A {
       int Baz;
     };
 
     void target() {
       A Foo;
       A Bar;
runDataflow(
         const auto *FooBazVal2 =
             cast<IntegerValue>(Env2.getValue(FooLoc1->getChild(*BazDecl)));
         const auto *BarBazVal2 =
             cast<IntegerValue>(Env2.getValue(BarLoc1->getChild(*BazDecl)));
         EXPECT_EQ(FooBazVal2, BarBazVal2);
       });
 }
 
-TEST_F(TransferTest, CopyConstructor) {
+TEST(TransferTest, CopyConstructor) {
   std::string Code = R"(
     struct A {
       int Baz;
     };
 
     void target() {
       A Foo;
       A Bar = Foo;
runDataflow(
         const auto *FooBazVal =
             cast<IntegerValue>(Env.getValue(FooLoc->getChild(*BazDecl)));
         const auto *BarBazVal =
             cast<IntegerValue>(Env.getValue(BarLoc->getChild(*BazDecl)));
         EXPECT_EQ(FooBazVal, BarBazVal);
       });
 }
 
-TEST_F(TransferTest, CopyConstructorWithParens) {
+TEST(TransferTest, CopyConstructorWithParens) {
   std::string Code = R"(
     struct A {
       int Baz;
     };
 
     void target() {
       A Foo;
       A Bar((A(Foo)));
runDataflow(
         const auto *FooBazVal =
             cast<IntegerValue>(Env.getValue(FooLoc->getChild(*BazDecl)));
         const auto *BarBazVal =
             cast<IntegerValue>(Env.getValue(BarLoc->getChild(*BazDecl)));
         EXPECT_EQ(FooBazVal, BarBazVal);
       });
 }
 
-TEST_F(TransferTest, MoveConstructor) {
+TEST(TransferTest, MoveConstructor) {
   std::string Code = R"(
     namespace std {
 
     template <typename T> struct remove_reference      { using type = T; };
     template <typename T> struct remove_reference<T&>  { using type = T; };
     template <typename T> struct remove_reference<T&&> { using type = T; };
 
     template <typename T>
runDataflow(
         EXPECT_EQ(FooVal2, BarVal1);
 
         const auto *FooBazVal2 =
             cast<IntegerValue>(Env2.getValue(FooLoc1->getChild(*BazDecl)));
         EXPECT_EQ(FooBazVal2, BarBazVal1);
       });
 }
 
-TEST_F(TransferTest, BindTemporary) {
+TEST(TransferTest, BindTemporary) {
   std::string Code = R"(
     struct A {
       virtual ~A() = default;
 
       int Baz;
     };
 
     void target(A Foo) {
runDataflow(Code,
                 const auto &FooVal =
                     *cast<StructValue>(Env.getValue(*FooDecl, SkipPast::None));
                 const auto *BarVal =
                     cast<IntegerValue>(Env.getValue(*BarDecl, SkipPast::None));
                 EXPECT_EQ(BarVal, FooVal.getChild(*BazDecl));
               });
 }
 
-TEST_F(TransferTest, StaticCast) {
+TEST(TransferTest, StaticCast) {
   std::string Code = R"(
     void target(int Foo) {
       int Bar = static_cast<int>(Foo);
       // [[p]]
     }
   )";
   runDataflow(Code,
               [](llvm::ArrayRef<
runDataflow(Code,
                 const auto *FooVal = Env.getValue(*FooDecl, SkipPast::None);
                 const auto *BarVal = Env.getValue(*BarDecl, SkipPast::None);
                 EXPECT_TRUE(isa<IntegerValue>(FooVal));
                 EXPECT_TRUE(isa<IntegerValue>(BarVal));
                 EXPECT_EQ(FooVal, BarVal);
               });
 }
 
-TEST_F(TransferTest, IntegralCast) {
+TEST(TransferTest, IntegralCast) {
   std::string Code = R"(
     void target(int Foo) {
       long Bar = Foo;
       // [[p]]
     }
   )";
   runDataflow(Code,
               [](llvm::ArrayRef<
runDataflow(Code,
                 const auto *FooVal = Env.getValue(*FooDecl, SkipPast::None);
                 const auto *BarVal = Env.getValue(*BarDecl, SkipPast::None);
                 EXPECT_TRUE(isa<IntegerValue>(FooVal));
                 EXPECT_TRUE(isa<IntegerValue>(BarVal));
                 EXPECT_EQ(FooVal, BarVal);
               });
 }
 
-TEST_F(TransferTest, IntegraltoBooleanCast) {
+TEST(TransferTest, IntegraltoBooleanCast) {
   std::string Code = R"(
     void target(int Foo) {
       bool Bar = Foo;
       // [[p]]
     }
   )";
   runDataflow(Code,
               [](llvm::ArrayRef<
runDataflow(Code,
 
                 const auto *FooVal = Env.getValue(*FooDecl, SkipPast::None);
                 const auto *BarVal = Env.getValue(*BarDecl, SkipPast::None);
                 EXPECT_TRUE(isa<IntegerValue>(FooVal));
                 EXPECT_TRUE(isa<BoolValue>(BarVal));
               });
 }
 
-TEST_F(TransferTest, IntegralToBooleanCastFromBool) {
+TEST(TransferTest, IntegralToBooleanCastFromBool) {
   std::string Code = R"(
     void target(bool Foo) {
       int Zab = Foo;
       bool Bar = Zab;
       // [[p]]
     }
   )";
   runDataflow(Code,
runDataflow(Code,
                 const auto *FooVal = Env.getValue(*FooDecl, SkipPast::None);
                 const auto *BarVal = Env.getValue(*BarDecl, SkipPast::None);
                 EXPECT_TRUE(isa<BoolValue>(FooVal));
                 EXPECT_TRUE(isa<BoolValue>(BarVal));
                 EXPECT_EQ(FooVal, BarVal);
               });
 }
 
-TEST_F(TransferTest, NullToPointerCast) {
+TEST(TransferTest, NullToPointerCast) {
   std::string Code = R"(
     struct Baz {};
     void target() {
       int *FooX = nullptr;
       int *FooY = nullptr;
       bool **Bar = nullptr;
       Baz *Baz = nullptr;
       // [[p]]
runDataflow(Code,
                 EXPECT_THAT(Env.getValue(BarPointeeLoc), IsNull());
 
                 const StorageLocation &BazPointeeLoc = BazVal->getPointeeLoc();
                 EXPECT_TRUE(isa<AggregateStorageLocation>(BazPointeeLoc));
                 EXPECT_THAT(Env.getValue(BazPointeeLoc), IsNull());
               });
 }
 
-TEST_F(TransferTest, NullToMemberPointerCast) {
+TEST(TransferTest, NullToMemberPointerCast) {
   std::string Code = R"(
     struct Foo {};
     void target(Foo *Foo) {
       int Foo::*MemberPointer = nullptr;
       // [[p]]
     }
   )";
   runDataflow(
runDataflow(
         const auto *MemberPointerVal = cast<PointerValue>(
             Env.getValue(*MemberPointerDecl, SkipPast::None));
 
         const StorageLocation &MemberLoc = MemberPointerVal->getPointeeLoc();
         EXPECT_THAT(Env.getValue(MemberLoc), IsNull());
       });
 }
 
-TEST_F(TransferTest, AddrOfValue) {
+TEST(TransferTest, AddrOfValue) {
   std::string Code = R"(
     void target() {
       int Foo;
       int *Bar = &Foo;
       // [[p]]
     }
   )";
   runDataflow(Code,
runDataflow(Code,
                 const auto *FooLoc = cast<ScalarStorageLocation>(
                     Env.getStorageLocation(*FooDecl, SkipPast::None));
                 const auto *BarVal =
                     cast<PointerValue>(Env.getValue(*BarDecl, SkipPast::None));
                 EXPECT_EQ(&BarVal->getPointeeLoc(), FooLoc);
               });
 }
 
-TEST_F(TransferTest, AddrOfReference) {
+TEST(TransferTest, AddrOfReference) {
   std::string Code = R"(
     void target(int *Foo) {
       int *Bar = &(*Foo);
       // [[p]]
     }
   )";
   runDataflow(Code,
               [](llvm::ArrayRef<
runDataflow(Code,
                 const auto *FooVal =
                     cast<PointerValue>(Env.getValue(*FooDecl, SkipPast::None));
                 const auto *BarVal =
                     cast<PointerValue>(Env.getValue(*BarDecl, SkipPast::None));
                 EXPECT_EQ(&BarVal->getPointeeLoc(), &FooVal->getPointeeLoc());
               });
 }
 
-TEST_F(TransferTest, DerefDependentPtr) {
+TEST(TransferTest, DerefDependentPtr) {
   std::string Code = R"(
     template <typename T>
     void target(T *Foo) {
       T &Bar = *Foo;
       /*[[p]]*/
     }
   )";
   runDataflow(
runDataflow(
         const auto *FooVal =
             cast<PointerValue>(Env.getValue(*FooDecl, SkipPast::None));
         const auto *BarVal =
             cast<ReferenceValue>(Env.getValue(*BarDecl, SkipPast::None));
         EXPECT_EQ(&BarVal->getReferentLoc(), &FooVal->getPointeeLoc());
       });
 }
 
-TEST_F(TransferTest, VarDeclInitAssignConditionalOperator) {
+TEST(TransferTest, VarDeclInitAssignConditionalOperator) {
   std::string Code = R"(
     struct A {};
 
     void target(A Foo, A Bar, bool Cond) {
       A Baz = Cond ?  Foo : Bar;
       /*[[p]]*/
     }
   )";
runDataflow(
             dyn_cast<StructValue>(Env.getValue(*BazDecl, SkipPast::None));
         ASSERT_THAT(BazVal, NotNull());
 
         EXPECT_NE(BazVal, FooVal);
         EXPECT_NE(BazVal, BarVal);
       });
 }
 
-TEST_F(TransferTest, VarDeclInDoWhile) {
+TEST(TransferTest, VarDeclInDoWhile) {
   std::string Code = R"(
     void target(int *Foo) {
       do {
         int Bar = *Foo;
       } while (true);
       (void)0;
       /*[[p]]*/
     }
runDataflow(Code,
                 const auto *BarVal = dyn_cast_or_null<IntegerValue>(
                     Env.getValue(*BarDecl, SkipPast::None));
                 ASSERT_THAT(BarVal, NotNull());
 
                 EXPECT_EQ(BarVal, FooPointeeVal);
               });
 }
 
-TEST_F(TransferTest, AggregateInitialization) {
+TEST(TransferTest, AggregateInitialization) {
   std::string BracesCode = R"(
     struct A {
       int Foo;
     };
 
     struct B {
       int Bar;
       A Baz;
runDataflow(
 
           EXPECT_EQ(QuuxVal->getChild(*BarDecl), BarArgVal);
           EXPECT_EQ(BazVal->getChild(*FooDecl), FooArgVal);
           EXPECT_EQ(QuuxVal->getChild(*QuxDecl), QuxArgVal);
         });
   }
 }
 
-TEST_F(TransferTest, AssignToUnionMember) {
+TEST(TransferTest, AssignToUnionMember) {
   std::string Code = R"(
     union A {
       int Foo;
     };
 
     void target(int Bar) {
       A Baz;
       Baz.Foo = Bar;
runDataflow(Code,
                     Env.getStorageLocation(*BazDecl, SkipPast::None));
                 ASSERT_THAT(BazLoc, NotNull());
 
                 // FIXME: Add support for union types.
                 EXPECT_THAT(Env.getValue(*BazLoc), IsNull());
               });
 }
 
-TEST_F(TransferTest, AssignFromBoolLiteral) {
+TEST(TransferTest, AssignFromBoolLiteral) {
   std::string Code = R"(
     void target() {
       bool Foo = true;
       bool Bar = false;
       // [[p]]
     }
   )";
   runDataflow(Code,
runDataflow(Code,
                     Env.getValue(*BarDecl, SkipPast::None));
                 ASSERT_THAT(BarVal, NotNull());
 
                 EXPECT_EQ(FooVal, &Env.getBoolLiteralValue(true));
                 EXPECT_EQ(BarVal, &Env.getBoolLiteralValue(false));
               });
 }
 
-TEST_F(TransferTest, AssignFromCompositeBoolExpression) {
+TEST(TransferTest, AssignFromCompositeBoolExpression) {
   {
     std::string Code = R"(
     void target(bool Foo, bool Bar, bool Qux) {
       bool Baz = (Foo) && (Bar || Qux);
       // [[p]]
     }
   )";
     runDataflow(
runDataflow(
           EXPECT_EQ(&FooLeftLeftSubVal.getLeftSubValue(), AVal);
           EXPECT_EQ(&FooLeftLeftSubVal.getRightSubValue(), BVal);
           EXPECT_EQ(&FooLeftSubVal.getRightSubValue(), CVal);
           EXPECT_EQ(&FooVal->getRightSubValue(), DVal);
         });
   }
 }
 
-TEST_F(TransferTest, AssignFromBoolNegation) {
+TEST(TransferTest, AssignFromBoolNegation) {
   std::string Code = R"(
     void target() {
       bool Foo = true;
       bool Bar = !(Foo);
       // [[p]]
     }
   )";
   runDataflow(Code,
runDataflow(Code,
                 const auto *BarVal = dyn_cast_or_null<NegationValue>(
                     Env.getValue(*BarDecl, SkipPast::None));
                 ASSERT_THAT(BarVal, NotNull());
 
                 EXPECT_EQ(&BarVal->getSubVal(), FooVal);
               });
 }
 
-TEST_F(TransferTest, BuiltinExpect) {
+TEST(TransferTest, BuiltinExpect) {
   std::string Code = R"(
     void target(long Foo) {
       long Bar = __builtin_expect(Foo, true);
       /*[[p]]*/
     }
   )";
   runDataflow(Code,
               [](llvm::ArrayRef<
runDataflow(Code,
                 EXPECT_EQ(Env.getValue(*FooDecl, SkipPast::None),
                           Env.getValue(*BarDecl, SkipPast::None));
               });
 }
 
 // `__builtin_expect` takes and returns a `long` argument, so other types
 // involve casts. This verifies that we identify the input and output in that
 // case.
-TEST_F(TransferTest, BuiltinExpectBoolArg) {
+TEST(TransferTest, BuiltinExpectBoolArg) {
   std::string Code = R"(
     void target(bool Foo) {
       bool Bar = __builtin_expect(Foo, true);
       /*[[p]]*/
     }
   )";
   runDataflow(Code,
               [](llvm::ArrayRef<
runDataflow(Code,
                 const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
                 ASSERT_THAT(BarDecl, NotNull());
 
                 EXPECT_EQ(Env.getValue(*FooDecl, SkipPast::None),
                           Env.getValue(*BarDecl, SkipPast::None));
               });
 }
 
-TEST_F(TransferTest, BuiltinUnreachable) {
+TEST(TransferTest, BuiltinUnreachable) {
   std::string Code = R"(
     void target(bool Foo) {
       bool Bar = false;
       if (Foo)
         Bar = Foo;
       else
         __builtin_unreachable();
       (void)0;
runDataflow(Code,
                 // `__builtin_unreachable` promises that the code is
                 // unreachable, so the compiler treats the "then" branch as the
                 // only possible predecessor of this statement.
                 EXPECT_EQ(Env.getValue(*FooDecl, SkipPast::None),
                           Env.getValue(*BarDecl, SkipPast::None));
               });
 }
 
-TEST_F(TransferTest, BuiltinTrap) {
+TEST(TransferTest, BuiltinTrap) {
   std::string Code = R"(
     void target(bool Foo) {
       bool Bar = false;
       if (Foo)
         Bar = Foo;
       else
         __builtin_trap();
       (void)0;
runDataflow(Code,
 
                 // `__builtin_trap` ensures program termination, so only the
                 // "then" branch is a predecessor of this statement.
                 EXPECT_EQ(Env.getValue(*FooDecl, SkipPast::None),
                           Env.getValue(*BarDecl, SkipPast::None));
               });
 }
 
-TEST_F(TransferTest, BuiltinDebugTrap) {
+TEST(TransferTest, BuiltinDebugTrap) {
   std::string Code = R"(
     void target(bool Foo) {
       bool Bar = false;
       if (Foo)
         Bar = Foo;
       else
         __builtin_debugtrap();
       (void)0;
runDataflow(Code,
                 ASSERT_THAT(BarDecl, NotNull());
 
                 // `__builtin_debugtrap` doesn't ensure program termination.
                 EXPECT_NE(Env.getValue(*FooDecl, SkipPast::None),
                           Env.getValue(*BarDecl, SkipPast::None));
               });
 }
 
-TEST_F(TransferTest, StaticIntSingleVarDecl) {
+TEST(TransferTest, StaticIntSingleVarDecl) {
   std::string Code = R"(
     void target() {
       static int Foo;
       // [[p]]
     }
   )";
   runDataflow(Code,
               [](llvm::ArrayRef<
runDataflow(Code,
                     Env.getStorageLocation(*FooDecl, SkipPast::None);
                 ASSERT_TRUE(isa_and_nonnull<ScalarStorageLocation>(FooLoc));
 
                 const Value *FooVal = Env.getValue(*FooLoc);
                 EXPECT_TRUE(isa_and_nonnull<IntegerValue>(FooVal));
               });
 }
 
-TEST_F(TransferTest, StaticIntGroupVarDecl) {
+TEST(TransferTest, StaticIntGroupVarDecl) {
   std::string Code = R"(
     void target() {
       static int Foo, Bar;
       (void)0;
       // [[p]]
     }
   )";
   runDataflow(Code,
runDataflow(Code,
 
                 const Value *BarVal = Env.getValue(*BarLoc);
                 EXPECT_TRUE(isa_and_nonnull<IntegerValue>(BarVal));
 
                 EXPECT_NE(FooVal, BarVal);
               });
 }
 
-TEST_F(TransferTest, GlobalIntVarDecl) {
+TEST(TransferTest, GlobalIntVarDecl) {
   std::string Code = R"(
     static int Foo;
 
     void target() {
       int Bar = Foo;
       int Baz = Foo;
       // [[p]]
     }
runDataflow(Code,
                 const Value *BarVal =
                     cast<IntegerValue>(Env.getValue(*BarDecl, SkipPast::None));
                 const Value *BazVal =
                     cast<IntegerValue>(Env.getValue(*BazDecl, SkipPast::None));
                 EXPECT_EQ(BarVal, BazVal);
               });
 }
 
-TEST_F(TransferTest, StaticMemberIntVarDecl) {
+TEST(TransferTest, StaticMemberIntVarDecl) {
   std::string Code = R"(
     struct A {
       static int Foo;
     };
 
     void target(A a) {
       int Bar = a.Foo;
       int Baz = a.Foo;
runDataflow(Code,
                 const Value *BarVal =
                     cast<IntegerValue>(Env.getValue(*BarDecl, SkipPast::None));
                 const Value *BazVal =
                     cast<IntegerValue>(Env.getValue(*BazDecl, SkipPast::None));
                 EXPECT_EQ(BarVal, BazVal);
               });
 }
 
-TEST_F(TransferTest, StaticMemberRefVarDecl) {
+TEST(TransferTest, StaticMemberRefVarDecl) {
   std::string Code = R"(
     struct A {
       static int &Foo;
     };
 
     void target(A a) {
       int Bar = a.Foo;
       int Baz = a.Foo;
runDataflow(Code,
                 const Value *BarVal =
                     cast<IntegerValue>(Env.getValue(*BarDecl, SkipPast::None));
                 const Value *BazVal =
                     cast<IntegerValue>(Env.getValue(*BazDecl, SkipPast::None));
                 EXPECT_EQ(BarVal, BazVal);
               });
 }
 
-TEST_F(TransferTest, AssignMemberBeforeCopy) {
+TEST(TransferTest, AssignMemberBeforeCopy) {
   std::string Code = R"(
     struct A {
       int Foo;
     };
 
     void target() {
       A A1;
       A A2;
runDataflow(Code,
                     cast<IntegerValue>(Env.getValue(*BarDecl, SkipPast::None));
 
                 const auto *A2Val =
                     cast<StructValue>(Env.getValue(*A2Decl, SkipPast::None));
                 EXPECT_EQ(A2Val->getChild(*FooDecl), BarVal);
               });
 }
 
-TEST_F(TransferTest, BooleanEquality) {
+TEST(TransferTest, BooleanEquality) {
   std::string Code = R"(
     void target(bool Bar) {
       bool Foo = true;
       if (Bar == Foo) {
         (void)0;
         /*[[p-then]]*/
       } else {
         (void)0;
runDataflow(
         EXPECT_TRUE(EnvThen.flowConditionImplies(BarValThen));
 
         auto &BarValElse =
             *cast<BoolValue>(EnvElse.getValue(*BarDecl, SkipPast::None));
         EXPECT_FALSE(EnvElse.flowConditionImplies(BarValElse));
       });
 }
 
-TEST_F(TransferTest, BooleanInequality) {
+TEST(TransferTest, BooleanInequality) {
   std::string Code = R"(
     void target(bool Bar) {
       bool Foo = true;
       if (Bar != Foo) {
         (void)0;
         /*[[p-then]]*/
       } else {
         (void)0;
runDataflow(
         EXPECT_FALSE(EnvThen.flowConditionImplies(BarValThen));
 
         auto &BarValElse =
             *cast<BoolValue>(EnvElse.getValue(*BarDecl, SkipPast::None));
         EXPECT_TRUE(EnvElse.flowConditionImplies(BarValElse));
       });
 }
 
-TEST_F(TransferTest, CorrelatedBranches) {
+TEST(TransferTest, CorrelatedBranches) {
   std::string Code = R"(
     void target(bool B, bool C) {
       if (B) {
         return;
       }
       (void)0;
       /*[[p0]]*/
       if (C) {
runDataflow(
           ASSERT_THAT(Results[0], Pair("p2", _));
           const Environment &Env = Results[0].second.Env;
           auto &CVal = *cast<BoolValue>(Env.getValue(*CDecl, SkipPast::None));
           EXPECT_TRUE(Env.flowConditionImplies(CVal));
         }
       });
 }
 
-TEST_F(TransferTest, LoopWithAssignmentConverges) {
+TEST(TransferTest, LoopWithAssignmentConverges) {
   std::string Code = R"(
 
     bool &foo();
 
     void target() {
        do {
         bool Bar = foo();
         if (Bar) break;
runDataflow(
         const ValueDecl *BarDecl = findValueDecl(ASTCtx, "Bar");
         ASSERT_THAT(BarDecl, NotNull());
 
         auto &BarVal = *cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::None));
         EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(BarVal)));
       });
 }
 
-TEST_F(TransferTest, LoopWithReferenceAssignmentConverges) {
+TEST(TransferTest, LoopWithReferenceAssignmentConverges) {
   std::string Code = R"(
 
     bool &foo();
 
     void target() {
        do {
         bool& Bar = foo();
         if (Bar) break;
runDataflow(
         ASSERT_THAT(BarDecl, NotNull());
 
         auto &BarVal =
             *cast<BoolValue>(Env.getValue(*BarDecl, SkipPast::Reference));
         EXPECT_TRUE(Env.flowConditionImplies(Env.makeNot(BarVal)));
       });
 }
 
-TEST_F(TransferTest, LoopWithStructReferenceAssignmentConverges) {
+TEST(TransferTest, LoopWithStructReferenceAssignmentConverges) {
   std::string Code = R"(
     struct Lookup {
       int x;
     };
 
     void target(Lookup val, bool b) {
       const Lookup* l = nullptr;
       while (b) {
runDataflow(
 
         // The loop body may not have been executed, so we should not conclude
         // that `l` points to `val`.
         EXPECT_NE(&LVal->getPointeeLoc(),
                   OuterEnv.getStorageLocation(*ValDecl, SkipPast::Reference));
       });
 }
 
-TEST_F(TransferTest, DoesNotCrashOnUnionThisExpr) {
+TEST(TransferTest, DoesNotCrashOnUnionThisExpr) {
   std::string Code = R"(
     union Union {
       int A;
       float B;
     };
 
     void foo() {
       Union A;
       Union B;
       A = B;
     }
   )";
   // This is a crash regression test when calling the transfer function on a
   // `CXXThisExpr` that refers to a union.
   runDataflow(
       Code,
       [](llvm::ArrayRef<
              std::pair<std::string, DataflowAnalysisState<NoopLattice>>>,
          ASTContext &) {},
       LangStandard::lang_cxx17, /*ApplyBuiltinTransfer=*/true, "operator=");
 }
 
-TEST_F(TransferTest, StructuredBindingAssignFromStructIntMembersToRefs) {
+TEST(TransferTest, StructuredBindingAssignFromStructIntMembersToRefs) {
   std::string Code = R"(
     struct A {
       int Foo;
       int Bar;
     };
 
     void target() {
       int Qux;
runDataflow(
         const StorageLocation *BoundBarRefLoc =
             Env.getStorageLocation(*BoundBarRefDecl, SkipPast::Reference);
         EXPECT_EQ(BoundBarRefLoc, BarRefLoc);
 
         EXPECT_EQ(Env.getValue(*BoundFooRefDecl, SkipPast::Reference), QuxVal);
       });
 }
 
-TEST_F(TransferTest, StructuredBindingAssignFromStructRefMembersToRefs) {
+TEST(TransferTest, StructuredBindingAssignFromStructRefMembersToRefs) {
   std::string Code = R"(
     struct A {
       int &Foo;
       int &Bar;
     };
 
     void target(A Baz) {
       int Qux;
runDataflow(
         const StorageLocation *BoundBarRefLoc =
             Env.getStorageLocation(*BoundBarRefDecl, SkipPast::Reference);
         EXPECT_EQ(BoundBarRefLoc, BarRefLoc);
 
         EXPECT_EQ(Env.getValue(*BoundFooRefDecl, SkipPast::Reference), QuxVal);
       });
 }
 
-TEST_F(TransferTest, StructuredBindingAssignFromStructIntMembersToInts) {
+TEST(TransferTest, StructuredBindingAssignFromStructIntMembersToInts) {
   std::string Code = R"(
     struct A {
       int Foo;
       int Bar;
     };
 
     void target() {
       int Qux;
runDataflow(
         const StorageLocation *BoundBarLoc =
             Env.getStorageLocation(*BoundBarDecl, SkipPast::Reference);
         EXPECT_NE(BoundBarLoc, BarRefLoc);
 
         EXPECT_EQ(Env.getValue(*BoundFooDecl, SkipPast::Reference), QuxVal);
       });
 }
 
-TEST_F(TransferTest, BinaryOperatorComma) {
+TEST(TransferTest, BinaryOperatorComma) {
   std::string Code = R"(
     void target(int Foo, int Bar) {
       int &Baz = (Foo, Bar);
       // [[p]]
     }
   )";
   runDataflow(Code,
               [](llvm::ArrayRef<
runDataflow(Code,
                 ASSERT_THAT(BarLoc, NotNull());
 
                 const StorageLocation *BazLoc =
                     Env.getStorageLocation(*BazDecl, SkipPast::Reference);
                 EXPECT_EQ(BazLoc, BarLoc);
               });
 }
 
-TEST_F(TransferTest, IfStmtBranchExtendsFlowCondition) {
+TEST(TransferTest, IfStmtBranchExtendsFlowCondition) {
   std::string Code = R"(
     void target(bool Foo) {
       if (Foo) {
         (void)0;
         // [[if_then]]
       } else {
         (void)0;
         // [[if_else]]
runDataflow(
         EXPECT_TRUE(ThenEnv.flowConditionImplies(ThenFooVal));
 
         BoolValue &ElseFooVal =
             *cast<BoolValue>(ElseEnv.getValue(*FooDecl, SkipPast::None));
         EXPECT_TRUE(ElseEnv.flowConditionImplies(ElseEnv.makeNot(ElseFooVal)));
       });
 }
 
-TEST_F(TransferTest, WhileStmtBranchExtendsFlowCondition) {
+TEST(TransferTest, WhileStmtBranchExtendsFlowCondition) {
   std::string Code = R"(
     void target(bool Foo) {
       while (Foo) {
         (void)0;
         // [[loop_body]]
       }
       (void)0;
       // [[after_loop]]
runDataflow(
 
         BoolValue &AfterLoopFooVal =
             *cast<BoolValue>(AfterLoopEnv.getValue(*FooDecl, SkipPast::None));
         EXPECT_TRUE(AfterLoopEnv.flowConditionImplies(
             AfterLoopEnv.makeNot(AfterLoopFooVal)));
       });
 }
 
-TEST_F(TransferTest, DoWhileStmtBranchExtendsFlowCondition) {
+TEST(TransferTest, DoWhileStmtBranchExtendsFlowCondition) {
   std::string Code = R"(
     void target(bool Foo) {
       bool Bar = true;
       do {
         (void)0;
         // [[loop_body]]
         Bar = false;
       } while (Foo);
runDataflow(
             *cast<BoolValue>(AfterLoopEnv.getValue(*BarDecl, SkipPast::None));
         EXPECT_TRUE(AfterLoopEnv.flowConditionImplies(
             AfterLoopEnv.makeNot(AfterLoopFooVal)));
         EXPECT_TRUE(AfterLoopEnv.flowConditionImplies(
             AfterLoopEnv.makeNot(AfterLoopBarVal)));
       });
 }
 
-TEST_F(TransferTest, ForStmtBranchExtendsFlowCondition) {
+TEST(TransferTest, ForStmtBranchExtendsFlowCondition) {
   std::string Code = R"(
     void target(bool Foo) {
       for (; Foo;) {
         (void)0;
         // [[loop_body]]
       }
       (void)0;
       // [[after_loop]]
runDataflow(
 
         BoolValue &AfterLoopFooVal =
             *cast<BoolValue>(AfterLoopEnv.getValue(*FooDecl, SkipPast::None));
         EXPECT_TRUE(AfterLoopEnv.flowConditionImplies(
             AfterLoopEnv.makeNot(AfterLoopFooVal)));
       });
 }
 
-TEST_F(TransferTest, ForStmtBranchWithoutConditionDoesNotExtendFlowCondition) {
+TEST(TransferTest, ForStmtBranchWithoutConditionDoesNotExtendFlowCondition) {
   std::string Code = R"(
     void target(bool Foo) {
       for (;;) {
         (void)0;
         // [[loop_body]]
       }
     }
   )";