[New PM] adding unit tests for PassInstrumentation

[fedor.sergeev]

Summary

Register mock instrumentation with PassBuilder and make a run
of pass/analysis checking that corresponding instrumentation calls
are done by pass managers.

(Since I'm new to these unittests) after the overall concept
(as well as details) of my testing approach are confirmed I'm going
to split this change in pieces and attach these pieces to the appropriate
PassInstrumentation patches in my series.

[fedor.sergeev]

unittests/IR/PassBuilderCallbacksTest.cpp

269–275

I'm particularly worried about having to use generic EXPECT_CALLs to essentially ignore majority of PassInstrumentation calls. And then InstrumentedPasses subtests perform sequenced checking for a selected subset only.
It does not look very pretty, but it appeared to be the only way to not dive deep into the details of each and every pass manager on each test.

[philip.pfaffe]

This looks good! I dislike the AnyNumber() expecations you highlighted above, but I see that it's unavoidable without either repeating a lot of the test logic again, or without waiting for something like D39678 to happen.

[fedor.sergeev]

These tests were split and added to the corresponding PassInstrumentation.

unittests/IR/PassBuilderCallbacksTest.cpp

 //===- unittests/IR/PassBuilderCallbacksTest.cpp - PB Callback Tests --===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include <functional>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
+#include <llvm/ADT/Any.h>
 #include <llvm/Analysis/CGSCCPassManager.h>
 #include <llvm/Analysis/LoopAnalysisManager.h>
 #include <llvm/AsmParser/Parser.h>
 #include <llvm/IR/LLVMContext.h>
+#include <llvm/IR/PassInstrumentation.h>
 #include <llvm/IR/PassManager.h>
 #include <llvm/Passes/PassBuilder.h>
+#include <llvm/Support/Regex.h>
 #include <llvm/Support/SourceMgr.h>
 #include <llvm/Transforms/Scalar/LoopPassManager.h>
 
 using namespace llvm;
 
 namespace llvm {
 /// Provide an ostream operator for StringRef.
 ///
 /// For convenience we provide a custom matcher below for IRUnit's and analysis
 /// result's getName functions, which most of the time returns a StringRef. The
 /// matcher makes use of this operator.
 static std::ostream &operator<<(std::ostream &O, StringRef S) {
   return O << S.str();
 }
 }
 
 namespace {
+using testing::AnyNumber;
+using testing::AtLeast;
 using testing::DoDefault;
+using testing::Eq;
+using testing::Ge;
 using testing::Return;
 using testing::Expectation;
 using testing::Invoke;
 using testing::WithArgs;
 using testing::_;
 
 /// A CRTP base for analysis mock handles
 ///
Result run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs) {
       return Handle->run(IR, AM, ExtraArgs...);
     }
   };
 
   Analysis getAnalysis() { return Analysis(static_cast<DerivedT &>(*this)); }
   typename Analysis::Result getResult() {
     return typename Analysis::Result(static_cast<DerivedT &>(*this));
   }
+  static StringRef getName() { return llvm::getTypeName<DerivedT>(); }
 
 protected:
   // FIXME: MSVC seems unable to handle a lambda argument to Invoke from within
   // the template, so we use a boring static function.
   static bool invalidateCallback(IRUnitT &IR, const PreservedAnalyses &PA,
                                  typename AnalysisManagerT::Invalidator &Inv) {
     auto PAC = PA.template getChecker<Analysis>();
     return !PAC.preserved() &&
public:
 
   public:
     PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM,
                           ExtraArgTs... ExtraArgs) {
       return Handle->run(IR, AM, ExtraArgs...);
     }
   };
 
