[ASTImporter] Add ms compatibility to tests

[martong]

Summary

In order to avoid build failures on MS, we use -fms-compatibility too in the
tests.

[martong]

This patch does not target testImport because I am not sure how to handle the options there:

auto RunOptsFrom = getRunOptionsForLanguage(FromLang);
auto RunOptsTo = getRunOptionsForLanguage(ToLang);
for (const auto &FromArgs : RunOptsFrom)
  for (const auto &ToArgs : RunOptsTo)
    EXPECT_TRUE(testImport(FromCode, FromArgs, ToCode, ToArgs,
                           Verifier, AMatcher));

I think, it is overkill to test all possible combinations of the options, we should come up with something better here.
Perhaps we could exploit parameterized tests here as well. @a.sidorin, @xazax.hun What is your opinion?

[a.sidorin]

I think, it is overkill to test all possible combinations of the options, we should come up with something better here.

I agree with that. I think we need to test just import pairs {/*From*/no_option, /*To*/no_option}, {option_1, option1}, {option_2, option_2}, ...{option_n, option_n}.
Another option is to just turn -fno-delayed-template-parsing -fno-ms-compatibility for ASTImporter tests like it is done in some unit tests, but I'm not sure it's a correct solution.

[martong]

I agree with that. I think we need to test just import pairs {/*From*/no_option, /*To*/no_option}, {option_1, option1}, {option_2, option_2}, ...{option_n, option_n}.

This patch does exactly that with the parameterized tests. Each elements of the DefaultTestValuesForRunOptions will be used both for the "To" and for the "From" context.
So we will have each TEST_P generating 4 cases:
[FROM, TO]
{no_option, no_option}
{"-fdelayed-template-parsing", "-fdelayed-template-parsing"}
{"-fms-compatibility", "-fms-compatibility"}
{"-fdelayed-template-parsing -fms-compatibility", "-fdelayed-template-parsing -fms-compatibility"}

[a.sidorin]

I meant that we can use this approach for testImport() too.

[martong]

• Moved the family of testImport functions under a test fixture class, so we can use parameterized test.
• Refactored testImport and testImportSequence, because for loops over the different compiler options is no longer needed, that is handeld by the test framework via parameters from now on.

[martong]

• Forgot to instantiate some of the parameterized tests

[martong]

Balazs, could you please review this patch as well? (This code is not in our fork yet.)

[martong]

• Remove unused function

[martong]

• Remove unused RunOptions typedef and isCXX function

[balazske]

Found no big problems. But not all extra options are applicable to all languages (template related things to C) so there may be redundant tests.

[martong]

Ping.

[a_sidorin]

LGTM, thank you!

Could you describe the refactoring in the commit message?

unittests/AST/ASTImporterTest.cpp

212

Looks like clang-format broke this comment in some places.

[martong]

• Update commit comment and fix broken format in a comment.

unittests/AST/ASTImporterTest.cpp

 }
 
 static void createVirtualFileIfNeeded(ASTUnit *ToAST, StringRef FileName,
                                       StringRef Code) {
   return createVirtualFileIfNeeded(ToAST, FileName,
                                    llvm::MemoryBuffer::getMemBuffer(Code));
 }
 
+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> {
+
+  // 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();
+    for (const auto &Arg : ExtraArgs) {
+      Args.push_back(Arg);
+    }
+    return Args;
+  }
+
+};
+
+// Base class for those tests which use the family of `testImport` functions.
+class TestImportBase : public ParameterizedTestsFixture {
+
   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
     // times - it just isn't replaced.
     StringRef FromFileName = From->getMainFileName();
     createVirtualFileIfNeeded(To, FromFileName,
                               From->getBufferForFile(FromFileName));
 
     auto Imported = Importer.Import(Node);
 
     // This should dump source locations and assert if some source locations
     // were not imported.
     SmallString<1024> ImportChecker;
     llvm::raw_svector_ostream ToNothing(ImportChecker);
     ToCtx.getTranslationUnitDecl()->print(ToNothing);
 
     // This traverses the AST to catch certain bugs like poorly or not
     // implemented subtrees.
     Imported->dump(ToNothing);
 
     return Imported;
   }
 
