using ::stablehlo::quantization::FunctionNameMatcherSpec;
using ::stablehlo::quantization::Method;
using ::stablehlo::quantization::QuantizationSpec;
using ::stablehlo::quantization::QuantizationSpecs;
using ::tsl::protobuf::TextFormat;

// TODO - b/303543789: Move the helper functions below to a separate util.
// Fetches the default or null attribute, used for pattern matching.
Attribute DefaultOrNullAttr(OpBuilder& builder, const Attribute& attr) {

# pylint: disable=undefined-variable
# Configuration file for the 'lit' test runner.

# name: The name of this test suite.
config.name = 'MLIR ' + os.path.basename(config.mlir_test_dir)

config.test_format = lit.formats.ShTest(not llvm_config.use_lit_shell)

# suffixes: A list of file extensions to treat as test files.
config.suffixes = ['.cc', '.hlo', '.json', '.mlir', '.pbtxt', '.py']

#include "tensorflow/core/public/version.h"

namespace tensorflow {

std::shared_ptr<NodeProperties> ToNodeProperties(const string& text) {
  NodeDef node_def;
  DataTypeVector dummy;
  EXPECT_TRUE(protobuf::TextFormat::MergeFromString(text, &node_def));
  return std::make_shared<NodeProperties>(nullptr, std::move(node_def), dummy,
                                          dummy);
}

    }

    /**
     * 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");

  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'"

};

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) ||