}

std::string DeviceCompilationProfiler::DebugString() const {
  std::string debug_string =
      "DeviceCompilationProfiler {\ncluster_compile_stats: {\n";
  {
    mutex_lock lock(mu_);

    for (const auto& [key, stats] : cluster_compile_stats_) {
      absl::StrAppend(&debug_string, key, ": ", stats.DebugString(), "\n");
    }
  }

  absl::StrAppend(&debug_string, "}\nnum_ongoing_compilations=",

  }

  /// Overload AbslHashValue to make TensorSpec hashable.
  template <typename H>
  friend H AbslHashValue(H h, const TensorSpec& t) {
    return H::combine(std::move(h), t.shape.DebugString(), t.dtype);
  }
};

// Defined in `iostream.cc`.
std::ostream& operator<<(std::ostream& o, const TensorSpec& x);

}  // namespace impl
}  // namespace libtf
}  // namespace tf

  if (!AreSerializedProtosEqual(key, entry.key())) {
    VLOG(2) << "Serialized cache key does not match:\n"
            << "got:\n"
            << entry.key().DebugString() << "\nexpected:\n"
            << key.DebugString() << "\n";
    return errors::InvalidArgument("Serialized cache key does not match.");
  }

  // Perform a stricter (slower) check of the snapshot to verify that they
  // match exactly.

        "be nullptr.");
  }

  LOG(INFO) << "User-provided quantization config: "
            << quantization_config.DebugString();
  const QuantizationConfig updated_config =
      ExpandPresets(PopulateDefaults(quantization_config));
  LOG(INFO) << "Updated quantization config: " << updated_config.DebugString();

  const absl::flat_hash_map<std::string, SignatureDef> signature_def_map =

    protobuf::TextFormat::ParseFromString(ExpectedString(#dtype),            \
                                          &expected_proto);                  \
    ASSERT_EQ(expected_proto.DebugString(), list.DebugString());             \
                                                                             \
    TF_DeleteBuffer(buf);                                                    \

  Status status;
  TF_Tensor* tf_tensor = TF_TensorFromTensor(tensor, &status);
  TF_TensorWrapper tensor_wrapper = TF_TensorWrapper(tf_tensor);
  ASSERT_TRUE(status.ok()) << status.ToString();
  ASSERT_EQ(tensor.shape().DebugString(), ShapeDebugString(tf_tensor));
}

TEST(ShapeDebugString, RegularShape) { TestShapeMatch(TensorShape({5, 4, 7})); }

TEST(ShapeDebugString, ScalarShape) { TestShapeMatch(TensorShape({})); }

}  // namespace

}

std::ostream& operator<<(std::ostream& o, const String& str) {
  return o << str.str();
}

std::ostream& operator<<(std::ostream& o, const TensorSpec& x) {
  o << "TensorSpec(shape = " << x.shape.DebugString() << ", dtype = " << x.dtype
    << ")";
  return o;
}

}  // namespace impl
}  // namespace libtf

        } else {
          return av.DebugString() == bv.DebugString();
        }
      },
      absl::StrCat(diff_preamble, " attr mismatch for node ", a.name()), diff);
}

bool EqualFunctionDef(const FunctionDef& a, const FunctionDef& b,
                      string* diff) {
  if (a.signature().DebugString() != b.signature().DebugString()) {
    if (diff) {
      *diff =

void ExpectSummaryMatches(const Summary& actual, const string& expected_str) {
  Summary expected;
  ASSERT_TRUE(protobuf::TextFormat::ParseFromString(expected_str, &expected));
  EXPECT_EQ(expected.DebugString(), actual.DebugString());
}

void TestScalarSummaryOp(Tensor* tags, Tensor* values, string expected_output,
                         error::Code expected_code) {
  // Initialize node used to fetch OpKernel
  Status status;

  // Prints out the internal state of this instance.  For debugging purposes
  // only.
  virtual void Print() const = 0;
  virtual ~DeadnessAnalysis();

  string DebugString(DeadnessPredicate predicate) const;

  // Run the deadness analysis over `graph` and returns an error or a populated
  // instance of DeadnessAnalysis in `result`.
  static Status Run(const Graph& graph,