+  static StringRef getName() { return llvm::getTypeName<DerivedT>(); }
+
   Pass getPass() { return Pass(static_cast<DerivedT &>(*this)); }
 
 protected:
   /// Derived classes should call this in their constructor to set up default
   /// mock actions. (We can't do this in our constructor because this has to
   /// run after the DerivedT is constructed.)
   void setDefaults() {
     ON_CALL(static_cast<DerivedT &>(*this),
struct MockAnalysisHandle<Module>
   MOCK_METHOD2(run, Analysis::Result(Module &, ModuleAnalysisManager &));
 
   MOCK_METHOD3(invalidate, bool(Module &, const PreservedAnalyses &,
                                 ModuleAnalysisManager::Invalidator &));
 
   MockAnalysisHandle<Module>() { setDefaults(); }
 };
 
+struct MockPassInstrumentationCallbacks {
+  MockPassInstrumentationCallbacks() {
+    ON_CALL(*this, runBeforePass(_, _, _)).WillByDefault(Return(true));
+    EXPECT_CALL(*this, runBeforePass(_, _, Ge(0))).Times(AnyNumber());
+    EXPECT_CALL(*this, runAfterPass(_, _, Ge(1))).Times(AnyNumber());
+    EXPECT_CALL(*this, runBeforeAnalysis(_, _, _)).Times(AnyNumber());
+    EXPECT_CALL(*this, runAfterAnalysis(_, _, _)).Times(AnyNumber());
+    EXPECT_CALL(*this, startPassManager(_, _, _)).Times(AnyNumber());
+    EXPECT_CALL(*this, finishPassManager(_, _, _)).Times(AnyNumber());
+  }
+  MOCK_METHOD3(runBeforePass,
+               bool(PassInstanceID PassID, llvm::Any, PassExecutionLocation));
+  MOCK_METHOD3(runAfterPass,
+               void(PassInstanceID PassID, llvm::Any, PassExecutionLocation));
+  MOCK_METHOD3(runBeforeAnalysis,
+               void(PassInstanceID PassID, llvm::Any, PassExecutionLocation));
+  MOCK_METHOD3(runAfterAnalysis,
+               void(PassInstanceID PassID, llvm::Any, PassExecutionLocation));
+  MOCK_METHOD0(startPipeline, void());
+  MOCK_METHOD0(endPipeline, void());
+  MOCK_METHOD3(startPassManager,
+               void(PassInstanceID PM, llvm::Any, PassExecutionLocation));
+  MOCK_METHOD3(finishPassManager,
+               void(PassInstanceID PM, llvm::Any, PassExecutionLocation));
+  MOCK_METHOD3(startIteration,
+               void(PassInstanceID PM, int, PassExecutionLocation));
+};
+
 static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
   SMDiagnostic Err;
   return parseAssemblyString(IR, Err, C);
 }
 