-const StringRef DeclToImportID = "declToImport";
-const StringRef DeclToVerifyID = "declToVerify";
-
   template <typename NodeType>
   testing::AssertionResult
   testImport(const std::string &FromCode, const ArgVector &FromArgs,
              const std::string &ToCode, const ArgVector &ToArgs,
              MatchVerifier<NodeType> &Verifier,
              const BindableMatcher<NodeType> &SearchMatcher,
              const BindableMatcher<NodeType> &VerificationMatcher) {
     const char *const InputFileName = "input.cc";
     const char *const OutputFileName = "output.cc";
 
-  std::unique_ptr<ASTUnit>
-      FromAST = tooling::buildASTFromCodeWithArgs(
+    std::unique_ptr<ASTUnit> FromAST = tooling::buildASTFromCodeWithArgs(
                                  FromCode, FromArgs, InputFileName),
-      ToAST = tooling::buildASTFromCodeWithArgs(ToCode, ToArgs, OutputFileName);
+                             ToAST = tooling::buildASTFromCodeWithArgs(
+                                 ToCode, ToArgs, OutputFileName);
 
     ASTContext &FromCtx = FromAST->getASTContext(),
                &ToCtx = ToAST->getASTContext();
 
-  ASTImporter Importer(ToCtx, ToAST->getFileManager(),
-                       FromCtx, FromAST->getFileManager(), false);
+    ASTImporter Importer(ToCtx, ToAST->getFileManager(), FromCtx,
+                         FromAST->getFileManager(), false);
 
     auto FoundNodes = match(SearchMatcher, FromCtx);
     if (FoundNodes.size() != 1)
       return testing::AssertionFailure()
              << "Multiple potential nodes were found!";
 
     auto ToImport = selectFirst<NodeType>(DeclToImportID, FoundNodes);
     if (!ToImport)
       return testing::AssertionFailure() << "Node type mismatch!";
 
     // Sanity check: the node being imported should match in the same way as
     // the result node.
     BindableMatcher<NodeType> WrapperMatcher(VerificationMatcher);
     EXPECT_TRUE(Verifier.match(ToImport, WrapperMatcher));
 
     auto Imported = importNode(FromAST.get(), ToAST.get(), Importer, ToImport);
     if (!Imported)
       return testing::AssertionFailure() << "Import failed, nullptr returned!";
 
     return Verifier.match(Imported, WrapperMatcher);
   }
 
   template <typename NodeType>
   testing::AssertionResult
   testImport(const std::string &FromCode, const ArgVector &FromArgs,
              const std::string &ToCode, const ArgVector &ToArgs,
              MatchVerifier<NodeType> &Verifier,
              const BindableMatcher<NodeType> &VerificationMatcher) {
     return testImport(
         FromCode, FromArgs, ToCode, ToArgs, Verifier,
         translationUnitDecl(
             has(namedDecl(hasName(DeclToImportID)).bind(DeclToImportID))),
         VerificationMatcher);
   }
 
+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,
                   MatchVerifier<NodeType> &Verifier,
                   const MatcherType &AMatcher) {
-  auto RunOptsFrom = getRunOptionsForLanguage(FromLang);
-  auto RunOptsTo = getRunOptionsForLanguage(ToLang);
-  for (const auto &FromArgs : RunOptsFrom)
-    for (const auto &ToArgs : RunOptsTo)
-      EXPECT_TRUE(testImport(FromCode, FromArgs, ToCode, ToArgs,
-                             Verifier, AMatcher));
+    ArgVector FromArgs = getArgVectorForLanguage(FromLang),
+              ToArgs = getArgVectorForLanguage(ToLang);
+    EXPECT_TRUE(
+        testImport(FromCode, FromArgs, ToCode, ToArgs, Verifier, AMatcher));
+  }
+
+  struct ImportAction {
+    StringRef FromFilename;
+    StringRef ToFilename;
+    // FIXME: Generalize this to support other node kinds.
+    BindableMatcher<Decl> ImportPredicate;
+
+    ImportAction(StringRef FromFilename, StringRef ToFilename,
+                 DeclarationMatcher ImportPredicate)
+        : FromFilename(FromFilename), ToFilename(ToFilename),
+          ImportPredicate(ImportPredicate) {}
+
+    ImportAction(StringRef FromFilename, StringRef ToFilename,
+                 const std::string &DeclName)
+        : FromFilename(FromFilename), ToFilename(ToFilename),
+          ImportPredicate(namedDecl(hasName(DeclName))) {}
+  };
+
+  using SingleASTUnit = std::unique_ptr<ASTUnit>;
+  using AllASTUnits = StringMap<SingleASTUnit>;
+
+  struct CodeEntry {
+    std::string CodeSample;
+    Language Lang;
+  };
+
+  using CodeFiles = StringMap<CodeEntry>;
+
+  /// Builds an ASTUnit for one potential compile options set.
+  SingleASTUnit createASTUnit(StringRef FileName, const CodeEntry &CE) const {
+    ArgVector Args = getArgVectorForLanguage(CE.Lang);
+    auto AST = tooling::buildASTFromCodeWithArgs(CE.CodeSample, Args, FileName);
+    EXPECT_TRUE(AST.get());
+    return AST;
+  }
+
+  /// Test an arbitrary sequence of imports for a set of given in-memory files.
+  /// The verification is done by running VerificationMatcher against a
+  /// specified
+  /// AST node inside of one of given files.
+  /// \param CodeSamples Map whose key is the file name and the value is the
+  /// file
+  /// content.
+  /// \param ImportActions Sequence of imports. Each import in sequence
+  /// specifies "from file" and "to file" and a matcher that is used for
+  /// searching a declaration for import in "from file".
+  /// \param FileForFinalCheck Name of virtual file for which the final check is
+  /// applied.
+  /// \param FinalSelectPredicate Matcher that specifies the AST node in the
+  /// FileForFinalCheck for which the verification will be done.
+  /// \param VerificationMatcher Matcher that will be used for verification
+  /// after
+  /// all imports in sequence are done.
+  void testImportSequence(const CodeFiles &CodeSamples,
+                          const std::vector<ImportAction> &ImportActions,
+                          StringRef FileForFinalCheck,
+                          BindableMatcher<Decl> FinalSelectPredicate,
+                          BindableMatcher<Decl> VerificationMatcher) {
+    AllASTUnits AllASTs;
+    using ImporterKey = std::pair<const ASTUnit *, const ASTUnit *>;
+    llvm::DenseMap<ImporterKey, std::unique_ptr<ASTImporter>> Importers;
+
+    auto GenASTsIfNeeded = [this, &AllASTs, &CodeSamples](StringRef Filename) {
+      if (!AllASTs.count(Filename)) {
+        auto Found = CodeSamples.find(Filename);
+        assert(Found != CodeSamples.end() && "Wrong file for import!");
+        AllASTs[Filename] = createASTUnit(Filename, Found->getValue());
+      }
+    };
+
+    for (const ImportAction &Action : ImportActions) {
+      StringRef FromFile = Action.FromFilename, ToFile = Action.ToFilename;
+      GenASTsIfNeeded(FromFile);
+      GenASTsIfNeeded(ToFile);
+
+      ASTUnit *From = AllASTs[FromFile].get();
+      ASTUnit *To = AllASTs[ToFile].get();
+
+      // Create a new importer if needed.
+      std::unique_ptr<ASTImporter> &ImporterRef = Importers[{From, To}];
+      if (!ImporterRef)
+        ImporterRef.reset(new ASTImporter(
+            To->getASTContext(), To->getFileManager(), From->getASTContext(),
+            From->getFileManager(), false));
+
+      // Find the declaration and import it.
+      auto FoundDecl = match(Action.ImportPredicate.bind(DeclToImportID),
+                             From->getASTContext());
+      EXPECT_TRUE(FoundDecl.size() == 1);
+      const Decl *ToImport = selectFirst<Decl>(DeclToImportID, FoundDecl);
+      auto Imported = importNode(From, To, *ImporterRef, ToImport);
+      EXPECT_TRUE(Imported);
+    }
+
+    // Find the declaration and import it.
+    auto FoundDecl = match(FinalSelectPredicate.bind(DeclToVerifyID),
+                           AllASTs[FileForFinalCheck]->getASTContext());
+    EXPECT_TRUE(FoundDecl.size() == 1);
+    const Decl *ToVerify = selectFirst<Decl>(DeclToVerifyID, FoundDecl);
+    MatchVerifier<Decl> Verifier;
+    EXPECT_TRUE(
+        Verifier.match(ToVerify, BindableMatcher<Decl>(VerificationMatcher)));
   }
