std::unique_ptr<OperationPass<func::FuncOp>> CreateTestClusteringPolicyPass();

// Test pass for analyzing side-effect analysis result.
std::unique_ptr<OperationPass<ModuleOp>> CreateTestSideEffectAnalysisPass();

std::unique_ptr<OperationPass<ModuleOp>> CreateTestResourceAliasAnalysisPass();

std::unique_ptr<OperationPass<ModuleOp>> CreateInitTextFileToImportTestPass();
std::unique_ptr<OperationPass<ModuleOp>>

}

absl::StatusOr<std::optional<SaverDef>> CreateSaverDef(
    const std::vector<std::string>& control_ret_node_names,
    const GraphDef& graph_def) {
  const std::string filename_tensor_name = FindFilePrefixTensorName(graph_def);
  const std::string restore_op_name =
      GetNodeName(control_ret_node_names, kTfSavedModelInitializerRestoreType);
  const std::string save_node_name =

#include <string>

#include "tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.h"

namespace tensorflow {
DataDumperLoggerConfig::DataDumperLoggerConfig(
    std::function<std::string(const std::string &, mlir::Operation *op)>
        get_filename,
    const std::string &pass_prefix, bool print_module_scope,
    bool print_after_only_on_change, mlir::OpPrintingFlags op_printing_flags)
    : ::tensorflow::BridgeLoggerConfig(

  return out;
}

std::string AttrAsString(mlir::Attribute& attr) {
  std::string out;
  llvm::raw_string_ostream attr_stream(out);
  attr.print(attr_stream);
  return out;
}

std::ostream& operator<<(std::ostream& o, const LoggableOperation& op) {
  return o << OpAsString(op.v);
}

std::ostream& operator<<(std::ostream& o, const LoggableAttribute& attr) {

 private:
  static void DumpMlir(const std::string &filename,
                       BridgeLoggerConfig::PrintCallbackFn print_callback);

  // The function to dump the target MLIR string to file.
  // The parameter that will be sent to the dump_func_ is:
  // The pass name (std::string)
  std::function<std::string(const std::string &, mlir::Operation *op)>
      get_filename_;

  // The pass prefix.

namespace tflite {
namespace {
std::unique_ptr<mlir::TFL::tac::TacImporter> CreateTfLiteImporter(
    const std::string input_file_name) {
  mlir::TFL::tac::TfLiteImporter::Options options;
  options.file_name = input_file_name;
  options.input_mlir = false;
  return std::make_unique<mlir::TFL::tac::TfLiteImporter>(options);
}

std::unique_ptr<mlir::TFL::tac::TacExporter> CreateTfLiteExporter(

namespace tensorflow {
namespace saved_model {

std::string GetWriteVersion(const SavedModel& saved_model) {
  if (saved_model.meta_graphs_size() == 1 &&
      saved_model.meta_graphs()[0].has_object_graph_def()) {
    return "2";
  }
  return "1";
}

std::set<std::string> GetMapKeys(
    const ::google::protobuf::Map<std::string, ::tensorflow::TensorProto>& map) {
  std::set<std::string> keys;
  for (const auto& it : map) {

TEST(CoordinatorTest, TestJoin) {
  Coordinator coord;
  int join_counter = 0;
  std::unique_ptr<MockQueueRunner> qr1(
      new MockQueueRunner(&coord, &join_counter));
  TF_ASSERT_OK(coord.RegisterRunner(std::move(qr1)));
  std::unique_ptr<MockQueueRunner> qr2(
      new MockQueueRunner(&coord, &join_counter));
  TF_ASSERT_OK(coord.RegisterRunner(std::move(qr2)));

  TF_EXPECT_OK(coord.RequestStop());
  TF_EXPECT_OK(coord.Join());

Status PreparePjRtExecutableArguments(
    int num_missing_prefix_ctx_inputs, const std::vector<int>& input_mapping,
    const std::vector<const Tensor*>& inputs,
    const absl::flat_hash_map<int, const Tensor*>& variable_snapshots,
    xla::PjRtClient* pjrt_client, xla::PjRtDevice* pjrt_device,
    bool use_pjrt_tensor_buffer, std::vector<xla::PjRtBuffer*>* args,
    std::vector<std::unique_ptr<xla::PjRtBuffer>>* owned_args,

TEST_F(CalibrationStatisticsSaverTest, SimpleMinMax) {
  std::vector<std::string> ids{"1"};
  std::vector<int32_t> calibration_methods{
      CalibrationOptions::CALIBRATION_METHOD_MIN_MAX};

  std::vector<NodeDefBuilder::NodeOut> inputs;
  inputs.emplace_back("min", 0, DT_FLOAT);
  inputs.emplace_back("max", 0, DT_FLOAT);
  inputs.emplace_back("histogram", 0, DT_INT64);

  const std::string dir = testing::TmpDir();