}

    /**
     * Test method for
     * {@link org.codelibs.core.log.Logger#format(String, Object...)} .
     */
    @SuppressWarnings("static-access")
    @Test
    public void testFormat() {
        exception.expect(ClIllegalArgumentException.class);
        exception.expectMessage(is("[ECL0009]argument[AUTL0009] is illegal. because messageCode : AUTL0009."));
        Logger.format("AUTL0009", "hoge");

namespace {

using ::tensorflow::string;

// Add the values of three variables on three different tasks.
string AddVariablesFunction() {
  tensorflow::FunctionDef def;
  CHECK(tensorflow::protobuf::TextFormat::ParseFromString(
      "    signature {"
      "      name: 'AddVariablesFunction'"
      "      input_arg {"
      "        name: 'var'"
      "        type: DT_RESOURCE"
      "      }"
      "      output_arg {"

using ::stablehlo::quantization::io::ReadFileToString;
using ::testing::HasSubstr;
using ::testing::IsEmpty;
using ::testing::SizeIs;
using ::testing::StrEq;
using ::testing::TempDir;
using ::tsl::protobuf::TextFormat;
using ::tsl::testing::IsOk;

using QuantizationReportTest = ::mlir::quant::QuantizationTestBase;

TEST_F(QuantizationReportTest, GetQuantizationResultsReturnsEmptyResults) {
  QuantizationReport report{};

  TF_ASSERT_OK(session->Run(inputs_2x2, output_names,
                            /*target_tensor_names=*/{}, &outputs));

  XlaAutoClusteringActivity expected_auto_clustering_activity;
  protobuf::TextFormat::ParseFromString(
      R"(global_jit_level: ON_2
cpu_global_jit_enabled: true
summary {
  unclustered_node_count: 4
  clustered_node_count: 14
  clusters {
    name: "cluster_0"
    size: 14

#include "tensorflow/core/protobuf/saved_object_graph.pb.h"

namespace tensorflow {
namespace {

SavedObjectGraph ParseSavedObjectGraph(StringPiece text_proto) {
  SavedObjectGraph value;
  CHECK(tensorflow::protobuf::TextFormat::ParseFromString(string(text_proto),
                                                          &value));
  return value;
}

constexpr absl::string_view kSingleChildFoo = R"(
nodes {
  children {
    node_id: 1

    return cpu_allocator();
  }
};

// Helper for comparing output and expected output
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,

    }
  }

  return absl::OkStatus();
}

Status ReadTextProtoFromString(Env* env, const string& data,
                               ::tensorflow::protobuf::Message* proto) {
  if (!::tensorflow::protobuf::TextFormat::ParseFromString(data, proto)) {
    return errors::DataLoss("Can't parse input data as text proto");
  }
  return absl::OkStatus();
}
}  // namespace

Status AutoClusteringTest::RunAutoClusteringTestImpl(

#include "tensorflow/core/protobuf/tensorflow_server.pb.h"

using ::tensorflow::string;

string MatMulFunction(const string& matmul_device) {
  tensorflow::FunctionDef def;
  CHECK(tensorflow::protobuf::TextFormat::ParseFromString(
      absl::StrCat("    signature {"
                   "      name: 'MatMulFunction'"
                   "      input_arg {"
                   "        name: 'a'"

#include "tensorflow/core/platform/mutex.h"
#include "tsl/platform/protobuf.h"  // IWYU pragma: keep

namespace mlir::quant {

using ::stablehlo::quantization::Method;
using ::tsl::protobuf::TextFormat;

// Default version number for native serialization.
constexpr int64_t kDefaultVersion = 9;
// Default platform for XlaCallModuleOp.
constexpr StringRef kPlatformCpu = "CPU";

};

bool LoadHloProto(const std::string& contents, xla::HloProto* hlo_proto) {
  // NOLINTNEXTLINE: Use tsl::protobuf to be compatible with OSS.
  tsl::protobuf::TextFormat::Parser parser;
  NoOpErrorCollector collector;
  parser.RecordErrorsTo(&collector);
  return hlo_proto->ParseFromString(contents) ||
         parser.ParseFromString(contents, hlo_proto) ||