+};
 
 // 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 ::testing::TestWithParam<ArgVector> {
+class ASTImporterTestBase : public ParameterizedTestsFixture {
 
   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;
 
   struct TU {
class ASTImporterTestBase : public ParameterizedTestsFixture {
   // references in the AST. By using a vector a move could happen when the
   // vector is expanding, with the list we won't have these issues.
   std::list<TU> FromTUs;
 
 public:
   // We may have several From context but only one To context.
   std::unique_ptr<ASTUnit> ToAST;
 
-  // Returns the argument vector used for a specific language, this set
-  // can be tweaked by the test parameters.
-  ArgVector getArgVectorForLanguage(Language Lang) {
-    ArgVector Args = getBasicRunOptionsForLanguage(Lang);
-    ArgVector ExtraArgs = GetParam();
-    for (const auto& Arg : ExtraArgs) {
-      Args.push_back(Arg);
-    }
-    return Args;
-  }
-
   // Creates an AST both for the From and To source code and imports the Decl
   // of the identifier into the To context.
   // Must not be called more than once within the same test.
   std::tuple<Decl *, Decl *>
   getImportedDecl(StringRef FromSrcCode, Language FromLang, StringRef ToSrcCode,
                   Language ToLang, StringRef Identifier = DeclToImportID) {
     ArgVector FromArgs = getArgVectorForLanguage(FromLang),
               ToArgs = getArgVectorForLanguage(ToLang);
~ASTImporterTestBase() {
     }
     if (ToAST) {
       llvm::errs() << "ToAST:\n";
       ToAST->getASTContext().getTranslationUnitDecl()->dump();
     }
   }
 };
 
+struct ImportExpr : TestImportBase {};
+struct ImportType : TestImportBase {};
+struct ImportDecl : TestImportBase {};
 
-struct ImportAction {
-  StringRef FromFilename;
-  StringRef ToFilename;
-  // FIXME: Generalize this to support other node kinds.
-  BindableMatcher<Decl> ImportPredicate;
-
-  ImportAction(StringRef FromFilename, StringRef ToFilename,
-               DeclarationMatcher ImportPredicate)
-      : FromFilename(FromFilename), ToFilename(ToFilename),
-        ImportPredicate(ImportPredicate) {}
-
-  ImportAction(StringRef FromFilename, StringRef ToFilename,
-               const std::string &DeclName)
-      : FromFilename(FromFilename), ToFilename(ToFilename),
-        ImportPredicate(namedDecl(hasName(DeclName))) {}
-};
-
-using SingleASTUnitForAllOpts = std::vector<std::unique_ptr<ASTUnit>>;
-using AllASTUnitsForAllOpts = StringMap<SingleASTUnitForAllOpts>;
-
-struct CodeEntry {
-  std::string CodeSample;
-  Language Lang;
-
-  /// Builds N copies of ASTUnits for each potential compile options set
-  /// for further import actions. N is equal to size of this option set.
-  SingleASTUnitForAllOpts createASTUnits(StringRef FileName) const {
-    auto RunOpts = getRunOptionsForLanguage(Lang);
-    size_t NumOpts = RunOpts.size();
-    SingleASTUnitForAllOpts ResultASTs(NumOpts);
-    for (size_t CompileOpt = 0; CompileOpt < NumOpts; ++CompileOpt) {
-      auto AST = tooling::buildASTFromCodeWithArgs(
-          CodeSample, RunOpts[CompileOpt], FileName);
-      EXPECT_TRUE(AST.get());
-      ResultASTs[CompileOpt] = std::move(AST);
-    }
-    return ResultASTs;
-  }
-};
-
-using CodeFiles = StringMap<CodeEntry>;
-
-/// Test an arbitrary sequence of imports for a set of given in-memory files.
-/// The verification is done by running VerificationMatcher against a specified
-/// AST node inside of one of given files.
-/// \param CodeSamples Map whose key is the file name and the value is the file
-/// content.
-/// \param ImportActions Sequence of imports. Each import in sequence
-/// specifies "from file" and "to file" and a matcher that is used for
-/// searching a declaration for import in "from file".
-/// \param FileForFinalCheck Name of virtual file for which the final check is
-/// applied.
-/// \param FinalSelectPredicate Matcher that specifies the AST node in the
-/// FileForFinalCheck for which the verification will be done.
-/// \param VerificationMatcher Matcher that will be used for verification after
-/// all imports in sequence are done.
-void testImportSequence(const CodeFiles &CodeSamples,
-                        const std::vector<ImportAction> &ImportActions,
-                        StringRef FileForFinalCheck,
-                        BindableMatcher<Decl> FinalSelectPredicate,
-                        BindableMatcher<Decl> VerificationMatcher) {
-  AllASTUnitsForAllOpts AllASTUnits;
-  using ImporterKey = std::pair<const ASTUnit *, const ASTUnit *>;
-  llvm::DenseMap<ImporterKey, std::unique_ptr<ASTImporter>> Importers;
-
-  auto GenASTsIfNeeded = [&AllASTUnits, &CodeSamples](StringRef Filename) {
-    if (!AllASTUnits.count(Filename)) {
-      auto Found = CodeSamples.find(Filename);
-      assert(Found != CodeSamples.end() && "Wrong file for import!");
-      AllASTUnits[Filename] = Found->getValue().createASTUnits(Filename);
-    }
-  };
-
-  size_t NumCompileOpts = 0;
-  for (const ImportAction &Action : ImportActions) {
-    StringRef FromFile = Action.FromFilename, ToFile = Action.ToFilename;
-    GenASTsIfNeeded(FromFile);
-    GenASTsIfNeeded(ToFile);
-    NumCompileOpts = AllASTUnits[FromFile].size();
-
-    for (size_t CompileOpt = 0; CompileOpt < NumCompileOpts; ++CompileOpt) {
-      ASTUnit *From = AllASTUnits[FromFile][CompileOpt].get();
-      ASTUnit *To = AllASTUnits[ToFile][CompileOpt].get();
-
-      // Create a new importer if needed.
-      std::unique_ptr<ASTImporter> &ImporterRef = Importers[{From, To}];
-      if (!ImporterRef)
-        ImporterRef.reset(new ASTImporter(
-            To->getASTContext(), To->getFileManager(), From->getASTContext(),
-            From->getFileManager(), false));
-
-      // Find the declaration and import it.
-      auto FoundDecl = match(Action.ImportPredicate.bind(DeclToImportID),
-                             From->getASTContext());
-      EXPECT_TRUE(FoundDecl.size() == 1);
-      const Decl *ToImport = selectFirst<Decl>(DeclToImportID, FoundDecl);
-      auto Imported = importNode(From, To, *ImporterRef, ToImport);
-      EXPECT_TRUE(Imported);
-    }
-  }
-
-  // NOTE: We don't do cross-option import check here due to fast growth of
-  // potential option sets.
-  for (size_t CompileOpt = 0; CompileOpt < NumCompileOpts; ++CompileOpt) {
-    // Find the declaration and import it.
-    auto FoundDecl =
-        match(FinalSelectPredicate.bind(DeclToVerifyID),
-              AllASTUnits[FileForFinalCheck][CompileOpt]->getASTContext());
-    EXPECT_TRUE(FoundDecl.size() == 1);
-    const Decl *ToVerify = selectFirst<Decl>(DeclToVerifyID, FoundDecl);
-    MatchVerifier<Decl> Verifier;
-    EXPECT_TRUE(Verifier.match(ToVerify,
-                               BindableMatcher<Decl>(VerificationMatcher)));
-  }
-}
-
-TEST(ImportExpr, ImportStringLiteral) {
+TEST_P(ImportExpr, ImportStringLiteral) {
   MatchVerifier<Decl> Verifier;
   testImport("void declToImport() { \"foo\"; }",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionDecl(
                hasBody(
                  compoundStmt(
                    has(
                      stringLiteral(
testImport("void declToImport() { \"foo\" \"bar\"; }",
                hasBody(
                  compoundStmt(
                    has(
                      stringLiteral(
                        hasType(
                          asString("const char [7]"))))))));
 }
 
-TEST(ImportExpr, ImportGNUNullExpr) {
+TEST_P(ImportExpr, ImportGNUNullExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("void declToImport() { __null; }",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionDecl(
                hasBody(
                  compoundStmt(
                    has(
                      gnuNullExpr(
                        hasType(isInteger())))))));
 }
 
-TEST(ImportExpr, ImportCXXNullPtrLiteralExpr) {
+TEST_P(ImportExpr, ImportCXXNullPtrLiteralExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("void declToImport() { nullptr; }",
              Lang_CXX11, "", Lang_CXX11, Verifier,
              functionDecl(
                hasBody(
                  compoundStmt(
                    has(
                      cxxNullPtrLiteralExpr())))));
 }
 
 
-TEST(ImportExpr, ImportFloatinglLiteralExpr) {
+TEST_P(ImportExpr, ImportFloatinglLiteralExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("void declToImport() { 1.0; }",
              Lang_C, "", Lang_C, Verifier,
              functionDecl(
                hasBody(
                  compoundStmt(
                    has(
                      floatLiteral(
                        equals(1.0),
                        hasType(asString("double"))))))));
   testImport("void declToImport() { 1.0e-5f; }",
               Lang_C, "", Lang_C, Verifier,
               functionDecl(
                 hasBody(
                   compoundStmt(
                     has(
                       floatLiteral(
                         equals(1.0e-5f),
                         hasType(asString("float"))))))));
 }
 
-TEST(ImportExpr, ImportCompoundLiteralExpr) {
+TEST_P(ImportExpr, ImportCompoundLiteralExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("void declToImport() {"
              "  struct s { int x; long y; unsigned z; }; "
              "  (struct s){ 42, 0L, 1U }; }",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionDecl(
                hasBody(
                  compoundStmt(
                    has(
                      compoundLiteralExpr(
                        hasType(asString("struct s")),
                        has(initListExpr(
                          hasType(asString("struct s")),
                          has(integerLiteral(
                                equals(42), hasType(asString("int")))),
                          has(integerLiteral(
                                equals(0), hasType(asString("long")))),
                          has(integerLiteral(
                                equals(1),
                                hasType(asString("unsigned int"))))
                          ))))))));
 }
 
-TEST(ImportExpr, ImportCXXThisExpr) {
+TEST_P(ImportExpr, ImportCXXThisExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("class declToImport { void f() { this; } };",
              Lang_CXX, "", Lang_CXX, Verifier,
              cxxRecordDecl(
                hasMethod(
                  hasBody(
                    compoundStmt(
                      has(
                        cxxThisExpr(
                          hasType(
                            asString("class declToImport *")))))))));
 }
 
-TEST(ImportExpr, ImportAtomicExpr) {
+TEST_P(ImportExpr, ImportAtomicExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("void declToImport() { int *ptr; __atomic_load_n(ptr, 1); }",
              Lang_C, "", Lang_C, Verifier,
              functionDecl(hasBody(compoundStmt(has(atomicExpr(
                  has(ignoringParenImpCasts(
                      declRefExpr(hasDeclaration(varDecl(hasName("ptr"))),
                                  hasType(asString("int *"))))),
                  has(integerLiteral(equals(1), hasType(asString("int"))))))))));
 }
 
-TEST(ImportExpr, ImportLabelDeclAndAddrLabelExpr) {
+TEST_P(ImportExpr, ImportLabelDeclAndAddrLabelExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "void declToImport() { loop: goto loop; &&loop; }", Lang_C, "", Lang_C,
       Verifier,
       functionDecl(hasBody(compoundStmt(
           has(labelStmt(hasDeclaration(labelDecl(hasName("loop"))))),
           has(addrLabelExpr(hasDeclaration(labelDecl(hasName("loop")))))))));
 }
 
 AST_MATCHER_P(TemplateDecl, hasTemplateDecl,
               internal::Matcher<NamedDecl>, InnerMatcher) {
   const NamedDecl *Template = Node.getTemplatedDecl();
   return Template && InnerMatcher.matches(*Template, Finder, Builder);
 }
 
-TEST(ImportExpr, ImportParenListExpr) {
+TEST_P(ImportExpr, ImportParenListExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "template<typename T> class dummy { void f() { dummy X(*this); } };"
       "typedef dummy<int> declToImport;"
       "template class dummy<int>;",
       Lang_CXX, "", Lang_CXX, Verifier,
       typedefDecl(hasType(templateSpecializationType(
           hasDeclaration(classTemplateSpecializationDecl(hasSpecializedTemplate(
               classTemplateDecl(hasTemplateDecl(cxxRecordDecl(hasMethod(allOf(
                   hasName("f"),
                   hasBody(compoundStmt(has(declStmt(hasSingleDecl(
                       varDecl(hasInitializer(parenListExpr(has(unaryOperator(
                           hasOperatorName("*"),
                           hasUnaryOperand(cxxThisExpr())))))))))))))))))))))));
 }
 
-TEST(ImportExpr, ImportSwitch) {
+TEST_P(ImportExpr, ImportSwitch) {
   MatchVerifier<Decl> Verifier;
   testImport("void declToImport() { int b; switch (b) { case 1: break; } }",
              Lang_C, "", Lang_C, Verifier,
              functionDecl(hasBody(compoundStmt(
                  has(switchStmt(has(compoundStmt(has(caseStmt())))))))));
 }
 
-TEST(ImportExpr, ImportStmtExpr) {
+TEST_P(ImportExpr, ImportStmtExpr) {
   MatchVerifier<Decl> Verifier;
   // NOTE: has() ignores implicit casts, using hasDescendant() to match it
   testImport(
     "void declToImport() { int b; int a = b ?: 1; int C = ({int X=4; X;}); }",
     Lang_C, "", Lang_C, Verifier,
     functionDecl(
       hasBody(
         compoundStmt(
functionDecl(
                               hasType(asString("int")),
                               hasInitializer(
                                 integerLiteral(equals(4))))))),
                       hasDescendant(
                         implicitCastExpr()
                         )))))))))));
 }
 
-TEST(ImportExpr, ImportConditionalOperator) {
+TEST_P(ImportExpr, ImportConditionalOperator) {
   MatchVerifier<Decl> Verifier;
   testImport(
     "void declToImport() { true ? 1 : -5; }",
     Lang_CXX, "", Lang_CXX, Verifier,
     functionDecl(
       hasBody(
         compoundStmt(
           has(
             conditionalOperator(
               hasCondition(cxxBoolLiteral(equals(true))),
               hasTrueExpression(integerLiteral(equals(1))),
               hasFalseExpression(
                 unaryOperator(hasUnaryOperand(integerLiteral(equals(5))))
                 )))))));
 }
 
-TEST(ImportExpr, ImportBinaryConditionalOperator) {
+TEST_P(ImportExpr, ImportBinaryConditionalOperator) {
   MatchVerifier<Decl> Verifier;
   testImport(
     "void declToImport() { 1 ?: -5; }", Lang_CXX, "", Lang_CXX, Verifier,
     functionDecl(
       hasBody(
         compoundStmt(
           has(
             binaryConditionalOperator(
               hasCondition(
                 implicitCastExpr(
                   hasSourceExpression(
                     opaqueValueExpr(
                       hasSourceExpression(integerLiteral(equals(1))))),
                   hasType(booleanType()))),
               hasTrueExpression(
                 opaqueValueExpr(hasSourceExpression(
                                   integerLiteral(equals(1))))),
               hasFalseExpression(
                 unaryOperator(hasOperatorName("-"),
                               hasUnaryOperand(integerLiteral(equals(5)))))
                 ))))));
 }
 
-TEST(ImportExpr, ImportDesignatedInitExpr) {
+TEST_P(ImportExpr, ImportDesignatedInitExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("void declToImport() {"
              "  struct point { double x; double y; };"
              "  struct point ptarray[10] = "
                     "{ [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 }; }",
              Lang_C, "", Lang_C, Verifier,
              functionDecl(
                hasBody(
testImport("void declToImport() {"
                                        has(floatLiteral(
                                              equals(1.0))),
                                        has(integerLiteral(
                                              equals(0)))))
                                    ))))))))))));
 }
 
 
