static void InitializeTestRNG() {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> distribution;
    rng_val_ = distribution(gen);
  }

  static void SetCloudPath(const std::string& cloud_path) {
    cloud_path_ = cloud_path;
    if (cloud_path_.back() == '/') cloud_path_.pop_back();
  }

  static void SetTmpDir(const std::string& tmp_dir) {

  // corresponding `request_count`. Only arguments that are not std::nullopt are
  // updated in the cache.
  void Store(const Key& key, std::optional<DeviceCompileState> compile_state,
             std::optional<Status> compilation_status,
             std::optional<std::unique_ptr<XlaCompiler::CompilationResult>>
                 compilation_result,
             std::optional<std::unique_ptr<ExecutableType>> executable);

GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os);
inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
  PrintStringTo(s, os);
}

// Overloads for ::wstring and ::std::wstring.
#if GTEST_HAS_GLOBAL_WSTRING
GTEST_API_ void PrintWideStringTo(const ::wstring&s, ::std::ostream* os);
inline void PrintTo(const ::wstring& s, ::std::ostream* os) {
  PrintWideStringTo(s, os);
}

  SymbolTableCollection symbol_table;
  // List pending nodes to traverse with their root TPU cluster.
  llvm::SmallVector<std::pair<CallGraphNode*, tf_device::ClusterOp>>
      pending_call_nodes;
  // Cache the host device for each TPU cluster.
  std::unordered_map<Operation*, std::optional<std::string>> cluster_to_host;

  auto insert_pending_op = [&](Operation* op,
                               tf_device::ClusterOp tpu_cluster) {

                    const std::vector<Output>& grad_inputs,
                    std::vector<Output>* grad_outputs) {
  grad_outputs->push_back(Identity(scope, grad_inputs[0]));
  return scope.status();
}
REGISTER_GRADIENT_OP("Identity", IdentityGrad);

Status RefIdentityGrad(const Scope& scope, const Operation& op,
                       const std::vector<Output>& grad_inputs,

  std::unordered_set<int> GetStopBackpropNodes(
      const std::vector<bool>& reachable_nodes,
      const std::unordered_set<int>& output_nodes) const;

  const Scope& scope_;
  const ops::GradOpRegistry* registry_;
  const std::vector<Output>& outputs_;
  const std::vector<Output>& inputs_;
  const std::vector<Output>& grad_inputs_;
  std::vector<Output>* grad_outputs_;

      }
    }
    return false;
  }

  std::optional<string> op;
  std::optional<string> name;
  std::optional<string> assigned_device;
  std::optional<Tensor> constant_value;
  std::optional<std::vector<::testing::Matcher<OutEdge>>> input_matchers;
  std::optional<::testing::Matcher<absl::Span<const Node* const>>>
      control_dep_set;
  std::map<string, std::optional<AttrValue>> attrs;
};

namespace tensorflow {

SignatureDefParam::SignatureDefParam(std::string name, TensorSpec spec)
    : name_(std::move(name)), spec_(std::move(spec)) {}

const std::string& SignatureDefParam::name() const { return name_; }

const TensorSpec& SignatureDefParam::spec() const { return spec_; }

SignatureDefFunctionMetadata::SignatureDefFunctionMetadata(
    std::vector<SignatureDefParam> arguments,
    std::vector<SignatureDefParam> returns)

          const absl::flat_hash_map<std::string, std::string>& frontend_attrs)
          -> absl::StatusOr<tsl::AsyncValueRef<std::unique_ptr<se::Event>>> {
        auto iter = frontend_attrs.find("_xla_host_transfer_rendezvous");

        // Generate the Rendezvous key.
        const std::string& rendezvous_key_base =
            absl::StrCat(program_key, iter->second);

        const std::string& dst_device = ctx->device()->name();

      hardwares_ops =
          []() -> std::vector<std::unique_ptr<RegisteredTargetHardwareOps>>* {
    return new std::vector<std::unique_ptr<RegisteredTargetHardwareOps>>();
  }();
  return hardwares_ops;
}

std::vector<RegisteredTargetHardware>* GetRegisteredHardwares() {
  static std::vector<RegisteredTargetHardware>* hardwares =
      []() -> std::vector<RegisteredTargetHardware>* {