[ASTImporter] Refactor unittests to be able to parameterize them in a more flexible way

[martong]

Summary

Currently TestImportBase is derived from ParameterizedTestsFixture
which explicitly states that the gtest parameter can be only an
ArgVector. This is a limitation when we want to create tests which may
have different parameters.
E.g. we would like to create tests where we can combine different test
parameters. So, for example we'd like gtest to be able to provide
parameters of <std::tuple<ArgVector, const char *> instead of a simple
ArgVector.

[balazske]

unittests/AST/ASTImporterTest.cpp

15

Define of this is related to the new visibility tests, but not a problem is this remains here (there is another not strictly related thing: The new Import template).

[shafik]

unittests/AST/ASTImporterTest.cpp

464

Is this being used in this PR?

[martong]

• Remove unrelated hunks

[martong]

Update: I just removed the unrelated changes.

[shafik]

This looks reasonable to me but I don't have strong opinions on refactoring gtest tests.

[aaron.ballman]

LGTM, though I am by no means a gtest expert.

unittests/AST/ASTImporterTest.cpp

 //===- unittest/AST/ASTImporterTest.cpp - AST node import test ------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Tests for the correct import of AST nodes from one AST context to another.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/ASTImporter.h"
 #include "MatchVerifier.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclContextInternals.h"
 #include "clang/AST/ASTImporter.h"
 #include "clang/AST/ASTImporterLookupTable.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Tooling/Tooling.h"
 
 #include "DeclMatcher.h"

 }
 
 const StringRef DeclToImportID = "declToImport";
 const StringRef DeclToVerifyID = "declToVerify";
 
 // Common base for the different families of ASTImporter tests that are
 // parameterized on the compiler options which may result a different AST. E.g.
 // -fms-compatibility or -fdelayed-template-parsing.
