};

TEST_F(EnableIrPrintingTest, PassSuccessfullyRuns) {
  mlir::PassManager pm = {ctx_.get()};
  pm.addPass(CreateNoOpPass());
  pm.addNestedPass<mlir::func::FuncOp>(mlir::createCanonicalizerPass());
  pm.addNestedPass<mlir::func::FuncOp>(mlir::createCanonicalizerPass());

  EnableIrPrinting(pm, "dump");

  constexpr absl::string_view program = R"mlir(
module{

        continue;
      }

      op.setValueAttr(DenseStringElementsAttr::get(shaped_type, {filename}));
    }
  }

  // Run the lowering pass.
  PassManager pm(context);
  pm.addNestedPass<func::FuncOp>(CreateInitTextFileToImportPass(""));
  if (failed(pm.run(module))) return signalPassFailure();
}

#define GEN_PASS_DEF_INITTEXTFILETOIMPORTSAVEDMODELTESTPASS

  // Inline and optimize loaded functions.
  MLIRContext* context = &getContext();
  PassManager pm(context);
  pm.addPass(createInlinerPass());
  pm.addNestedPass<func::FuncOp>(createCanonicalizerPass());
  pm.addNestedPass<func::FuncOp>(createCSEPass());

  StatusScopedDiagnosticHandler diagnostic_handler(context);
  if (failed(pm.run(*module_ref))) {

  pm.addPass(CreateTFShapeInferencePass());
  if (options.enable_inliner) {
    pm.addPass(createInlinerPass());
  }
  pm.addPass(createSymbolDCEPass());
  pm.addNestedPass<func::FuncOp>(CreateTFOptimizePass());
  pm.addNestedPass<func::FuncOp>(createCSEPass());
}

std::unique_ptr<OperationPass<func::FuncOp>> CreateTFOptimizePass() {
  return std::make_unique<TensorFlowOptimizePass>();
}

    TF_ASSERT_OK_AND_ASSIGN(module_,
                            GetMlirModuleFromString(module_string, &context_));
    pm_ = std::make_unique<mlir::PassManager>(&context_);
    pm_->addNestedPass<mlir::func::FuncOp>(CreateVerifyClusteringPass());
  }

  mlir::LogicalResult Run() { return pm_->run(module_.get()); }

 private:
  mlir::MLIRContext context_;
  mlir::OwningOpRef<mlir::ModuleOp> module_;

  ::tensorflow::applyTensorflowAndCLOptions(pm);

  // Run island coarsening before shape inference to allow more exact shape
  // inference using constant folding within islands.
  pm.addNestedPass<func::FuncOp>(
      tf_executor::CreateTFExecutorIslandCoarseningPass());
  pm.addPass(CreateTFShapeInferencePass());

  // Assign optimal data layout to layout sensitive operations and delete

  TF_ASSERT_OK(env_->GetChildren(test_dir_, &files));
  EXPECT_THAT(files, ::testing::IsEmpty());

  TF_ASSERT_OK(CreateMlirModule("dead_const.mlir"));
  PassManager pass_manager(&context_);
  pass_manager.addNestedPass<FuncOp>(mlir::createCanonicalizerPass());

  EnablePassIRPrinting(pass_manager, test_group_name_);

  LogicalResult pass_status = pass_manager.run(mlir_module_.get());
  EXPECT_TRUE(pass_status.succeeded());

    TF_ASSERT_OK_AND_ASSIGN(module_,
                            GetMlirModuleFromString(module_string, &context_));

    pm_ = std::make_unique<mlir::PassManager>(&context_);
    pm_->addNestedPass<func::FuncOp>(
        CreateVerifyNoOutsideCompilationMarkersPass());
  }

  mlir::LogicalResult Run() { return pm_->run(module_.get()); }

 private:
  MLIRContext context_;
  OwningOpRef<ModuleOp> module_;

    TF_ASSERT_OK_AND_ASSIGN(module_,
                            GetMlirModuleFromString(module_string, &context_));
    pm_ = std::make_unique<mlir::PassManager>(&context_);
    pm_->addNestedPass<mlir::func::FuncOp>(CreateInputLoweringMetricsPass());
  }

  bool ModulesEqual(const ModuleOp& module_before,
                    const ModuleOp& module_after) {
    return mlir::OperationEquivalence::isEquivalentTo(

    context_.appendDialectRegistry(mlir_registry);
    TF_ASSERT_OK(
        tensorflow::DeserializeMlirModule(module_string, &context_, &module_));

    pm_ = std::make_unique<mlir::PassManager>(&context_);
    pm_->addNestedPass<mlir::func::FuncOp>(
        quant::stablehlo::CreateConvertTFQuantTypesPass());
  }
  mlir::LogicalResult Run() { return pm_->run(module_.get()); }

 private:
  MLIRContext context_;