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

                    "-Duser.country=US," +
                    "-Duser.language=en," +
                    "-Duser.variant"
            ) + "]"
        when:
        DaemonContext parsedContext = DaemonContextParser.parseFromString(contextString, GradleVersion.version("8.7"))
        then:
        parsedContext != null
        parsedContext.javaVersion == JavaLanguageVersion.of(8) // hardcoded in fixture
    }

  }

  // Use TOCO to produce new outputs.
  toco::ModelFlags model_flags;
  if (!model_flags.ParseFromString(model_flags_proto_txt)) {
    PyErr_SetString(PyExc_ValueError,
                    "Failed to convert Model to Python String.");
    return nullptr;
  }
  toco::TocoFlags toco_flags;
  if (!toco_flags.ParseFromString(toco_flags_proto_txt)) {
    PyErr_SetString(PyExc_ValueError,

}

TEST(CreateExportedModelTest, CreateExportedModelWithAddedAssetFileDefs) {
  AssetFileDef asset1;
  ASSERT_TRUE(
      TextFormat::ParseFromString(R"pb(filename: "fname1")pb", &asset1));

  AssetFileDef asset2;
  ASSERT_TRUE(
      TextFormat::ParseFromString(R"pb(filename: "fname2")pb", &asset2));

  const ExportedModel exported_model = CreateExportedModelFromGraphDef(

  tsl::protobuf::TextFormat::Parser parser;
  NoOpErrorCollector collector;
  parser.RecordErrorsTo(&collector);
  return hlo_proto->ParseFromString(contents) ||
         parser.ParseFromString(contents, hlo_proto) ||
         hlo_proto->mutable_hlo_module()->ParseFromString(contents) ||
         parser.ParseFromString(contents, hlo_proto->mutable_hlo_module());
}

mlir::OwningOpRef<mlir::ModuleOp> HloToMlirHloTranslateFunction(

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",
                                          &graph_def));
  MutateNodeDefs(graph_def,

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,

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

        }
        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() {

                                   Value lhs, Value rhs, Value output,
                                   StringAttr dot_dimension_numbers_str) {
  xla::DotDimensionNumbers dot_dimension_numbers;
  dot_dimension_numbers.ParseFromString(dot_dimension_numbers_str.str());
  SmallVector<Value> input_arguments = {lhs, rhs};
  const int lhs_rank = mlir::cast<ShapedType>(lhs.getType()).getShape().size();