+/// Helper for HasName matcher that returns getName both for IRUnit and
+/// for IRUnit pointer wrapper into llvm::Any (wrapped by PassInstrumentation).
+template <typename IRUnitT> StringRef getName(const IRUnitT &IR) {
+  return IR.getName();
+}
+
+template <> StringRef getName(const llvm::Any &WrappedIR) {
+  if (any_isa<const Module *>(WrappedIR))
+    return any_cast<const Module *>(WrappedIR)->getName();
+  if (any_isa<const Function *>(WrappedIR))
+    return any_cast<const Function *>(WrappedIR)->getName();
+  if (any_isa<const Loop *>(WrappedIR))
+    return any_cast<const Loop *>(WrappedIR)->getName();
+  if (any_isa<const LazyCallGraph::SCC *>(WrappedIR))
+    return any_cast<const LazyCallGraph::SCC *>(WrappedIR)->getName();
+  return "<UNKNOWN>";
+}
+/// Define a custom matcher for objects which support a 'getName' method.
+///
+/// LLVM often has IR objects or analysis objects which expose a name
+/// and in tests it is convenient to match these by name for readability.
+/// Usually, this name is either a StringRef or a plain std::string. This
+/// matcher supports any type exposing a getName() method of this form whose
+/// return value is compatible with an std::ostream. For StringRef, this uses
+/// the shift operator defined above.
+///
+/// It should be used as:
+///
+///   HasName("my_function")
+///
+/// No namespace or other qualification is required.
+MATCHER_P(HasName, Name, "") {
+  *result_listener << "has name '" << getName(arg) << "'";
+  return Name == getName(arg);
+}
+
+MATCHER_P(HasNameRegex, Name, "") {
+  *result_listener << "has name '" << getName(arg) << "'";
+  llvm::Regex r(Name);
+  return r.match(getName(arg));
+}
+
 template <typename PassManagerT> class PassBuilderCallbacksTest;
 
 /// This test fixture is shared between all the actual tests below and
 /// takes care of setting up appropriate defaults.
 ///
 /// The template specialization serves to extract the IRUnit and AM types from
 /// the given PassManagerT.
 template <typename TestIRUnitT, typename... ExtraPassArgTs,
           typename... ExtraAnalysisArgTs>
 class PassBuilderCallbacksTest<PassManager<
     TestIRUnitT, AnalysisManager<TestIRUnitT, ExtraAnalysisArgTs...>,
     ExtraPassArgTs...>> : public testing::Test {
 protected:
   using IRUnitT = TestIRUnitT;
   using AnalysisManagerT = AnalysisManager<TestIRUnitT, ExtraAnalysisArgTs...>;
   using PassManagerT =
       PassManager<TestIRUnitT, AnalysisManagerT, ExtraPassArgTs...>;
   using AnalysisT = typename MockAnalysisHandle<IRUnitT>::Analysis;
 
   LLVMContext Context;
   std::unique_ptr<Module> M;
 
+  PassInstrumentation PI;
   PassBuilder PB;
   ModulePassManager PM;
   LoopAnalysisManager LAM;
   FunctionAnalysisManager FAM;
   CGSCCAnalysisManager CGAM;
   ModuleAnalysisManager AM;
 
   MockPassHandle<IRUnitT> PassHandle;
   MockAnalysisHandle<IRUnitT> AnalysisHandle;
+  MockPassInstrumentationCallbacks PassInstrumentationCallbacks;
 
   static PreservedAnalyses getAnalysisResult(IRUnitT &U, AnalysisManagerT &AM,
                                              ExtraAnalysisArgTs &&... Args) {
     (void)AM.template getResult<AnalysisT>(
         U, std::forward<ExtraAnalysisArgTs>(Args)...);
     return PreservedAnalyses::all();
   }
 
   PassBuilderCallbacksTest()
       : M(parseIR(Context,
                   "declare void @bar()\n"
                   "define void @foo(i32 %n) {\n"
                   "entry:\n"
                   "  br label %loop\n"
                   "loop:\n"
                   "  %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ]\n"
                   "  %iv.next = add i32 %iv, 1\n"
                   "  tail call void @bar()\n"
                   "  %cmp = icmp eq i32 %iv, %n\n"
                   "  br i1 %cmp, label %exit, label %loop\n"
                   "exit:\n"
                   "  ret void\n"
                   "}\n")),
-        PM(true), LAM(true), FAM(true), CGAM(true), AM(true) {
+        PI(), PB(nullptr, None, &PI), PM(true), LAM(true), FAM(true),
+        CGAM(true), AM(true) {
 
     /// Register a callback for analysis registration.
     ///
     /// The callback is a function taking a reference to an AnalyisManager
     /// object. When called, the callee gets to register its own analyses with
     /// this PassBuilder instance.
     PB.registerAnalysisRegistrationCallback([this](AnalysisManagerT &AM) {
       // Register our mock analysis
PB.registerPipelineParsingCallback(
           /// Parse the name of our pass mock handle
           if (Name == "test-transform") {
             PM.addPass(PassHandle.getPass());
             return true;
           }
           return false;
         });
 
+    /// Register pass instrumentation
+    PB.registerPassInstrumentation([this](PassInstrumentation &_PI) {
+      using namespace std::placeholders;
+      _PI.registerBeforePassCallback(
+          std::bind(&MockPassInstrumentationCallbacks::runBeforePass,
+                    &PassInstrumentationCallbacks, _1, _2, _3));
+      _PI.registerAfterPassCallback(
+          std::bind(&MockPassInstrumentationCallbacks::runAfterPass,
+                    &PassInstrumentationCallbacks, _1, _2, _3));
+      _PI.registerBeforeAnalysisCallback(
+          std::bind(&MockPassInstrumentationCallbacks::runBeforeAnalysis,
+                    &PassInstrumentationCallbacks, _1, _2, _3));
+      _PI.registerAfterAnalysisCallback(
+          std::bind(&MockPassInstrumentationCallbacks::runAfterAnalysis,
+                    &PassInstrumentationCallbacks, _1, _2, _3));
+      _PI.registerStartPassManagerCallback(
+          std::bind(&MockPassInstrumentationCallbacks::startPassManager,
+                    &PassInstrumentationCallbacks, _1, _2, _3));
+      _PI.registerFinishPassManagerCallback(
+          std::bind(&MockPassInstrumentationCallbacks::finishPassManager,
+                    &PassInstrumentationCallbacks, _1, _2, _3));
+      _PI.registerStartPipelineCallback(
+          std::bind(&MockPassInstrumentationCallbacks::startPipeline,
+                    &PassInstrumentationCallbacks));
+      _PI.registerEndPipelineCallback(
+          std::bind(&MockPassInstrumentationCallbacks::endPipeline,
+                    &PassInstrumentationCallbacks));
+      _PI.registerStartIterationCallback(
+          std::bind(&MockPassInstrumentationCallbacks::startIteration,
+                    &PassInstrumentationCallbacks, _1, _2, _3));
+    });
     /// Register builtin analyses and cross-register the analysis proxies
     PB.registerModuleAnalyses(AM);
     PB.registerCGSCCAnalyses(CGAM);
     PB.registerFunctionAnalyses(FAM);
     PB.registerLoopAnalyses(LAM);
     PB.crossRegisterProxies(LAM, FAM, CGAM, AM);
   }
 };
 
-/// Define a custom matcher for objects which support a 'getName' method.
-///
-/// LLVM often has IR objects or analysis objects which expose a name
-/// and in tests it is convenient to match these by name for readability.
-/// Usually, this name is either a StringRef or a plain std::string. This
-/// matcher supports any type exposing a getName() method of this form whose
-/// return value is compatible with an std::ostream. For StringRef, this uses
-/// the shift operator defined above.
-///
-/// It should be used as:
-///
-///   HasName("my_function")
-///
-/// No namespace or other qualification is required.
-MATCHER_P(HasName, Name, "") {
-  *result_listener << "has name '" << arg.getName() << "'";
-  return Name == arg.getName();
-}
-
 using ModuleCallbacksTest = PassBuilderCallbacksTest<ModulePassManager>;
 using CGSCCCallbacksTest = PassBuilderCallbacksTest<CGSCCPassManager>;
 using FunctionCallbacksTest = PassBuilderCallbacksTest<FunctionPassManager>;
 using LoopCallbacksTest = PassBuilderCallbacksTest<LoopPassManager>;
 
 /// Test parsing of the name of our mock pass for all IRUnits.
 ///
 /// The pass should by default run our mock analysis and then preserve it.
 TEST_F(ModuleCallbacksTest, Passes) {
   EXPECT_CALL(AnalysisHandle, run(HasName("<string>"), _));
   EXPECT_CALL(PassHandle, run(HasName("<string>"), _))
       .WillOnce(Invoke(getAnalysisResult));
 
   StringRef PipelineText = "test-transform";
   ASSERT_TRUE(PB.parsePassPipeline(PM, PipelineText, true))
       << "Pipeline was: " << PipelineText;
+
+  PM.run(*M, AM);
+}
+
+TEST_F(ModuleCallbacksTest, InstrumentedPasses) {
+  EXPECT_CALL(AnalysisHandle, run(HasName("<string>"), _));
+  EXPECT_CALL(PassHandle, run(HasName("<string>"), _))
+      .WillOnce(Invoke(getAnalysisResult));
+
+  {
+    testing::InSequence InstrumentationExpectationsSequenced;
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                startPassManager(_, HasName("<string>"), Eq(0)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                runBeforePass(_, HasName("<string>"), Eq(1)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                runBeforeAnalysis(_, HasName("<string>"), Eq(1)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                runAfterAnalysis(_, HasName("<string>"), Eq(1)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                runAfterPass(_, HasName("<string>"), Eq(1)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                finishPassManager(_, HasName("<string>"), Ge(1)));
+  }
+
+  StringRef PipelineText = "test-transform";
+  ASSERT_TRUE(PB.parsePassPipeline(PM, PipelineText, true))
+      << "Pipeline was: " << PipelineText;
+
   PM.run(*M, AM);
 }
 
 TEST_F(FunctionCallbacksTest, Passes) {
   EXPECT_CALL(AnalysisHandle, run(HasName("foo"), _));
   EXPECT_CALL(PassHandle, run(HasName("foo"), _))
       .WillOnce(Invoke(getAnalysisResult));
 
   StringRef PipelineText = "test-transform";
   ASSERT_TRUE(PB.parsePassPipeline(PM, PipelineText, true))
       << "Pipeline was: " << PipelineText;
   PM.run(*M, AM);
 }
 
+TEST_F(FunctionCallbacksTest, InstrumentedPasses) {
+  EXPECT_CALL(AnalysisHandle, run(HasName("foo"), _));
+  EXPECT_CALL(PassHandle, run(HasName("foo"), _))
+      .WillOnce(Invoke(getAnalysisResult));
+
+  {
+    testing::InSequence InstrumentationExpectationsSequenced;
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                startPassManager(HasNameRegex("PassManager"),
+                                 HasName("<string>"), Eq(0)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                startPassManager(HasNameRegex("PassAdaptor"),
+                                 HasName("<string>"), Eq(1)));
+    EXPECT_CALL(
+        PassInstrumentationCallbacks,
+        startPassManager(HasNameRegex("PassManager"), HasName("foo"), Eq(2)));
+    EXPECT_CALL(
+        PassInstrumentationCallbacks,
+        runBeforePass(HasNameRegex("MockPassHandle"), HasName("foo"), Ge(3)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"),
+                                  HasName("foo"), Ge(3)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                runAfterAnalysis(HasNameRegex("MockAnalysisHandle"),
+                                 HasName("foo"), Ge(3)));
+    EXPECT_CALL(
+        PassInstrumentationCallbacks,
+        runAfterPass(HasNameRegex("MockPassHandle"), HasName("foo"), Ge(3)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                finishPassManager(_, HasName("foo"), Ge(3)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                finishPassManager(_, HasName("<string>"), Ge(3)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                finishPassManager(_, HasName("<string>"), Ge(3)));
+  }
+
+  StringRef PipelineText = "test-transform";
+  ASSERT_TRUE(PB.parsePassPipeline(PM, PipelineText, true))
+      << "Pipeline was: " << PipelineText;
+  PM.run(*M, AM);
+}
+
 TEST_F(LoopCallbacksTest, Passes) {
   EXPECT_CALL(AnalysisHandle, run(HasName("loop"), _, _));
   EXPECT_CALL(PassHandle, run(HasName("loop"), _, _, _))
       .WillOnce(WithArgs<0, 1, 2>(Invoke(getAnalysisResult)));
 
   StringRef PipelineText = "test-transform";
   ASSERT_TRUE(PB.parsePassPipeline(PM, PipelineText, true))
       << "Pipeline was: " << PipelineText;
   PM.run(*M, AM);
 }
 
+TEST_F(LoopCallbacksTest, InstrumentedPasses) {
+  EXPECT_CALL(AnalysisHandle, run(HasName("loop"), _, _));
+  EXPECT_CALL(PassHandle, run(HasName("loop"), _, _, _))
+      .WillOnce(WithArgs<0, 1, 2>(Invoke(getAnalysisResult)));
+  {
+    testing::InSequence InstrumentationExpectationsSequenced;
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                startPassManager(HasNameRegex("PassManager<.*Module.*>"),
+                                 HasName("<string>"), Eq(0)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                startPassManager(HasNameRegex("ModuleToFunctionPassAdaptor"),
+                                 HasName("<string>"), Eq(1)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                startPassManager(HasNameRegex("PassManager<.*Function.*>"),
+                                 HasName("foo"), Eq(2)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                startPassManager(HasNameRegex("FunctionToLoopPassAdaptor"),
+                                 HasName("foo"), Eq(3)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                startPassManager(HasNameRegex("PassManager<.*Loop.*>"),
+                                 HasName("loop"), Ge(4)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                runBeforePass(HasNameRegex("MockPassHandle"),
+                              HasName("loop"), Ge(5)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"),
+                                  HasName("loop"), Ge(5)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                runAfterAnalysis(HasNameRegex("MockAnalysisHandle"),
+                                 HasName("loop"), Ge(5)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                runAfterPass(HasNameRegex("MockPassHandle"),
+                             HasName("loop"), Ge(5)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                finishPassManager(_, HasName("loop"), Ge(5)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                finishPassManager(_, HasName("foo"), Ge(5)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                finishPassManager(_, HasName("foo"), Ge(5)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                finishPassManager(_, HasName("<string>"), Ge(5)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                finishPassManager(_, HasName("<string>"), Ge(5)));
+  }
+
+  StringRef PipelineText = "test-transform";
+  ASSERT_TRUE(PB.parsePassPipeline(PM, PipelineText, true))
+      << "Pipeline was: " << PipelineText;
+  PM.run(*M, AM);
+}
+
 TEST_F(CGSCCCallbacksTest, Passes) {
   EXPECT_CALL(AnalysisHandle, run(HasName("(foo)"), _, _));
   EXPECT_CALL(PassHandle, run(HasName("(foo)"), _, _, _))
       .WillOnce(WithArgs<0, 1, 2>(Invoke(getAnalysisResult)));
 
   StringRef PipelineText = "test-transform";
   ASSERT_TRUE(PB.parsePassPipeline(PM, PipelineText, true))
       << "Pipeline was: " << PipelineText;
   PM.run(*M, AM);
 }
 
+TEST_F(CGSCCCallbacksTest, InstrumentedPasses) {
+  EXPECT_CALL(AnalysisHandle, run(HasName("(foo)"), _, _));
+  EXPECT_CALL(PassHandle, run(HasName("(foo)"), _, _, _))
+      .WillOnce(WithArgs<0, 1, 2>(Invoke(getAnalysisResult)));
+
+  {
+    testing::InSequence InstrumentationExpectationsSequenced;
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                startPassManager(HasNameRegex("PassManager<.*Module.*>"),
+                                 HasName("<string>"), Eq(0)));
+    EXPECT_CALL(
+        PassInstrumentationCallbacks,
+        startPassManager(HasNameRegex("ModuleToPostOrderCGSCCPassAdaptor"),
+                         HasName("<string>"), Eq(1)));
+    EXPECT_CALL(
+        PassInstrumentationCallbacks,
+        startPassManager(HasNameRegex("PassManager<.*LazyCallGraph::SCC.*>"),
+                         HasName("(foo)"), Eq(2)));
+    EXPECT_CALL(
+        PassInstrumentationCallbacks,
+        runBeforePass(HasNameRegex("MockPassHandle"), HasName("(foo)"), Ge(3)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                runBeforeAnalysis(HasNameRegex("MockAnalysisHandle"),
+                                  HasName("(foo)"), Ge(3)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                runAfterAnalysis(HasNameRegex("MockAnalysisHandle"),
+                                 HasName("(foo)"), Ge(3)));
+    EXPECT_CALL(
+        PassInstrumentationCallbacks,
+        runAfterPass(HasNameRegex("MockPassHandle"), HasName("(foo)"), Ge(3)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                finishPassManager(_, HasName("(foo)"), Ge(3)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                finishPassManager(_, HasName("<string>"), Ge(3)));
+    EXPECT_CALL(PassInstrumentationCallbacks,
+                finishPassManager(_, HasName("<string>"), Ge(3)));
+  }
+
+  StringRef PipelineText = "test-transform";
+  ASSERT_TRUE(PB.parsePassPipeline(PM, PipelineText, true))
+      << "Pipeline was: " << PipelineText;
+  PM.run(*M, AM);
+}
+
 /// Test parsing of the names of analysis utilities for our mock analysis
 /// for all IRUnits.
 ///
 /// We first require<>, then invalidate<> it, expecting the analysis to be run
 /// once and subsequently invalidated.
 TEST_F(ModuleCallbacksTest, AnalysisUtilities) {
   EXPECT_CALL(AnalysisHandle, run(HasName("<string>"), _));
   EXPECT_CALL(AnalysisHandle, invalidate(HasName("<string>"), _, _));