ExpectNodeEqual<double>(c.node(), {42.0, 42.0, 42.0, 42.0}, {2, 2});

  auto d = ops::Const(root, {"1", "2", "3", "4", "5", "6"}, {2, 3});
  TF_CHECK_OK(root.status());
  EXPECT_EQ(d.op().output_type(0), DT_STRING);
  ExpectNodeEqual<tstring>(d.node(), {"1", "2", "3", "4", "5", "6"}, {2, 3});
}

TEST(ConstOpTest, FromProto) {
  Scope root = Scope::NewRootScope();
  TensorProto proto;
  proto.set_dtype(DT_DOUBLE);

  EXPECT_FALSE(root.status().ok());
}

TEST(CCOpTest, InvalidFinalize) {
  Scope root = Scope::NewRootScope();
  auto read_up_to =
      ops::ReaderReadUpTo(root, Variable(root, {}, DT_STRING),
                          Variable(root, {}, DT_STRING), static_cast<int32>(2));
  EXPECT_FALSE(root.status().ok());
  auto err_msg = std::string(root.status().message());
  EXPECT_NE(err_msg.find("'num_records' passed int32 expected int64"),

  // Add a _Retval node to loop body.
  NodeDefBuilder ret_builder(
      absl::StrCat("recv_oc_while_body_ret_", while_node_name), "_Retval");
  ret_builder.Attr("T", DT_STRING);
  ret_builder.Attr("index", 0);
  ret_builder.Input(key_arg->name(), 0, DT_STRING);
  NodeDef ret_def;
  TF_RETURN_IF_ERROR(ret_builder.Finalize(&ret_def));
  TF_ASSIGN_OR_RETURN(Node * ret_node, body_graph->AddNode(ret_def));

    case DT_BFLOAT16:
    case DT_HALF:
    case DT_FLOAT8_E5M2:
    case DT_FLOAT8_E4M3FN:
      return ConvertTensorOfCustomFloatType(input_tensor, type);
    case DT_STRING:
      return ConvertStringTensor(input_tensor, type);
    default:
      // TODO(hinsu): Remove mangling now that there is a special attribute.
      return ElementsAttr(

                                      const std::string& s,
                                      ImmediateTensorHandlePtr* out) {
  int64_t flat_shape[] = {1};
  AbstractTensorPtr tensor(ctx->CreateTensor(DT_STRING, flat_shape));
  if (tensor.get() == nullptr) {
    return errors::Internal(
        "Failed to create vector string tensor for checkpoint restore");
  }
  // Use placement new to construct the string, since we don't have

  Tensor t(first.tensor.dtype(), shape);

  // Collate the constituent Tensors.
  size_t offset = 0;
  for (auto const& e : v) {
    Tensor elem = e.tensor;
    if (first.tensor.dtype() == DT_STRING) {
      for (int i = 0; i < elem.NumElements(); ++i) {
        t.flat<tstring>()(offset + i) = elem.flat<tstring>()(i);
      }
      offset += elem.NumElements();
    } else {

      TF_RETURN_IF_ERROR(ValidateFunctionNotRecursive(function));
    }
  }

  return absl::OkStatus();
}

Tensor CreateStringTensor(const string& value) {
  Tensor tensor(DT_STRING, TensorShape({}));
  tensor.scalar<tstring>()() = value;
  return tensor;
}

void AddAssetsTensorsToInputs(const StringPiece export_dir,

      }
      op {
        name: "RestoreV2"
        input_arg {
          name: "prefix"
          type: DT_STRING
        }
        input_arg {
          name: "tensor_names"
          type: DT_STRING
        }
        input_arg {
          name: "shape_and_slices"
          type: DT_STRING
        }
        output_arg {
          name: "tensors"
          type_list_attr: "dtypes"
        }

  TF_RETURN_WITH_CONTEXT_IF_ERROR(
      bundle_reader->Lookup(kObjectGraphProtoKey, &object_graph_tensor),
      "SavedModel checkpoint does not contain object graph.");
  if (object_graph_tensor.dtype() != DT_STRING ||
      object_graph_tensor.dims() != 0 ||
      object_graph_tensor.NumElements() != 1) {
    return absl::Status(
        absl::StatusCode::kFailedPrecondition,

  tsl::Set_TF_Status_from_Status(status, cc_status);
}

#endif  // LIBTPU_EXCLUDE_C_API_IMPL

namespace tensorflow {

void TensorInterface::Release() {
  if (Type() == DT_STRING && NumElements() > 0) {
    TF_TString* data = static_cast<TF_TString*>(Data());
    if (CanMove() && data != nullptr) {
      for (int64_t i = 0; i < NumElements(); ++i) {
        TF_TString_Dealloc(&data[i]);
      }