-struct ParameterizedTestsFixture : ::testing::TestWithParam<ArgVector> {
+class CompilerOptionSpecificTest : public ::testing::Test {
+protected:
+  // Return the extra arguments appended to runtime options at compilation.
+  virtual ArgVector getExtraArgs() const { return ArgVector(); }
 
   // Returns the argument vector used for a specific language option, this set
   // can be tweaked by the test parameters.
   ArgVector getArgVectorForLanguage(Language Lang) const {
     ArgVector Args = getBasicRunOptionsForLanguage(Lang);
-    ArgVector ExtraArgs = GetParam();
+    ArgVector ExtraArgs = getExtraArgs();
     for (const auto &Arg : ExtraArgs) {
       Args.push_back(Arg);
     }
     return Args;
   }
-
 };
 
+auto DefaultTestValuesForRunOptions = ::testing::Values(
+    ArgVector(), ArgVector{"-fdelayed-template-parsing"},
+    ArgVector{"-fms-compatibility"},
+    ArgVector{"-fdelayed-template-parsing", "-fms-compatibility"});
+
 // Base class for those tests which use the family of `testImport` functions.
-class TestImportBase : public ParameterizedTestsFixture {
+class TestImportBase : public CompilerOptionSpecificTest,
+                       public ::testing::WithParamInterface<ArgVector> {
 
   template <typename NodeType>
   NodeType importNode(ASTUnit *From, ASTUnit *To, ASTImporter &Importer,
                       NodeType Node) {
     ASTContext &ToCtx = To->getASTContext();
 
     // Add 'From' file to virtual file system so importer can 'find' it
     // while importing SourceLocations. It is safe to add same file multiple
testImport(const std::string &FromCode, const ArgVector &FromArgs,
              const BindableMatcher<NodeType> &VerificationMatcher) {
     return testImport(
         FromCode, FromArgs, ToCode, ToArgs, Verifier,
         translationUnitDecl(
             has(namedDecl(hasName(DeclToImportID)).bind(DeclToImportID))),
         VerificationMatcher);
   }
 
+protected:
+  ArgVector getExtraArgs() const override { return GetParam(); }
+
 public:
 
   /// Test how AST node named "declToImport" located in the translation unit
   /// of "FromCode" virtual file is imported to "ToCode" virtual file.
   /// The verification is done by running AMatcher over the imported node.
   template <typename NodeType, typename MatcherType>
   void testImport(const std::string &FromCode, Language FromLang,
                   const std::string &ToCode, Language ToLang,

 template <typename T> RecordDecl *getRecordDecl(T *D) {
   auto *ET = cast<ElaboratedType>(D->getType().getTypePtr());
   return cast<RecordType>(ET->getNamedType().getTypePtr())->getDecl();
 }
 
 // This class provides generic methods to write tests which can check internal
 // attributes of AST nodes like getPreviousDecl(), isVirtual(), etc. Also,
 // this fixture makes it possible to import from several "From" contexts.
-class ASTImporterTestBase : public ParameterizedTestsFixture {
+class ASTImporterTestBase : public CompilerOptionSpecificTest {
 
   const char *const InputFileName = "input.cc";
   const char *const OutputFileName = "output.cc";
 
   // Buffer for the To context, must live in the test scope.
   std::string ToCode;
 
   // Represents a "From" translation unit and holds an importer object which we
public:
   // The different instances of the param From may have different ASTContext.
   Decl *Import(Decl *From, Language ToLang) {
     lazyInitToAST(ToLang, "", OutputFileName);
     TU *FromTU = findFromTU(From);
     assert(LookupTablePtr);
     return FromTU->import(*LookupTablePtr, ToAST.get(), From);
   }
 
   QualType ImportType(QualType FromType, Decl *TUDecl, Language ToLang) {
     lazyInitToAST(ToLang, "", OutputFileName);
     TU *FromTU = findFromTU(TUDecl);
     assert(LookupTablePtr);
     return FromTU->import(*LookupTablePtr, ToAST.get(), FromType);
    }
 
   ~ASTImporterTestBase() {
     if (!::testing::Test::HasFailure()) return;
 
     for (auto &Tu : FromTUs) {
       assert(Tu.Unit);
       llvm::errs() << "FromAST:\n";
       Tu.Unit->getASTContext().getTranslationUnitDecl()->dump();
       llvm::errs() << "\n";
     }
     if (ToAST) {
       llvm::errs() << "ToAST:\n";
       ToAST->getASTContext().getTranslationUnitDecl()->dump();
     }
   }
 };
 
+class ASTImporterOptionSpecificTestBase
+    : public ASTImporterTestBase,
+      public ::testing::WithParamInterface<ArgVector> {
+protected:
+  ArgVector getExtraArgs() const override { return GetParam(); }
+};
+
 struct ImportExpr : TestImportBase {};
 struct ImportType : TestImportBase {};
 struct ImportDecl : TestImportBase {};
 
-struct CanonicalRedeclChain : ASTImporterTestBase {};
+struct CanonicalRedeclChain : ASTImporterOptionSpecificTestBase {};
 
 TEST_P(CanonicalRedeclChain, ShouldBeConsequentWithMatchers) {
   Decl *FromTU = getTuDecl("void f();", Lang_CXX);
   auto Pattern = functionDecl(hasName("f"));
   auto *D0 = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
 
   auto Redecls = getCanonicalForwardRedeclChain(D0);
   ASSERT_EQ(Redecls.size(), 1u);
testImport("int declToImport() { "
              "  struct data_t d;"
              "  return 0;"
              "}",
              Lang_C, "", Lang_C, Verifier,
              functionDecl(hasBody(compoundStmt(
                  has(declStmt(hasSingleDecl(varDecl(hasName("d")))))))));
 }
 
-TEST_P(ASTImporterTestBase, ImportRecordTypeInFunc) {
+TEST_P(ASTImporterOptionSpecificTestBase, ImportRecordTypeInFunc) {
   Decl *FromTU = getTuDecl("int declToImport() { "
                            "  struct data_t {int a;int b;};"
                            "  struct data_t d;"
                            "  return 0;"
                            "}",
                            Lang_C, "input.c");
   auto *FromVar =
       FirstDeclMatcher<VarDecl>().match(FromTU, varDecl(hasName("d")));
   ASSERT_TRUE(FromVar);
   auto ToType =
       ImportType(FromVar->getType().getCanonicalType(), FromVar, Lang_C);
   EXPECT_FALSE(ToType.isNull());
 }
 
-TEST_P(ASTImporterTestBase, ImportRecordDeclInFuncParams) {
+TEST_P(ASTImporterOptionSpecificTestBase, ImportRecordDeclInFuncParams) {
   // This construct is not supported by ASTImporter.
   Decl *FromTU = getTuDecl(
       "int declToImport(struct data_t{int a;int b;} ***d){ return 0; }",
       Lang_C, "input.c");
   auto *From = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("declToImport")));
   ASSERT_TRUE(From);
   auto *To = Import(From, Lang_C);
   EXPECT_EQ(To, nullptr);
 }
 
-TEST_P(ASTImporterTestBase, ImportRecordDeclInFuncFromMacro) {
+TEST_P(ASTImporterOptionSpecificTestBase, ImportRecordDeclInFuncFromMacro) {
   Decl *FromTU = getTuDecl(
       "#define NONAME_SIZEOF(type) sizeof(struct{type *dummy;}) \n"
       "int declToImport(){ return NONAME_SIZEOF(int); }",
       Lang_C, "input.c");
   auto *From = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("declToImport")));
   ASSERT_TRUE(From);
   auto *To = Import(From, Lang_C);
   ASSERT_TRUE(To);
   EXPECT_TRUE(MatchVerifier<FunctionDecl>().match(
       To, functionDecl(hasName("declToImport"),
                        hasDescendant(unaryExprOrTypeTraitExpr()))));
 }
 
-TEST_P(ASTImporterTestBase, ImportRecordDeclInFuncParamsFromMacro) {
+TEST_P(ASTImporterOptionSpecificTestBase,
+       ImportRecordDeclInFuncParamsFromMacro) {
   // This construct is not supported by ASTImporter.
   Decl *FromTU = getTuDecl(
       "#define PAIR_STRUCT(type) struct data_t{type a;type b;} \n"
       "int declToImport(PAIR_STRUCT(int) ***d){ return 0; }",
       Lang_C, "input.c");
   auto *From = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("declToImport")));
   ASSERT_TRUE(From);
testImport(
       "template<typename T, int Size> class declToImport {"
       "  T data[Size];"
       "};",
       Lang_CXX, "", Lang_CXX, Verifier,
       classTemplateDecl(has(cxxRecordDecl(
           has(fieldDecl(hasType(dependentSizedArrayType())))))));
 }
 
-TEST_P(ASTImporterTestBase, ImportOfTemplatedDeclOfClassTemplateDecl) {
+TEST_P(ASTImporterOptionSpecificTestBase,
+       ImportOfTemplatedDeclOfClassTemplateDecl) {
   Decl *FromTU = getTuDecl("template<class X> struct S{};", Lang_CXX);
   auto From =
       FirstDeclMatcher<ClassTemplateDecl>().match(FromTU, classTemplateDecl());
   ASSERT_TRUE(From);
   auto To = cast<ClassTemplateDecl>(Import(From, Lang_CXX));
   ASSERT_TRUE(To);
   Decl *ToTemplated = To->getTemplatedDecl();
   Decl *ToTemplated1 = Import(From->getTemplatedDecl(), Lang_CXX);
   EXPECT_TRUE(ToTemplated1);
   EXPECT_EQ(ToTemplated1, ToTemplated);
 }
 
-TEST_P(ASTImporterTestBase, ImportOfTemplatedDeclOfFunctionTemplateDecl) {
+TEST_P(ASTImporterOptionSpecificTestBase,
+       ImportOfTemplatedDeclOfFunctionTemplateDecl) {
   Decl *FromTU = getTuDecl("template<class X> void f(){}", Lang_CXX);
   auto From = FirstDeclMatcher<FunctionTemplateDecl>().match(
       FromTU, functionTemplateDecl());
   ASSERT_TRUE(From);
   auto To = cast<FunctionTemplateDecl>(Import(From, Lang_CXX));
   ASSERT_TRUE(To);
   Decl *ToTemplated = To->getTemplatedDecl();
   Decl *ToTemplated1 = Import(From->getTemplatedDecl(), Lang_CXX);
   EXPECT_TRUE(ToTemplated1);
   EXPECT_EQ(ToTemplated1, ToTemplated);
 }
 
-TEST_P(ASTImporterTestBase,
+TEST_P(ASTImporterOptionSpecificTestBase,
        ImportOfTemplatedDeclShouldImportTheClassTemplateDecl) {
   Decl *FromTU = getTuDecl("template<class X> struct S{};", Lang_CXX);
   auto FromFT =
       FirstDeclMatcher<ClassTemplateDecl>().match(FromTU, classTemplateDecl());
   ASSERT_TRUE(FromFT);
 
   auto ToTemplated =
       cast<CXXRecordDecl>(Import(FromFT->getTemplatedDecl(), Lang_CXX));
   EXPECT_TRUE(ToTemplated);
   auto ToTU = ToTemplated->getTranslationUnitDecl();
   auto ToFT =
       FirstDeclMatcher<ClassTemplateDecl>().match(ToTU, classTemplateDecl());
   EXPECT_TRUE(ToFT);
 }
 
-TEST_P(ASTImporterTestBase,
+TEST_P(ASTImporterOptionSpecificTestBase,
        ImportOfTemplatedDeclShouldImportTheFunctionTemplateDecl) {
   Decl *FromTU = getTuDecl("template<class X> void f(){}", Lang_CXX);
   auto FromFT = FirstDeclMatcher<FunctionTemplateDecl>().match(
       FromTU, functionTemplateDecl());
   ASSERT_TRUE(FromFT);
 
   auto ToTemplated =
       cast<FunctionDecl>(Import(FromFT->getTemplatedDecl(), Lang_CXX));
   EXPECT_TRUE(ToTemplated);
   auto ToTU = ToTemplated->getTranslationUnitDecl();
   auto ToFT = FirstDeclMatcher<FunctionTemplateDecl>().match(
       ToTU, functionTemplateDecl());
   EXPECT_TRUE(ToFT);
 }
 
-TEST_P(ASTImporterTestBase, ImportCorrectTemplatedDecl) {
+TEST_P(ASTImporterOptionSpecificTestBase, ImportCorrectTemplatedDecl) {
   auto Code =
         R"(
         namespace x {
           template<class X> struct S1{};
           template<class X> struct S2{};
           template<class X> struct S3{};
         }
         )";
TEST_P(ASTImporterOptionSpecificTestBase, ImportCorrectTemplatedDecl) {
   ASSERT_TRUE(To);
   auto ToTemplated = To->getTemplatedDecl();
   auto ToTemplated1 =
       cast<CXXRecordDecl>(Import(From->getTemplatedDecl(), Lang_CXX));
   EXPECT_TRUE(ToTemplated1);
   ASSERT_EQ(ToTemplated1, ToTemplated);
 }
 
-TEST_P(ASTImporterTestBase, ImportFunctionWithBackReferringParameter) {
+TEST_P(ASTImporterOptionSpecificTestBase,
+       ImportFunctionWithBackReferringParameter) {
   Decl *From, *To;
   std::tie(From, To) = getImportedDecl(
       R"(
       template <typename T> struct X {};
 
       void declToImport(int y, X<int> &x) {}
 
       template <> struct X<int> {
auto Matcher = functionDecl(hasName("declToImport"),
                               parameterCountIs(2),
                               hasParameter(0, hasName("y")),
                               hasParameter(1, hasName("x")),
                               hasParameter(1, hasType(asString("X<int> &"))));
   ASSERT_TRUE(Verifier.match(From, Matcher));
   EXPECT_TRUE(Verifier.match(To, Matcher));
 }
 
-TEST_P(ASTImporterTestBase,
+TEST_P(ASTImporterOptionSpecificTestBase,
        TUshouldNotContainTemplatedDeclOfFunctionTemplates) {
   Decl *From, *To;
   std::tie(From, To) =
       getImportedDecl("template <typename T> void declToImport() { T a = 1; }"
                       "void instantiate() { declToImport<int>(); }",
                       Lang_CXX, "", Lang_CXX);
 
   auto Check = [](Decl *D) -> bool {
auto Check = [](Decl *D) -> bool {
     }
     return true;
   };
 
   ASSERT_TRUE(Check(From));
   EXPECT_TRUE(Check(To));
 }
 
-TEST_P(ASTImporterTestBase, TUshouldNotContainTemplatedDeclOfClassTemplates) {
+TEST_P(ASTImporterOptionSpecificTestBase,
+       TUshouldNotContainTemplatedDeclOfClassTemplates) {
   Decl *From, *To;
   std::tie(From, To) =
       getImportedDecl("template <typename T> struct declToImport { T t; };"
                       "void instantiate() { declToImport<int>(); }",
                       Lang_CXX, "", Lang_CXX);
 
   auto Check = [](Decl *D) -> bool {
     auto TU = D->getTranslationUnitDecl();
     for (auto Child : TU->decls()) {
       if (auto *RD = dyn_cast<CXXRecordDecl>(Child)) {
         if (RD->getNameAsString() == "declToImport") {
           GTEST_NONFATAL_FAILURE_(
               "TU should not contain any CXXRecordDecl with name declToImport");
           return false;
         }
       }
     }
     return true;
   };
 
   ASSERT_TRUE(Check(From));
   EXPECT_TRUE(Check(To));
 }
 
-TEST_P(ASTImporterTestBase, TUshouldNotContainTemplatedDeclOfTypeAlias) {
+TEST_P(ASTImporterOptionSpecificTestBase,
+       TUshouldNotContainTemplatedDeclOfTypeAlias) {
   Decl *From, *To;
   std::tie(From, To) =
       getImportedDecl(
           "template <typename T> struct X {};"
           "template <typename T> using declToImport = X<T>;"
           "void instantiate() { declToImport<int> a; }",
                       Lang_CXX11, "", Lang_CXX11);
 
auto Check = [](Decl *D) -> bool {
     }
     return true;
   };
 
   ASSERT_TRUE(Check(From));
   EXPECT_TRUE(Check(To));
 }
 
-TEST_P(
-    ASTImporterTestBase,
+TEST_P(ASTImporterOptionSpecificTestBase,
        TUshouldNotContainClassTemplateSpecializationOfImplicitInstantiation) {
 
   Decl *From, *To;
   std::tie(From, To) = getImportedDecl(
       R"(
       template<class T>
       class Base {};
       class declToImport : public Base<declToImport> {};
       )",
if (Index == Order.size())
       return false;
     if (Field->getName() != Order[Index])
       return false;
     ++Index;
   }
   return Index == Order.size();
 }
 
-TEST_P(ASTImporterTestBase,
+TEST_P(ASTImporterOptionSpecificTestBase,
        TUshouldContainClassTemplateSpecializationOfExplicitInstantiation) {
   Decl *From, *To;
   std::tie(From, To) = getImportedDecl(
       R"(
       namespace NS {
         template<class T>
         class X {};
         template class X<int>;
TEST_P(ASTImporterOptionSpecificTestBase,
 
   // Check that the ClassTemplateSpecializationDecl is the child of the
   // NamespaceDecl.
   Pattern = namespaceDecl(has(classTemplateSpecializationDecl(hasName("X"))));
   ASSERT_TRUE(MatchVerifier<Decl>{}.match(From, Pattern));
   EXPECT_TRUE(MatchVerifier<Decl>{}.match(To, Pattern));
 }
 
-TEST_P(ASTImporterTestBase, CXXRecordDeclFieldsShouldBeInCorrectOrder) {
+TEST_P(ASTImporterOptionSpecificTestBase,
+       CXXRecordDeclFieldsShouldBeInCorrectOrder) {
   Decl *From, *To;
   std::tie(From, To) =
       getImportedDecl(
           "struct declToImport { int a; int b; };",
                       Lang_CXX11, "", Lang_CXX11);
 
   MatchVerifier<Decl> Verifier;
   ASSERT_TRUE(Verifier.match(From, cxxRecordDecl(hasFieldOrder({"a", "b"}))));
   EXPECT_TRUE(Verifier.match(To, cxxRecordDecl(hasFieldOrder({"a", "b"}))));
 }
 
-TEST_P(ASTImporterTestBase,
+TEST_P(ASTImporterOptionSpecificTestBase,
        DISABLED_CXXRecordDeclFieldOrderShouldNotDependOnImportOrder) {
   Decl *From, *To;
   std::tie(From, To) = getImportedDecl(
       // The original recursive algorithm of ASTImporter first imports 'c' then
       // 'b' and lastly 'a'.  Therefore we must restore the order somehow.
       R"s(
       struct declToImport {
           int a = c + b;
           int b = 1;
           int c = 2;
       };
       )s",
       Lang_CXX11, "", Lang_CXX11);
 
   MatchVerifier<Decl> Verifier;
   ASSERT_TRUE(
       Verifier.match(From, cxxRecordDecl(hasFieldOrder({"a", "b", "c"}))));
   EXPECT_TRUE(
       Verifier.match(To, cxxRecordDecl(hasFieldOrder({"a", "b", "c"}))));
 }
 
-TEST_P(ASTImporterTestBase, ShouldImportImplicitCXXRecordDecl) {
+TEST_P(ASTImporterOptionSpecificTestBase, ShouldImportImplicitCXXRecordDecl) {
   Decl *From, *To;
   std::tie(From, To) = getImportedDecl(
       R"(
       struct declToImport {
       };
       )",
       Lang_CXX, "", Lang_CXX);
 
   MatchVerifier<Decl> Verifier;
   // Match the implicit Decl.
   auto Matcher = cxxRecordDecl(has(cxxRecordDecl()));
   ASSERT_TRUE(Verifier.match(From, Matcher));
   EXPECT_TRUE(Verifier.match(To, Matcher));
 }
 
-TEST_P(ASTImporterTestBase, ShouldImportImplicitCXXRecordDeclOfClassTemplate) {
+TEST_P(ASTImporterOptionSpecificTestBase,
+       ShouldImportImplicitCXXRecordDeclOfClassTemplate) {
   Decl *From, *To;
   std::tie(From, To) = getImportedDecl(
       R"(
       template <typename U>
       struct declToImport {
       };
       )",
       Lang_CXX, "", Lang_CXX);
 
   MatchVerifier<Decl> Verifier;
   // Match the implicit Decl.
   auto Matcher = classTemplateDecl(has(cxxRecordDecl(has(cxxRecordDecl()))));
   ASSERT_TRUE(Verifier.match(From, Matcher));
   EXPECT_TRUE(Verifier.match(To, Matcher));
 }
 
-TEST_P(
-    ASTImporterTestBase,
+TEST_P(ASTImporterOptionSpecificTestBase,
        ShouldImportImplicitCXXRecordDeclOfClassTemplateSpecializationDecl) {
   Decl *From, *To;
   std::tie(From, To) = getImportedDecl(
       R"(
       template<class T>
       class Base {};
       class declToImport : public Base<declToImport> {};
       )",
       Lang_CXX, "", Lang_CXX);
 
   auto hasImplicitClass = has(cxxRecordDecl());
   auto Pattern = translationUnitDecl(has(classTemplateDecl(
       hasName("Base"),
       has(classTemplateSpecializationDecl(hasImplicitClass)))));
   ASSERT_TRUE(
       MatchVerifier<Decl>{}.match(From->getTranslationUnitDecl(), Pattern));
   EXPECT_TRUE(
       MatchVerifier<Decl>{}.match(To->getTranslationUnitDecl(), Pattern));
 }
 
-TEST_P(ASTImporterTestBase, IDNSOrdinary) {
+TEST_P(ASTImporterOptionSpecificTestBase, IDNSOrdinary) {
   Decl *From, *To;
   std::tie(From, To) =
       getImportedDecl("void declToImport() {}", Lang_CXX, "", Lang_CXX);
 
   MatchVerifier<Decl> Verifier;
   auto Matcher = functionDecl();
   ASSERT_TRUE(Verifier.match(From, Matcher));
   EXPECT_TRUE(Verifier.match(To, Matcher));
   EXPECT_EQ(From->getIdentifierNamespace(), To->getIdentifierNamespace());
 }
 
-TEST_P(ASTImporterTestBase, IDNSOfNonmemberOperator) {
+TEST_P(ASTImporterOptionSpecificTestBase, IDNSOfNonmemberOperator) {
   Decl *FromTU = getTuDecl(
       R"(
       struct X {};
       void operator<<(int, X);
       )",
       Lang_CXX);
   Decl *From = LastDeclMatcher<Decl>{}.match(FromTU, functionDecl());
   const Decl *To = Import(From, Lang_CXX);
   EXPECT_EQ(From->getIdentifierNamespace(), To->getIdentifierNamespace());
 }
 
-TEST_P(ASTImporterTestBase,
+TEST_P(ASTImporterOptionSpecificTestBase,
        ShouldImportMembersOfClassTemplateSpecializationDecl) {
   Decl *From, *To;
   std::tie(From, To) = getImportedDecl(
       R"(
       template<class T>
       class Base { int a; };
       class declToImport : Base<declToImport> {};
       )",
       Lang_CXX, "", Lang_CXX);
 
   auto Pattern = translationUnitDecl(has(classTemplateDecl(
       hasName("Base"),
       has(classTemplateSpecializationDecl(has(fieldDecl(hasName("a"))))))));
   ASSERT_TRUE(
       MatchVerifier<Decl>{}.match(From->getTranslationUnitDecl(), Pattern));
   EXPECT_TRUE(
       MatchVerifier<Decl>{}.match(To->getTranslationUnitDecl(), Pattern));
 }
 
-TEST_P(ASTImporterTestBase, ImportDefinitionOfClassTemplateAfterFwdDecl) {
+TEST_P(ASTImporterOptionSpecificTestBase,
+       ImportDefinitionOfClassTemplateAfterFwdDecl) {
   {
     Decl *FromTU = getTuDecl(
         R"(
             template <typename T>
             struct B;
             )",
         Lang_CXX, "input0.cc");
     auto *FromD = FirstDeclMatcher<ClassTemplateDecl>().match(
TEST_P(ASTImporterOptionSpecificTestBase,
     Import(FromD, Lang_CXX);
     auto *FromCTD = FirstDeclMatcher<ClassTemplateDecl>().match(
         FromTU, classTemplateDecl(hasName("B")));
     auto *ToCTD = cast<ClassTemplateDecl>(Import(FromCTD, Lang_CXX));
     EXPECT_TRUE(ToCTD->isThisDeclarationADefinition());
   }
 }
 
-TEST_P(ASTImporterTestBase,
+TEST_P(ASTImporterOptionSpecificTestBase,
        ImportDefinitionOfClassTemplateIfThereIsAnExistingFwdDeclAndDefinition) {
   Decl *ToTU = getToTuDecl(
       R"(
       template <typename T>
       struct B {
         void f();
       };
 
TEST_P(ASTImporterOptionSpecificTestBase,
   // We should have only one definition.
   EXPECT_EQ(1u, DeclCounterWithPredicate<ClassTemplateDecl>(
                     [](const ClassTemplateDecl *T) {
                       return T->isThisDeclarationADefinition();
                     })
                     .match(ToTU, classTemplateDecl()));
 }
 
-TEST_P(ASTImporterTestBase,
+TEST_P(ASTImporterOptionSpecificTestBase,
        ImportDefinitionOfClassIfThereIsAnExistingFwdDeclAndDefinition) {
   Decl *ToTU = getToTuDecl(
       R"(
       struct B {
         void f();
       };
 
       struct B;

 }
 static void CompareSourceRanges(SourceRange Range1, SourceRange Range2,
                                 SourceManager &SM1, SourceManager &SM2) {
   CompareSourceLocs(FullSourceLoc{ Range1.getBegin(), SM1 },
                     FullSourceLoc{ Range2.getBegin(), SM2 });
   CompareSourceLocs(FullSourceLoc{ Range1.getEnd(), SM1 },
                     FullSourceLoc{ Range2.getEnd(), SM2 });
 }
-TEST_P(ASTImporterTestBase, ImportSourceLocs) {
+TEST_P(ASTImporterOptionSpecificTestBase, ImportSourceLocs) {
   Decl *FromTU = getTuDecl(
       R"(
       #define MFOO(arg) arg = arg + 1
 
       void foo() {
         int a = 5;
         MFOO(a);
       }
TEST_P(ASTImporterOptionSpecificTestBase, ImportSourceLocs) {
   CompareSourceRanges(ToD->getSourceRange(), FromD->getSourceRange(), ToSM,
                       FromSM);
   CompareSourceRanges(ToLHS->getSourceRange(), FromLHS->getSourceRange(), ToSM,
                       FromSM);
   CompareSourceRanges(ToRHS->getSourceRange(), FromRHS->getSourceRange(), ToSM,
                       FromSM);
 }
 
-TEST_P(ASTImporterTestBase, ImportNestedMacro) {
+TEST_P(ASTImporterOptionSpecificTestBase, ImportNestedMacro) {
   Decl *FromTU = getTuDecl(
       R"(
       #define FUNC_INT void declToImport
       #define FUNC FUNC_INT
       FUNC(int a);
       )",
       Lang_CXX);
   auto FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, functionDecl());
   auto ToD = Import(FromD, Lang_CXX);
 
   SourceManager &ToSM = ToAST->getASTContext().getSourceManager();
   SourceManager &FromSM = FromD->getASTContext().getSourceManager();
   CompareSourceRanges(ToD->getSourceRange(), FromD->getSourceRange(), ToSM,
                       FromSM);
 }
 
 TEST_P(
-    ASTImporterTestBase,
-    ImportDefinitionOfClassTemplateSpecIfThereIsAnExistingFwdDeclAndDefinition)
-{
+    ASTImporterOptionSpecificTestBase,
+    ImportDefinitionOfClassTemplateSpecIfThereIsAnExistingFwdDeclAndDefinition) {
   Decl *ToTU = getToTuDecl(
       R"(
       template <typename T>
       struct B;
 
       template <>
       struct B<int> {};
 
TEST_P(
   // We should have only one definition.
   EXPECT_EQ(1u, DeclCounterWithPredicate<ClassTemplateSpecializationDecl>(
                     [](const ClassTemplateSpecializationDecl *T) {
                       return T->isThisDeclarationADefinition();
                     })
                     .match(ToTU, classTemplateSpecializationDecl()));
 }
 
-TEST_P(ASTImporterTestBase, ObjectsWithUnnamedStructType) {
+TEST_P(ASTImporterOptionSpecificTestBase, ObjectsWithUnnamedStructType) {
   Decl *FromTU = getTuDecl(
       R"(
       struct { int a; int b; } object0 = { 2, 3 };
       struct { int x; int y; int z; } object1;
       )",
       Lang_CXX, "input0.cc");
 
   auto *Obj0 =
       FirstDeclMatcher<VarDecl>().match(FromTU, varDecl(hasName("object0")));
   auto *From0 = getRecordDecl(Obj0);
   auto *Obj1 =
       FirstDeclMatcher<VarDecl>().match(FromTU, varDecl(hasName("object1")));
   auto *From1 = getRecordDecl(Obj1);
 
   auto *To0 = Import(From0, Lang_CXX);
   auto *To1 = Import(From1, Lang_CXX);
 
   EXPECT_TRUE(To0);
   EXPECT_TRUE(To1);
   EXPECT_NE(To0, To1);
   EXPECT_NE(To0->getCanonicalDecl(), To1->getCanonicalDecl());
 }
 
-TEST_P(ASTImporterTestBase, AnonymousRecords) {
+TEST_P(ASTImporterOptionSpecificTestBase, AnonymousRecords) {
   auto *Code =
       R"(
       struct X {
         struct { int a; };
         struct { int b; };
       };
       )";
   Decl *FromTU0 = getTuDecl(Code, Lang_C, "input0.c");
TEST_P(ASTImporterOptionSpecificTestBase, AnonymousRecords) {
 
   auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   // We expect no (ODR) warning during the import.
   EXPECT_EQ(0u, ToTU->getASTContext().getDiagnostics().getNumWarnings());
   EXPECT_EQ(1u,
             DeclCounter<RecordDecl>().match(ToTU, recordDecl(hasName("X"))));
 }
 
-TEST_P(ASTImporterTestBase, AnonymousRecordsReversed) {
+TEST_P(ASTImporterOptionSpecificTestBase, AnonymousRecordsReversed) {
   Decl *FromTU0 = getTuDecl(
       R"(
       struct X {
         struct { int a; };
         struct { int b; };
       };
       )",
       Lang_C, "input0.c");
TEST_P(ASTImporterOptionSpecificTestBase, AnonymousRecordsReversed) {
 
   auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   // We expect one (ODR) warning during the import.
   EXPECT_EQ(1u, ToTU->getASTContext().getDiagnostics().getNumWarnings());
   EXPECT_EQ(2u,
             DeclCounter<RecordDecl>().match(ToTU, recordDecl(hasName("X"))));
 }
 
-TEST_P(ASTImporterTestBase, ImportDoesUpdateUsedFlag) {
+TEST_P(ASTImporterOptionSpecificTestBase, ImportDoesUpdateUsedFlag) {
   auto Pattern = varDecl(hasName("x"));
   VarDecl *Imported1;
   {
     Decl *FromTU = getTuDecl("extern int x;", Lang_CXX, "input0.cc");
     auto *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
     Imported1 = cast<VarDecl>(Import(FromD, Lang_CXX));
   }
   VarDecl *Imported2;
Decl *FromTU =
         getTuDecl("extern int x; int f() { return x; }", Lang_CXX, "input2.cc");
     auto *FromD = FirstDeclMatcher<FunctionDecl>().match(
         FromTU, functionDecl(hasName("f")));
     Import(FromD, Lang_CXX);
   }
   EXPECT_TRUE(Imported2->isUsed(false));
 }
 
-TEST_P(ASTImporterTestBase, ImportDoesUpdateUsedFlag2) {
+TEST_P(ASTImporterOptionSpecificTestBase, ImportDoesUpdateUsedFlag2) {
   auto Pattern = varDecl(hasName("x"));
   VarDecl *ExistingD;
   {
     Decl *ToTU = getToTuDecl("int x = 1;", Lang_CXX);
     ExistingD = FirstDeclMatcher<VarDecl>().match(ToTU, Pattern);
   }
   EXPECT_FALSE(ExistingD->isUsed(false));
   {
     Decl *FromTU = getTuDecl(
         "int x = 1; int f() { return x; }", Lang_CXX, "input1.cc");
     auto *FromD = FirstDeclMatcher<FunctionDecl>().match(
         FromTU, functionDecl(hasName("f")));
     Import(FromD, Lang_CXX);
   }
   EXPECT_TRUE(ExistingD->isUsed(false));
 }
 
-TEST_P(ASTImporterTestBase, ImportDoesUpdateUsedFlag3) {
+TEST_P(ASTImporterOptionSpecificTestBase, ImportDoesUpdateUsedFlag3) {
   auto Pattern = varDecl(hasName("a"));
   VarDecl *ExistingD;
   {
     Decl *ToTU = getToTuDecl(
         R"(
         struct A {
           static const int a = 1;
         };
auto *FromFunD = FirstDeclMatcher<FunctionDecl>().match(
         FromTU, functionDecl(hasName("f")));
     auto *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
     ASSERT_TRUE(FromD->isUsed(false));
     Import(FromFunD, Lang_CXX);
   }
   EXPECT_TRUE(ExistingD->isUsed(false));
 }
 
-TEST_P(ASTImporterTestBase, ReimportWithUsedFlag) {
+TEST_P(ASTImporterOptionSpecificTestBase, ReimportWithUsedFlag) {
   auto Pattern = varDecl(hasName("x"));
 
   Decl *FromTU = getTuDecl("int x;", Lang_CXX, "input0.cc");
   auto *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
 
   auto *Imported1 = cast<VarDecl>(Import(FromD, Lang_CXX));
 
   ASSERT_FALSE(Imported1->isUsed(false));
 
   FromD->setIsUsed();
   auto *Imported2 = cast<VarDecl>(Import(FromD, Lang_CXX));
 
   EXPECT_EQ(Imported1, Imported2);
   EXPECT_TRUE(Imported2->isUsed(false));
 }
 
-struct ImportFunctions : ASTImporterTestBase {};
+struct ImportFunctions : ASTImporterOptionSpecificTestBase {};
 
 TEST_P(ImportFunctions,
        DefinitionShouldBeImportedAsDefintionWhenThereIsAPrototype) {
   Decl *FromTU = getTuDecl("void f(); void f() {}", Lang_CXX);
   auto Pattern = functionDecl(hasName("f"));
   FunctionDecl *FromD = // Definition
       LastDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
 
testImport("struct S { template <typename T> void mem(); };"
              "  s.mem<U>();"
              "}"
              "void instantiate() { declToImport<int>(); }",
              Lang_CXX11, "", Lang_CXX11, Verifier,
              functionTemplateDecl(has(functionDecl(has(
                  compoundStmt(has(callExpr(has(unresolvedMemberExpr())))))))));
 }
 
-class ImportImplicitMethods : public ASTImporterTestBase {
+class ImportImplicitMethods : public ASTImporterOptionSpecificTestBase {
 public:
   static constexpr auto DefaultCode = R"(
       struct A { int x; };
       void f() {
         A a;
         A a1(a);
         A a2(A{});
         a = a1;

 
 TEST_P(ImportImplicitMethods, DoNotImportOtherMethod) {
   auto Code = R"(
       struct A { void f() { } };
       )";
   testNoImportOf(cxxMethodDecl(hasName("f")), Code);
 }
 
-TEST_P(ASTImporterTestBase, ImportOfEquivalentRecord) {
+TEST_P(ASTImporterOptionSpecificTestBase, ImportOfEquivalentRecord) {
   Decl *ToR1;
   {
     Decl *FromTU = getTuDecl(
         "struct A { };", Lang_CXX, "input0.cc");
     auto *FromR = FirstDeclMatcher<CXXRecordDecl>().match(
         FromTU, cxxRecordDecl(hasName("A")));
 
     ToR1 = Import(FromR, Lang_CXX);
   }
 
   Decl *ToR2;
   {
     Decl *FromTU = getTuDecl(
         "struct A { };", Lang_CXX, "input1.cc");
     auto *FromR = FirstDeclMatcher<CXXRecordDecl>().match(
         FromTU, cxxRecordDecl(hasName("A")));
 
     ToR2 = Import(FromR, Lang_CXX);
   }
 
   EXPECT_EQ(ToR1, ToR2);
 }
 
-TEST_P(ASTImporterTestBase, ImportOfNonEquivalentRecord) {
+TEST_P(ASTImporterOptionSpecificTestBase, ImportOfNonEquivalentRecord) {
   Decl *ToR1;
   {
     Decl *FromTU = getTuDecl(
         "struct A { int x; };", Lang_CXX, "input0.cc");
     auto *FromR = FirstDeclMatcher<CXXRecordDecl>().match(
         FromTU, cxxRecordDecl(hasName("A")));
     ToR1 = Import(FromR, Lang_CXX);
   }
   Decl *ToR2;
   {
     Decl *FromTU = getTuDecl(
         "struct A { unsigned x; };", Lang_CXX, "input1.cc");
     auto *FromR = FirstDeclMatcher<CXXRecordDecl>().match(
         FromTU, cxxRecordDecl(hasName("A")));
     ToR2 = Import(FromR, Lang_CXX);
   }
   EXPECT_NE(ToR1, ToR2);
 }
 
-TEST_P(ASTImporterTestBase, ImportOfEquivalentField) {
+TEST_P(ASTImporterOptionSpecificTestBase, ImportOfEquivalentField) {
   Decl *ToF1;
   {
     Decl *FromTU = getTuDecl(
         "struct A { int x; };", Lang_CXX, "input0.cc");
     auto *FromF = FirstDeclMatcher<FieldDecl>().match(
         FromTU, fieldDecl(hasName("x")));
     ToF1 = Import(FromF, Lang_CXX);
   }
   Decl *ToF2;
   {
     Decl *FromTU = getTuDecl(
         "struct A { int x; };", Lang_CXX, "input1.cc");
     auto *FromF = FirstDeclMatcher<FieldDecl>().match(
         FromTU, fieldDecl(hasName("x")));
     ToF2 = Import(FromF, Lang_CXX);
   }
   EXPECT_EQ(ToF1, ToF2);
 }
 
-TEST_P(ASTImporterTestBase, ImportOfNonEquivalentField) {
+TEST_P(ASTImporterOptionSpecificTestBase, ImportOfNonEquivalentField) {
   Decl *ToF1;
   {
     Decl *FromTU = getTuDecl(
         "struct A { int x; };", Lang_CXX, "input0.cc");
     auto *FromF = FirstDeclMatcher<FieldDecl>().match(
         FromTU, fieldDecl(hasName("x")));
     ToF1 = Import(FromF, Lang_CXX);
   }
   Decl *ToF2;
   {
     Decl *FromTU = getTuDecl(
         "struct A { unsigned x; };", Lang_CXX, "input1.cc");
     auto *FromF = FirstDeclMatcher<FieldDecl>().match(
         FromTU, fieldDecl(hasName("x")));
     ToF2 = Import(FromF, Lang_CXX);
   }
   EXPECT_NE(ToF1, ToF2);
 }
 
-TEST_P(ASTImporterTestBase, ImportOfEquivalentMethod) {
+TEST_P(ASTImporterOptionSpecificTestBase, ImportOfEquivalentMethod) {
   Decl *ToM1;
   {
     Decl *FromTU = getTuDecl(
         "struct A { void x(); }; void A::x() { }", Lang_CXX, "input0.cc");
     auto *FromM = FirstDeclMatcher<FunctionDecl>().match(
         FromTU, functionDecl(hasName("x"), isDefinition()));
     ToM1 = Import(FromM, Lang_CXX);
   }
   Decl *ToM2;
   {
     Decl *FromTU = getTuDecl(
         "struct A { void x(); }; void A::x() { }", Lang_CXX, "input1.cc");
     auto *FromM = FirstDeclMatcher<FunctionDecl>().match(
         FromTU, functionDecl(hasName("x"), isDefinition()));
     ToM2 = Import(FromM, Lang_CXX);
   }
   EXPECT_EQ(ToM1, ToM2);
 }
 
-TEST_P(ASTImporterTestBase, ImportOfNonEquivalentMethod) {
+TEST_P(ASTImporterOptionSpecificTestBase, ImportOfNonEquivalentMethod) {
   Decl *ToM1;
   {
     Decl *FromTU = getTuDecl(
         "struct A { void x(); }; void A::x() { }",
         Lang_CXX, "input0.cc");
     auto *FromM = FirstDeclMatcher<FunctionDecl>().match(
         FromTU, functionDecl(hasName("x"), isDefinition()));
     ToM1 = Import(FromM, Lang_CXX);
   }
   Decl *ToM2;
   {
     Decl *FromTU = getTuDecl(
         "struct A { void x() const; }; void A::x() const { }",
         Lang_CXX, "input1.cc");
     auto *FromM = FirstDeclMatcher<FunctionDecl>().match(
         FromTU, functionDecl(hasName("x"), isDefinition()));
     ToM2 = Import(FromM, Lang_CXX);
   }
   EXPECT_NE(ToM1, ToM2);
 }
 
-TEST_P(ASTImporterTestBase, ImportUnnamedStructsWithRecursingField) {
+TEST_P(ASTImporterOptionSpecificTestBase,
+       ImportUnnamedStructsWithRecursingField) {
   Decl *FromTU = getTuDecl(
       R"(
       struct A {
         struct {
           struct A *next;
         } entry0;
         struct {
           struct A *next;
TEST_P(ASTImporterOptionSpecificTestBase,
   auto *R1 = getRecordDecl(Entry1);
   EXPECT_NE(R0, R1);
   EXPECT_TRUE(MatchVerifier<RecordDecl>().match(
       R0, recordDecl(has(fieldDecl(hasName("next"))))));
   EXPECT_TRUE(MatchVerifier<RecordDecl>().match(
       R1, recordDecl(has(fieldDecl(hasName("next"))))));
 }
 
-TEST_P(ASTImporterTestBase, ImportUnnamedFieldsInCorrectOrder) {
+TEST_P(ASTImporterOptionSpecificTestBase, ImportUnnamedFieldsInCorrectOrder) {
   Decl *FromTU = getTuDecl(
       R"(
       void f(int X, int Y, bool Z) {
         (void)[X, Y, Z] { (void)Z; };
       }
       )",
       Lang_CXX11, "input0.cc");
   auto *FromF = FirstDeclMatcher<FunctionDecl>().match(
for (auto *FromField : FromLambda->fields()) {
     EXPECT_TRUE(ToIndex);
     EXPECT_EQ(*ToIndex, FromIndex);
     ++FromIndex;
   }
 
   EXPECT_EQ(FromIndex, 3u);
 }
 
-TEST_P(ASTImporterTestBase, MergeFieldDeclsOfClassTemplateSpecialization) {
+TEST_P(ASTImporterOptionSpecificTestBase,
+       MergeFieldDeclsOfClassTemplateSpecialization) {
   std::string ClassTemplate =
       R"(
       template <typename T>
       struct X {
           int a{0}; // FieldDecl with InitListExpr
           X(char) : a(3) {}     // (1)
           X(int) {}             // (2)
       };
TEST_P(ASTImporterOptionSpecificTestBase,
   auto *ImportedSpec = Import(FromSpec, Lang_CXX11);
   ASSERT_TRUE(ImportedSpec);
   EXPECT_EQ(ImportedSpec, ToSpec);
   // After the import, the FieldDecl has to be merged, thus it should have the
   // InitListExpr.
   EXPECT_TRUE(ToField->getInClassInitializer());
 }
 
-TEST_P(ASTImporterTestBase, MergeFunctionOfClassTemplateSpecialization) {
+TEST_P(ASTImporterOptionSpecificTestBase,
+       MergeFunctionOfClassTemplateSpecialization) {
   std::string ClassTemplate =
       R"(
       template <typename T>
       struct X {
         void f() {}
         void g() {}
       };
       )";
TEST_P(ASTImporterOptionSpecificTestBase,
   auto *ImportedSpec = Import(FromSpec, Lang_CXX11);
   ASSERT_TRUE(ImportedSpec);
   auto *ToSpec = FirstDeclMatcher<ClassTemplateSpecializationDecl>().match(
       ToTU, classTemplateSpecializationDecl(hasName("X")));
   EXPECT_EQ(ImportedSpec, ToSpec);
   EXPECT_TRUE(ToFun->hasBody());
 }
 
-TEST_P(ASTImporterTestBase,
+TEST_P(ASTImporterOptionSpecificTestBase,
        ODRViolationOfClassTemplateSpecializationsShouldBeReported) {
   std::string ClassTemplate =
       R"(
       template <typename T>
       struct X {};
       )";
   Decl *ToTU = getToTuDecl(ClassTemplate +
                                R"(
TEST_P(ASTImporterOptionSpecificTestBase,
   EXPECT_TRUE(ImportedSpec);
   auto *ToSpec = FirstDeclMatcher<ClassTemplateSpecializationDecl>().match(
       ToTU, classTemplateSpecializationDecl(hasName("X")));
   EXPECT_EQ(ImportedSpec, ToSpec);
   EXPECT_EQ(1u, DeclCounter<ClassTemplateSpecializationDecl>().match(
                     ToTU, classTemplateSpecializationDecl()));
 }
 
-TEST_P(ASTImporterTestBase, MergeCtorOfClassTemplateSpecialization) {
+TEST_P(ASTImporterOptionSpecificTestBase,
+       MergeCtorOfClassTemplateSpecialization) {
   std::string ClassTemplate =
       R"(
       template <typename T>
       struct X {
           X(char) {}
           X(int) {}
       };
       )";
TEST_P(ASTImporterOptionSpecificTestBase,
   auto *ImportedSpec = Import(FromSpec, Lang_CXX11);
   ASSERT_TRUE(ImportedSpec);
   auto *ToSpec = FirstDeclMatcher<ClassTemplateSpecializationDecl>().match(
       ToTU, classTemplateSpecializationDecl(hasName("X")));
   EXPECT_EQ(ImportedSpec, ToSpec);
   EXPECT_TRUE(ToCtor->hasBody());
 }
 
-TEST_P(ASTImporterTestBase,
+TEST_P(ASTImporterOptionSpecificTestBase,
        ClassTemplatePartialSpecializationsShouldNotBeDuplicated) {
   auto Code =
       R"(
     // primary template
     template<class T1, class T2, int I>
     class A {};
 
     // partial specialization
auto *ToSpec =
           ToTU, classTemplatePartialSpecializationDecl());
 
   auto *ImportedSpec = Import(FromSpec, Lang_CXX11);
   EXPECT_EQ(ImportedSpec, ToSpec);
   EXPECT_EQ(1u, DeclCounter<ClassTemplatePartialSpecializationDecl>().match(
                     ToTU, classTemplatePartialSpecializationDecl()));
 }
 
-TEST_P(ASTImporterTestBase, ClassTemplateSpecializationsShouldNotBeDuplicated) {
+TEST_P(ASTImporterOptionSpecificTestBase,
+       ClassTemplateSpecializationsShouldNotBeDuplicated) {
   auto Code =
       R"(
     // primary template
     template<class T1, class T2, int I>
     class A {};
 
     // full specialization
     template<>
     class A<int, int, 1> {};
     )";
   Decl *ToTU = getToTuDecl(Code, Lang_CXX11);
   Decl *FromTU = getTuDecl(Code, Lang_CXX11);
   auto *FromSpec = FirstDeclMatcher<ClassTemplateSpecializationDecl>().match(
       FromTU, classTemplateSpecializationDecl());
   auto *ToSpec = FirstDeclMatcher<ClassTemplateSpecializationDecl>().match(
       ToTU, classTemplateSpecializationDecl());
 
   auto *ImportedSpec = Import(FromSpec, Lang_CXX11);
   EXPECT_EQ(ImportedSpec, ToSpec);
   EXPECT_EQ(1u, DeclCounter<ClassTemplateSpecializationDecl>().match(
                    ToTU, classTemplateSpecializationDecl()));
 }
 
-TEST_P(ASTImporterTestBase, ClassTemplateFullAndPartialSpecsShouldNotBeMixed) {
+TEST_P(ASTImporterOptionSpecificTestBase,
+       ClassTemplateFullAndPartialSpecsShouldNotBeMixed) {
   std::string PrimaryTemplate =
       R"(
     template<class T1, class T2, int I>
     class A {};
     )";
   auto PartialSpec =
       R"(
     template<class T, int I>
TEST_P(ASTImporterOptionSpecificTestBase,
   EXPECT_EQ(1u, DeclCounter<ClassTemplatePartialSpecializationDecl>().match(
                     ToTU, classTemplatePartialSpecializationDecl()));
   // Check the number of full specializations.
   EXPECT_EQ(1u, DeclCounter<ClassTemplateSpecializationDecl>().match(
                     ToTU, classTemplateSpecializationDecl(
                               unless(classTemplatePartialSpecializationDecl()))));
 }
 
-TEST_P(ASTImporterTestBase, InitListExprValueKindShouldBeImported) {
+TEST_P(ASTImporterOptionSpecificTestBase,
+       InitListExprValueKindShouldBeImported) {
   Decl *TU = getTuDecl(
       R"(
       const int &init();
       void foo() { const int &a{init()}; }
       )", Lang_CXX11, "input0.cc");
   auto *FromD = FirstDeclMatcher<VarDecl>().match(TU, varDecl(hasName("a")));
   ASSERT_TRUE(FromD->getAnyInitializer());
   auto *InitExpr = FromD->getAnyInitializer();
   ASSERT_TRUE(InitExpr);
   ASSERT_TRUE(InitExpr->isGLValue());
 
   auto *ToD = Import(FromD, Lang_CXX11);
   EXPECT_TRUE(ToD);
   auto *ToInitExpr = cast<VarDecl>(ToD)->getAnyInitializer();
   EXPECT_TRUE(ToInitExpr);
   EXPECT_TRUE(ToInitExpr->isGLValue());
 }
 
-struct ImportVariables : ASTImporterTestBase {};
+struct ImportVariables : ASTImporterOptionSpecificTestBase {};
 
 TEST_P(ImportVariables, ImportOfOneDeclBringsInTheWholeChain) {
   Decl *FromTU = getTuDecl(
       R"(
       struct A {
         static const int a = 1 + 2;
       };
       const int A::a;
TEST_P(ImportVariables, InitAndDefinitionAreInTheFromContext) {
   ASSERT_FALSE(ToD->getInit());
   ASSERT_FALSE(ToD->getDefinition());
 
   auto *ImportedD = cast<VarDecl>(Import(FromDWithDef, Lang_CXX11));
   EXPECT_TRUE(ImportedD->getAnyInitializer());
   EXPECT_TRUE(ImportedD->getDefinition());
 }
 
-struct ImportClasses : ASTImporterTestBase {};
+struct ImportClasses : ASTImporterOptionSpecificTestBase {};
 
 TEST_P(ImportClasses,
        PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition) {
   Decl *FromTU = getTuDecl("class X;", Lang_CXX);
   auto Pattern = cxxRecordDecl(hasName("X"), unless(isImplicit()));
   auto FromD = FirstDeclMatcher<CXXRecordDecl>().match(FromTU, Pattern);
 
   Decl *ImportedD = Import(FromD, Lang_CXX);
TEST_P(ImportClasses, ImportNestedPrototypeThenDefinition) {
   auto ToDef = LastDeclMatcher<RecordDecl>().match(ToTU, Pattern);
   EXPECT_TRUE(ImportedDef == ToDef);
   EXPECT_TRUE(ImportedProto == ToProto);
   EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
   EXPECT_FALSE(ToProto->isThisDeclarationADefinition());
   EXPECT_EQ(ToDef->getPreviousDecl(), ToProto);
 }
 
-struct ImportClassTemplates : ASTImporterTestBase {};
+struct ImportClassTemplates : ASTImporterOptionSpecificTestBase {};
 
 TEST_P(ImportClassTemplates,
        PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition) {
   Decl *FromTU = getTuDecl("template <class T> class X;", Lang_CXX);
   auto Pattern = classTemplateDecl(hasName("X"), unless(isImplicit()));
   auto FromD = FirstDeclMatcher<ClassTemplateDecl>().match(FromTU, Pattern);
 
   Decl *ImportedD = Import(FromD, Lang_CXX);
TEST_P(ImportClassTemplates, ImportPrototypeThenDefinition) {
   ASSERT_TRUE(ToDef->getTemplatedDecl());
   EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
   EXPECT_FALSE(ToProto->isThisDeclarationADefinition());
   EXPECT_EQ(ToDef->getPreviousDecl(), ToProto);
   EXPECT_EQ(ToDef->getTemplatedDecl()->getPreviousDecl(),
             ToProto->getTemplatedDecl());
 }
 
-struct ImportFriendClasses : ASTImporterTestBase {};
+struct ImportFriendClasses : ASTImporterOptionSpecificTestBase {};
 
 TEST_P(ImportFriendClasses, ImportOfFriendRecordDoesNotMergeDefinition) {
   Decl *FromTU = getTuDecl(
       R"(
       class A {
         template <int I> class F {};
         class X {
           template <int I> friend class F;
Decl *FromTU1 = getTuDecl(
       Lang_CXX, "input1.cc");
   auto *Definition = FirstDeclMatcher<CXXRecordDecl>().match(
       FromTU1, cxxRecordDecl(hasName("F")));
   auto *ImportedDef = Import(Definition, Lang_CXX);
   EXPECT_TRUE(ImportedDef->getPreviousDecl());
   EXPECT_EQ(ImportedFwd, ImportedDef->getPreviousDecl());
 }
 
-TEST_P(ASTImporterTestBase, FriendFunInClassTemplate) {
+TEST_P(ASTImporterOptionSpecificTestBase, FriendFunInClassTemplate) {
   auto *Code = R"(
   template <class T>
   struct X {
     friend void foo(){}
   };
       )";
   TranslationUnitDecl *ToTU = getToTuDecl(Code, Lang_CXX);
   auto *ToFoo = FirstDeclMatcher<FunctionDecl>().match(
       ToTU, functionDecl(hasName("foo")));
 
   TranslationUnitDecl *FromTU = getTuDecl(Code, Lang_CXX, "input.cc");
   auto *FromFoo = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("foo")));
   auto *ImportedFoo = Import(FromFoo, Lang_CXX);
   EXPECT_EQ(ImportedFoo, ToFoo);
 }
 
-struct DeclContextTest : ASTImporterTestBase {};
+struct DeclContextTest : ASTImporterOptionSpecificTestBase {};
 
 TEST_P(DeclContextTest, removeDeclOfClassTemplateSpecialization) {
   Decl *TU = getTuDecl(
       R"(
       namespace NS {
 
       template <typename T>
       struct S {};
TEST_P(DeclContextTest,
   ASSERT_TRUE(L.getAsVector());
   ASSERT_EQ(1u, L.getAsVector()->size());
 
   // This asserts in the old implementation.
   DC->removeDecl(A0);
   EXPECT_FALSE(DC->containsDecl(A0));
 }
 
-struct ImportFunctionTemplateSpecializations : ASTImporterTestBase {};
+struct ImportFunctionTemplateSpecializations
+    : ASTImporterOptionSpecificTestBase {};
 
 TEST_P(ImportFunctionTemplateSpecializations,
        TUshouldNotContainFunctionTemplateImplicitInstantiation) {
 
   Decl *FromTU = getTuDecl(
       R"(
       template<class T>
       int f() { return 0; }
TEST_P(ImportFunctionTemplateSpecializations, DefinitionThenPrototype) {
   auto *To1 = LastDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
   EXPECT_TRUE(ImportedD == To0);
   EXPECT_TRUE(ImportedD != To1);
   EXPECT_TRUE(To0->doesThisDeclarationHaveABody());
   EXPECT_FALSE(To1->doesThisDeclarationHaveABody());
   EXPECT_EQ(To1->getPreviousDecl(), To0);
 }
 
-TEST_P(ASTImporterTestBase,
+TEST_P(ASTImporterOptionSpecificTestBase,
     ImportShouldNotReportFalseODRErrorWhenRecordIsBeingDefined) {
   {
     Decl *FromTU = getTuDecl(
         R"(
             template <typename T>
             struct B;
             )",
         Lang_CXX, "input0.cc");
TEST_P(ASTImporterOptionSpecificTestBase,
     EXPECT_TRUE(ToCTD->isThisDeclarationADefinition());
 
     // We expect no (ODR) warning during the import.
     auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
     EXPECT_EQ(0u, ToTU->getASTContext().getDiagnostics().getNumWarnings());
   }
 }
 
-TEST_P(ASTImporterTestBase, ImportingTypedefShouldImportTheCompleteType) {
+TEST_P(ASTImporterOptionSpecificTestBase,
+       ImportingTypedefShouldImportTheCompleteType) {
   // We already have an incomplete underlying type in the "To" context.
   auto Code =
       R"(
       template <typename T>
       struct S {
         void foo();
       };
       using U = S<int>;
auto *FromD = FirstDeclMatcher<TypedefNameDecl>().match(FromTU,
       typedefNameDecl(hasName("U")));
   ASSERT_FALSE(FromD->getUnderlyingType()->isIncompleteType());
 
   // The imported type should be complete.
   auto *ImportedD = cast<TypedefNameDecl>(Import(FromD, Lang_CXX11));
   EXPECT_FALSE(ImportedD->getUnderlyingType()->isIncompleteType());
 }
 
-struct ASTImporterLookupTableTest : ASTImporterTestBase {};
+struct ASTImporterLookupTableTest : ASTImporterOptionSpecificTestBase {};
 
 TEST_P(ASTImporterLookupTableTest, OneDecl) {
   auto *ToTU = getToTuDecl("int a;", Lang_CXX);
   auto *D = FirstDeclMatcher<VarDecl>().match(ToTU, varDecl(hasName("a")));
   ASTImporterLookupTable LT(*ToTU);
   auto Res = LT.lookup(ToTU, D->getDeclName());
   ASSERT_EQ(Res.size(), 1u);
   EXPECT_EQ(*Res.begin(), D);

 
 INSTANTIATE_TEST_CASE_P(ParameterizedTests, DeclContextTest,
                         ::testing::Values(ArgVector()), );
 
 INSTANTIATE_TEST_CASE_P(
     ParameterizedTests, CanonicalRedeclChain,
     ::testing::Values(ArgVector()),);
 
-auto DefaultTestValuesForRunOptions = ::testing::Values(
-    ArgVector(),
-    ArgVector{"-fdelayed-template-parsing"},
-    ArgVector{"-fms-compatibility"},
-    ArgVector{"-fdelayed-template-parsing", "-fms-compatibility"});
-
 INSTANTIATE_TEST_CASE_P(ParameterizedTests, ASTImporterLookupTableTest,
                         DefaultTestValuesForRunOptions, );
 
 INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportExpr,
                         DefaultTestValuesForRunOptions, );
 
 INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportType,
                         DefaultTestValuesForRunOptions, );
 
 INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportDecl,
                         DefaultTestValuesForRunOptions, );
 
-INSTANTIATE_TEST_CASE_P(ParameterizedTests, ASTImporterTestBase,
+INSTANTIATE_TEST_CASE_P(ParameterizedTests, ASTImporterOptionSpecificTestBase,
                         DefaultTestValuesForRunOptions, );
 
 INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportFunctions,
                         DefaultTestValuesForRunOptions, );
 
 INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportClasses,
                         DefaultTestValuesForRunOptions, );