-TEST(ImportExpr, ImportPredefinedExpr) {
+TEST_P(ImportExpr, ImportPredefinedExpr) {
   MatchVerifier<Decl> Verifier;
   // __func__ expands as StringLiteral("declToImport")
   testImport("void declToImport() { __func__; }",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionDecl(
                hasBody(
                  compoundStmt(
                    has(
                      predefinedExpr(
                        hasType(
                          asString("const char [13]")),
                        has(
                          stringLiteral(
                            hasType(
                              asString("const char [13]"))))))))));
 }
 
-TEST(ImportExpr, ImportInitListExpr) {
+TEST_P(ImportExpr, ImportInitListExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
     "void declToImport() {"
     "  struct point { double x; double y; };"
     "  point ptarray[10] = { [2].y = 1.0, [2].x = 2.0,"
     "                        [0].x = 1.0 }; }",
     Lang_CXX, "", Lang_CXX, Verifier,
     functionDecl(
functionDecl(
                           has(floatLiteral(equals(2.0))),
                           has(floatLiteral(equals(1.0)))))
                         ))))))))));
 }
 
 
 const internal::VariadicDynCastAllOfMatcher<Expr, VAArgExpr> vaArgExpr;
 
-TEST(ImportExpr, ImportVAArgExpr) {
+TEST_P(ImportExpr, ImportVAArgExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("void declToImport(__builtin_va_list list, ...) {"
              "  (void)__builtin_va_arg(list, int); }",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionDecl(
                hasBody(
                  compoundStmt(
                    has(
                      cStyleCastExpr(
                        hasSourceExpression(
                          vaArgExpr())))))));
 }
 
-TEST(ImportExpr, CXXTemporaryObjectExpr) {
+TEST_P(ImportExpr, CXXTemporaryObjectExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("struct C {};"
              "void declToImport() { C c = C(); }",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionDecl(hasBody(compoundStmt(has(
                  declStmt(has(varDecl(has(exprWithCleanups(has(cxxConstructExpr(
                      has(materializeTemporaryExpr(has(implicitCastExpr(
                          has(cxxTemporaryObjectExpr())))))))))))))))));
 }
 
-TEST(ImportType, ImportAtomicType) {
+TEST_P(ImportType, ImportAtomicType) {
   MatchVerifier<Decl> Verifier;
   testImport("void declToImport() { typedef _Atomic(int) a_int; }",
              Lang_CXX11, "", Lang_CXX11, Verifier,
              functionDecl(
                hasBody(
                  compoundStmt(
                    has(
                      declStmt(
                        has(
                          typedefDecl(
                            has(atomicType())))))))));
 }
 
-TEST(ImportDecl, ImportFunctionTemplateDecl) {
+TEST_P(ImportDecl, ImportFunctionTemplateDecl) {
   MatchVerifier<Decl> Verifier;
   testImport("template <typename T> void declToImport() { };", Lang_CXX, "",
              Lang_CXX, Verifier, functionTemplateDecl());
 }
 
 const internal::VariadicDynCastAllOfMatcher<Expr, CXXDependentScopeMemberExpr>
     cxxDependentScopeMemberExpr;
 
-TEST(ImportExpr, ImportCXXDependentScopeMemberExpr) {
+TEST_P(ImportExpr, ImportCXXDependentScopeMemberExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("template <typename T> struct C { T t; };"
              "template <typename T> void declToImport() {"
              "  C<T> d;"
              "  d.t;"
              "}"
              "void instantiate() { declToImport<int>(); }",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionTemplateDecl(has(functionDecl(
                  has(compoundStmt(has(cxxDependentScopeMemberExpr())))))));
   testImport("template <typename T> struct C { T t; };"
              "template <typename T> void declToImport() {"
              "  C<T> d;"
              "  (&d)->t;"
              "}"
              "void instantiate() { declToImport<int>(); }",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionTemplateDecl(has(functionDecl(
                  has(compoundStmt(has(cxxDependentScopeMemberExpr())))))));
 }
 
-TEST(ImportType, ImportTypeAliasTemplate) {
+TEST_P(ImportType, ImportTypeAliasTemplate) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "template <int K>"
       "struct dummy { static const int i = K; };"
       "template <int K> using dummy2 = dummy<K>;"
       "int declToImport() { return dummy2<3>::i; }",
       Lang_CXX11, "", Lang_CXX11, Verifier,
       functionDecl(
           hasBody(compoundStmt(
               has(returnStmt(has(implicitCastExpr(has(declRefExpr()))))))),
           unless(hasAncestor(translationUnitDecl(has(typeAliasDecl()))))));
 }
 
 const internal::VariadicDynCastAllOfMatcher<Decl, VarTemplateSpecializationDecl>
     varTemplateSpecializationDecl;
 
-TEST(ImportDecl, ImportVarTemplate) {
+TEST_P(ImportDecl, ImportVarTemplate) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "template <typename T>"
       "T pi = T(3.1415926535897932385L);"
       "void declToImport() { pi<int>; }",
       Lang_CXX11, "", Lang_CXX11, Verifier,
       functionDecl(
           hasBody(has(declRefExpr(to(varTemplateSpecializationDecl())))),
           unless(hasAncestor(translationUnitDecl(has(varDecl(
               hasName("pi"), unless(varTemplateSpecializationDecl()))))))));
 }
 
-TEST(ImportType, ImportPackExpansion) {
+TEST_P(ImportType, ImportPackExpansion) {
   MatchVerifier<Decl> Verifier;
   testImport("template <typename... Args>"
              "struct dummy {"
              "  dummy(Args... args) {}"
              "  static const int i = 4;"
              "};"
              "int declToImport() { return dummy<int>::i; }",
              Lang_CXX11, "", Lang_CXX11, Verifier,
              functionDecl(
                hasBody(
                  compoundStmt(
                    has(
                      returnStmt(
                        has(
                          implicitCastExpr(
                            has(
                              declRefExpr())))))))));
 }
 
 const internal::VariadicDynCastAllOfMatcher<Type,
                                             DependentTemplateSpecializationType>
     dependentTemplateSpecializationType;
 
-TEST(ImportType, ImportDependentTemplateSpecialization) {
+TEST_P(ImportType, ImportDependentTemplateSpecialization) {
   MatchVerifier<Decl> Verifier;
   testImport("template<typename T>"
              "struct A;"
              "template<typename T>"
              "struct declToImport {"
              "  typename A<T>::template B<T> a;"
              "};",
              Lang_CXX, "", Lang_CXX, Verifier,
              classTemplateDecl(has(cxxRecordDecl(has(
                  fieldDecl(hasType(dependentTemplateSpecializationType())))))));
 }
 
 const internal::VariadicDynCastAllOfMatcher<Stmt, SizeOfPackExpr>
     sizeOfPackExpr;
 
-TEST(ImportExpr, ImportSizeOfPackExpr) {
+TEST_P(ImportExpr, ImportSizeOfPackExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("template <typename... Ts>"
              "void declToImport() {"
              "  const int i = sizeof...(Ts);"
              "};"
              "void g() { declToImport<int>(); }",
              Lang_CXX11, "", Lang_CXX11, Verifier,
              functionTemplateDecl(has(functionDecl(

 /// GNU extension to check equivalent types
 /// Given
 /// \code
 ///   __builtin_types_compatible_p(int, int)
 /// \endcode
 //  will generate TypeTraitExpr <...> 'int'
 const internal::VariadicDynCastAllOfMatcher<Stmt, TypeTraitExpr> typeTraitExpr;
 
-TEST(ImportExpr, ImportTypeTraitExpr) {
+TEST_P(ImportExpr, ImportTypeTraitExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("void declToImport() { "
              "  __builtin_types_compatible_p(int, int);"
              "}",
              Lang_C, "", Lang_C, Verifier,
              functionDecl(
                hasBody(
                  compoundStmt(
                    has(
                      typeTraitExpr(hasType(asString("int"))))))));
 }
 
 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTypeidExpr> cxxTypeidExpr;
 
-TEST(ImportExpr, ImportCXXTypeidExpr) {
+TEST_P(ImportExpr, ImportCXXTypeidExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "namespace std { class type_info {}; }"
       "void declToImport() {"
       "  int x;"
       "  auto a = typeid(int); auto b = typeid(x);"
       "}",
       Lang_CXX11, "", Lang_CXX11, Verifier,
       functionDecl(
           hasDescendant(varDecl(
               hasName("a"), hasInitializer(hasDescendant(cxxTypeidExpr())))),
           hasDescendant(varDecl(
               hasName("b"), hasInitializer(hasDescendant(cxxTypeidExpr()))))));
 }
 
-TEST(ImportExpr, ImportTypeTraitExprValDep) {
+TEST_P(ImportExpr, ImportTypeTraitExprValDep) {
   MatchVerifier<Decl> Verifier;
   testImport("template<typename T> struct declToImport {"
              "  void m() { __is_pod(T); }"
              "};"
              "void f() { declToImport<int>().m(); }",
              Lang_CXX11, "", Lang_CXX11, Verifier,
              classTemplateDecl(
                has(
                  cxxRecordDecl(
                    has(
                      functionDecl(
                        hasBody(
                          compoundStmt(
                            has(
                              typeTraitExpr(
                                hasType(booleanType())
                                ))))))))));
 }
 
 const internal::VariadicDynCastAllOfMatcher<Expr, CXXPseudoDestructorExpr>
     cxxPseudoDestructorExpr;
 
-TEST(ImportExpr, ImportCXXPseudoDestructorExpr) {
+TEST_P(ImportExpr, ImportCXXPseudoDestructorExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("typedef int T;"
              "void declToImport(int *p) {"
              "  T t;"
              "  p->T::~T();"
              "}",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionDecl(has(compoundStmt(has(
                  callExpr(has(cxxPseudoDestructorExpr())))))));
 }
 
-TEST(ImportDecl, ImportUsingDecl) {
+TEST_P(ImportDecl, ImportUsingDecl) {
   MatchVerifier<Decl> Verifier;
   testImport("namespace foo { int bar; }"
              "void declToImport() { using foo::bar; }",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionDecl(
                has(
                  compoundStmt(
                    has(

 ///   namespace n { int f; }
 ///   namespace declToImport { using n::f; }
 /// \endcode
 /// usingShadowDecl()
 ///   matches \code f \endcode
 const internal::VariadicDynCastAllOfMatcher<Decl,
                                             UsingShadowDecl> usingShadowDecl;
 
-TEST(ImportDecl, ImportUsingShadowDecl) {
+TEST_P(ImportDecl, ImportUsingShadowDecl) {
   MatchVerifier<Decl> Verifier;
   testImport("namespace foo { int bar; }"
              "namespace declToImport { using foo::bar; }",
              Lang_CXX, "", Lang_CXX, Verifier,
              namespaceDecl(has(usingShadowDecl())));
 }
 
-TEST(ImportExpr, ImportUnresolvedLookupExpr) {
+TEST_P(ImportExpr, ImportUnresolvedLookupExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("template<typename T> int foo();"
              "template <typename T> void declToImport() {"
              "  ::foo<T>;"
              "  ::template foo<T>;"
              "}"
              "void instantiate() { declToImport<int>(); }",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionTemplateDecl(has(functionDecl(
                  has(compoundStmt(has(unresolvedLookupExpr())))))));
 }
 
-TEST(ImportExpr, ImportCXXUnresolvedConstructExpr) {
+TEST_P(ImportExpr, ImportCXXUnresolvedConstructExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("template <typename T> struct C { T t; };"
              "template <typename T> void declToImport() {"
              "  C<T> d;"
              "  d.t = T();"
              "}"
              "void instantiate() { declToImport<int>(); }",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionTemplateDecl(has(functionDecl(has(compoundStmt(has(
                  binaryOperator(has(cxxUnresolvedConstructExpr())))))))));
   testImport("template <typename T> struct C { T t; };"
              "template <typename T> void declToImport() {"
              "  C<T> d;"
              "  (&d)->t = T();"
              "}"
              "void instantiate() { declToImport<int>(); }",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionTemplateDecl(has(functionDecl(has(compoundStmt(has(
                  binaryOperator(has(cxxUnresolvedConstructExpr())))))))));
 }
 
 /// Check that function "declToImport()" (which is the templated function
 /// for corresponding FunctionTemplateDecl) is not added into DeclContext.
 /// Same for class template declarations.
-TEST(ImportDecl, ImportTemplatedDeclForTemplate) {
+TEST_P(ImportDecl, ImportTemplatedDeclForTemplate) {
   MatchVerifier<Decl> Verifier;
   testImport("template <typename T> void declToImport() { T a = 1; }"
              "void instantiate() { declToImport<int>(); }",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionTemplateDecl(hasAncestor(translationUnitDecl(
                  unless(has(functionDecl(hasName("declToImport"))))))));
   testImport("template <typename T> struct declToImport { T t; };"
              "void instantiate() { declToImport<int>(); }",
              Lang_CXX, "", Lang_CXX, Verifier,
              classTemplateDecl(hasAncestor(translationUnitDecl(
                  unless(has(cxxRecordDecl(hasName("declToImport"))))))));
 }
 
-TEST(ImportExpr, CXXOperatorCallExpr) {
+TEST_P(ImportExpr, CXXOperatorCallExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("class declToImport {"
              "  void f() { *this = declToImport(); }"
              "};",
              Lang_CXX, "", Lang_CXX, Verifier,
              cxxRecordDecl(has(cxxMethodDecl(hasBody(compoundStmt(
                  has(exprWithCleanups(has(cxxOperatorCallExpr())))))))));
 }
 
-TEST(ImportExpr, DependentSizedArrayType) {
+TEST_P(ImportExpr, DependentSizedArrayType) {
   MatchVerifier<Decl> Verifier;
   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(
   // We should have only one definition.
   EXPECT_EQ(1u, DeclCounterWithPredicate<ClassTemplateSpecializationDecl>(
                     [](const ClassTemplateSpecializationDecl *T) {
                       return T->isThisDeclarationADefinition();
                     })
                     .match(ToTU, classTemplateSpecializationDecl()));
 }
 
-INSTANTIATE_TEST_CASE_P(
-    ParameterizedTests, ASTImporterTestBase,
-    ::testing::Values(ArgVector(), ArgVector{"-fdelayed-template-parsing"}),);
-
 struct ImportFunctions : ASTImporterTestBase {};
 
 TEST_P(ImportFunctions,
        PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition) {
   Decl *FromTU = getTuDecl("void f();", Lang_CXX);
   auto Pattern = functionDecl(hasName("f"));
   FunctionDecl *FromD =
       FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
TEST_P(ImportFunctions, VirtualFlagShouldBePreservedWhenImportingPrototype) {
   CXXMethodDecl *Def = LastDeclMatcher<CXXMethodDecl>().match(FromTU, Pattern);
 
   ASSERT_TRUE(Proto->isVirtual());
   ASSERT_TRUE(Def->isVirtual());
   CXXMethodDecl *To = cast<CXXMethodDecl>(Import(Proto, Lang_CXX));
   EXPECT_TRUE(To->isVirtual());
 }
 
-INSTANTIATE_TEST_CASE_P(
-    ParameterizedTests, ImportFunctions,
-    ::testing::Values(ArgVector(), ArgVector{"-fdelayed-template-parsing"}),);
-
 AST_MATCHER_P(TagDecl, hasTypedefForAnonDecl, Matcher<TypedefNameDecl>,
               InnerMatcher) {
   if (auto *Typedef = Node.getTypedefNameForAnonDecl())
     return InnerMatcher.matches(*Typedef, Finder, Builder);
   return false;
 }
 
-TEST(ImportDecl, ImportEnumSequential) {
+TEST_P(ImportDecl, ImportEnumSequential) {
   CodeFiles Samples{{"main.c",
                      {"void foo();"
                       "void moo();"
                       "int main() { foo(); moo(); }",
                       Lang_C}},
 
                     {"foo.c",
                      {"typedef enum { THING_VALUE } thing_t;"
testImportSequence(
       Samples, {ImportMoo, ImportFoo}, // "moo", them "foo".
       // Check that there is only one enum decl in the result AST.
       "main.c", enumDecl(), VerificationMatcher);
 }
 
 const internal::VariadicDynCastAllOfMatcher<Expr, DependentScopeDeclRefExpr>
     dependentScopeDeclRefExpr;
 
-TEST(ImportExpr, DependentScopeDeclRefExpr) {
+TEST_P(ImportExpr, DependentScopeDeclRefExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("template <typename T> struct S { static T foo; };"
              "template <typename T> void declToImport() {"
              "  (void) S<T>::foo;"
              "}"
              "void instantiate() { declToImport<int>(); }",
              Lang_CXX11, "", Lang_CXX11, Verifier,
              functionTemplateDecl(has(functionDecl(has(compoundStmt(
testImport("template <typename T> struct S {"
              Lang_CXX11, "", Lang_CXX11, Verifier,
              functionTemplateDecl(has(functionDecl(has(compoundStmt(
                  has(callExpr(has(dependentScopeDeclRefExpr())))))))));
 }
 
 const internal::VariadicDynCastAllOfMatcher<Type, DependentNameType>
     dependentNameType;
 
-TEST(ImportExpr, DependentNameType) {
+TEST_P(ImportExpr, DependentNameType) {
   MatchVerifier<Decl> Verifier;
   testImport("template <typename T> struct declToImport {"
              "  typedef typename T::type dependent_name;"
              "};",
              Lang_CXX11, "", Lang_CXX11, Verifier,
              classTemplateDecl(has(
                  cxxRecordDecl(has(typedefDecl(has(dependentNameType())))))));
 }
 
 const internal::VariadicDynCastAllOfMatcher<Expr, UnresolvedMemberExpr>
     unresolvedMemberExpr;
 
-TEST(ImportExpr, UnresolvedMemberExpr) {
+TEST_P(ImportExpr, UnresolvedMemberExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("struct S { template <typename T> void mem(); };"
              "template <typename U> void declToImport() {"
              "  S s;"
              "  s.mem<U>();"
              "}"
              "void instantiate() { declToImport<int>(); }",
              Lang_CXX11, "", Lang_CXX11, Verifier,
TEST_P(DeclContextTest, removeDeclOfClassTemplateSpecialization) {
   auto *Spec = FirstDeclMatcher<ClassTemplateSpecializationDecl>().match(
       TU, classTemplateSpecializationDecl());
   ASSERT_TRUE(NS->containsDecl(Spec));
 
   NS->removeDecl(Spec);
   EXPECT_FALSE(NS->containsDecl(Spec));
 }
 
-INSTANTIATE_TEST_CASE_P(
-    ParameterizedTests, DeclContextTest,
-    ::testing::Values(ArgVector(), ArgVector{"-fdelayed-template-parsing"}),);
+INSTANTIATE_TEST_CASE_P(ParameterizedTests, DeclContextTest,
+                        ::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, ImportExpr,
+                        DefaultTestValuesForRunOptions, );
+
+INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportType,
+                        DefaultTestValuesForRunOptions, );
+
+INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportDecl,
+                        DefaultTestValuesForRunOptions, );
+
+INSTANTIATE_TEST_CASE_P(ParameterizedTests, ASTImporterTestBase,
+                        DefaultTestValuesForRunOptions, );
+
+INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportFunctions,
+                        DefaultTestValuesForRunOptions, );
 
 } // end namespace ast_matchers
 } // end namespace clang

unittests/AST/Language.h

 #include "llvm/Support/ErrorHandling.h"
 #include <vector>
 #include <string>
 
 namespace clang {
 namespace ast_matchers {
 
 typedef std::vector<std::string> ArgVector;
-typedef std::vector<ArgVector> RunOptions;
 
 enum Language {
     Lang_C,
     Lang_C89,
     Lang_CXX,
     Lang_CXX11,
     Lang_CXX14,
     Lang_OpenCL,
     Lang_OBJCXX
 };
 
-inline bool isCXX(Language Lang) {
-  return Lang == Lang_CXX || Lang == Lang_CXX11 || Lang == Lang_CXX14;
-}
-
 ArgVector getBasicRunOptionsForLanguage(Language Lang);
-RunOptions getRunOptionsForLanguage(Language Lang);
 
 } // end namespace ast_matchers
 } // end namespace clang
 
 #endif

unittests/AST/Language.cpp

case Lang_CXX14:
     break;
   case Lang_OpenCL:
   case Lang_OBJCXX:
     llvm_unreachable("Not implemented yet!");
   }
   return BasicArgs;
 }
 
-RunOptions getRunOptionsForLanguage(Language Lang) {
-  ArgVector BasicArgs = getBasicRunOptionsForLanguage(Lang);
-
-  // For C++, test with "-fdelayed-template-parsing" enabled to handle MSVC
-  // default behaviour.
-  if (isCXX(Lang)) {
-    ArgVector ArgsForDelayedTemplateParse = BasicArgs;
-    ArgsForDelayedTemplateParse.emplace_back("-fdelayed-template-parsing");
-    return {BasicArgs, ArgsForDelayedTemplateParse};
-  }
-
-  return {BasicArgs};
-}
-
 } // end namespace ast_matchers
 } // end namespace clang