limitations under the License.
==============================================================================*/

#include <algorithm>
#include <memory>
#include <string>

#include "google/protobuf/text_format.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Twine.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/Regex.h"

  const std::string pb_txt = R"pb(
    user_object {
      identifier: "trackable_list_wrapper"
      version { producer: 1 min_consumer: 1 }
    }
  )pb";

  ASSERT_TRUE(::tensorflow::protobuf::TextFormat::ParseFromString(
      pb_txt, &saved_object_proto));
  TF_ASSERT_OK_AND_ASSIGN(Handle result,
                          BuildSavedUserObject(saved_object_proto));
  EXPECT_EQ(Cast<tf::libtf::List>(result)->size(), 0);
}

namespace {

using ::tensorflow::GraphDef;
using ::tensorflow::NodeDef;
using ::testing::SizeIs;
using ::testing::StrEq;
using ::tsl::protobuf::TextFormat;

TEST(GraphDefTest, MutateNodeDefsMutatesTopLevelNodeDefs) {
  GraphDef graph_def;
  ASSERT_TRUE(TextFormat::ParseFromString(R"pb(
                                            node { name: "foo" }
                                          )pb",

TEST(CcOpGenTest, TestVisibilityChangedToHidden) {
  const string api_def = R"(
op {
  graph_op_name: "Foo"
  visibility: HIDDEN
}
)";
  Env* env = Env::Default();
  OpList op_defs;
  protobuf::TextFormat::ParseFromString(kBaseOpDef, &op_defs);  // NOLINT
  ApiDefMap api_def_map(op_defs);

  string h_file_text, internal_h_file_text;
  // Without ApiDef
  GenerateCcOpFiles(env, op_defs, api_def_map, &h_file_text,

#include "tensorflow/compiler/mlir/quantization/stablehlo/passes/testing/passes.h.inc"

namespace {

using ::stablehlo::quantization::QuantizationSpecs;
using ::tsl::protobuf::TextFormat;
// NOLINTNEXTLINE(misc-include-cleaner) - Required for OSS.
using ::tsl::protobuf::io::ArrayInputStream;

// Empty (default) `QuantizationSpecs` proto.
constexpr absl::string_view kSpecsEmpty = R"pb(specs

using ::stablehlo::quantization::Method;
using ::stablehlo::quantization::QuantizationResult;
using ::stablehlo::quantization::QuantizationResults;
using ::stablehlo::quantization::io::WriteStringToFile;
using ::tsl::protobuf::TextFormat;

// Given a `quantized_func_name` that starts with `kQuantizedFuncPrefix`,
// converts `kQuantizedFuncPrefix` to `kCompositeFuncPrefix`.
std::string GetCompositeFunctionName(const StringRef quantized_func_name) {

      cluster_func_op,
      /*num_replicas=*/1, /*num_cores_per_replica=*/1, {}, &compile_metadata)));

  tensorflow::tpu::TPUCompileMetadataProto expected_compile_metadata;
  ASSERT_TRUE(tsl::protobuf::TextFormat::ParseFromString(
      R"pb(
        num_replicas: 1 num_cores_per_replica: 1
      )pb",
      &expected_compile_metadata));

  EXPECT_THAT(compile_metadata, EqualsProto(expected_compile_metadata));
}

}

Status ParseTextProto(absl::string_view text_proto,
                      absl::string_view prefix_to_strip,
                      protobuf::Message* parsed_proto) {
  protobuf::TextFormat::Parser parser;
  // Don't produce errors when attempting to parse text format as it would fail
  // when the input is actually a binary file.
  NoOpErrorCollector collector;
  parser.RecordErrorsTo(&collector);

namespace {

using ::stablehlo::quantization::QuantizationResults;
using ::stablehlo::quantization::io::ReadFileToString;
using ::testing::SizeIs;
using ::testing::StrEq;
using ::tsl::protobuf::TextFormat;
using ::tsl::testing::IsOk;
using ::tsl::testing::StatusIs;

using SaveQuantizationReportInstrumentationTest = QuantizationTestBase;

TEST_F(SaveQuantizationReportInstrumentationTest, SaveReport) {

        }
        }
        dtype: DT_FLOAT
    }
    }
}
)";

StructuredValue ParseStructuredValue(absl::string_view text_proto) {
  StructuredValue value;
  CHECK(tensorflow::protobuf::TextFormat::ParseFromString(string(text_proto),
                                                          &value));
  return value;
}

}  // namespace

StructuredValue ZeroArgInputSignature() {