}

TEST(Dump, TextualIrWithOptions) {
  Graph graph(OpRegistry::Global());
  Node* node;
  TF_ASSERT_OK(NodeBuilder("A", "Placeholder")
                   .Attr("dtype", DT_FLOAT)
                   .Finalize(&graph, &node));

  string actual;
  StringWritableFile file(&actual);
  TF_ASSERT_OK(DumpTextualIRToFile(MlirDumpConfig().emit_location_information(),

    .Attr("shared_name: string = ''")
    .Attr("debug_name: string = ''")
    .Attr("dtype: type")
    .Attr("shape: shape")
    .Output("resource: resource")
    .SetIsStateful()
    .SetShapeFn([](shape_inference::InferenceContext* c) {
      c->set_output(0, c->Scalar());
      DataType t;
      TF_RETURN_IF_ERROR(c->GetAttr("dtype", &t));
      PartialTensorShape p;
      TF_RETURN_IF_ERROR(c->GetAttr("shape", &p));

          dtype == tensorflow::DT_UINT16 || dtype == tensorflow::DT_INT16 ||
          dtype == tensorflow::DT_UINT8 || dtype == tensorflow::DT_INT8 ||
          dtype == tensorflow::DT_HALF || dtype == tensorflow::DT_BFLOAT16 ||
          dtype == tensorflow::DT_FLOAT || dtype == tensorflow::DT_DOUBLE ||
          dtype == tensorflow::DT_COMPLEX64 ||
          dtype == tensorflow::DT_COMPLEX128 || dtype == tensorflow::DT_BOOL) {
        return {};

    for (auto type : inst.getResultTypes())
      if (!mlir::isa<mlir::TensorType, mlir::tf_executor::ControlType,
                     mlir::tf_executor::TokenType>(type))
        return errors::InvalidArgument(
            "Values must be of tensor type, TensorFlow control type, or "
            "TensorFlow token type. Found ",
            mlir::debugString(type));

    for (auto type : inst.getResultTypes())
      if (!mlir::isa<mlir::TensorType, mlir::tf_executor::ControlType,
                     mlir::tf_executor::TokenType>(type))
        return errors::InvalidArgument(
            "Values must be of tensor type, TensorFlow control type, or "
            "TensorFlow token type. Found ",
            mlir::debugString(type));

      // Return values
      {"y: float"},
      // Attr def
      {},
      // Nodes
      {
          {{"two"},
           "Const",
           {},
           {{"value", test::AsScalar<int32>(2)}, {"dtype", DT_INT64}}},
          {{"scale"},
           "Cast",
           {"two"},
           {{"SrcT", DT_INT64}, {"DstT", DT_FLOAT}}},
          {{"y"}, "Mul", {"x", "scale"}, {{"T", DT_FLOAT}}},
      });

    shape_string = "<error computing shape>";
  } else {
    shape_string = shape.DebugString();
  }
  return absl::StrCat("TensorHandle(shape=", shape_string,
                      ", dtype=", DataType_Name(DataType()),
                      ", type=", FullType().DebugString(), ")");
}

Status AbstractTensorHandle::TensorHandleStatus() const {
  // Tensor handles in current runtime don't carry error info and this method

                               tensorflow::CustomDevice* device,
                               tensorflow::DataType dtype, void* data,
                               TFE_CustomDeviceTensorHandleMethods methods)
      : tensorflow::CustomDeviceTensorHandle(context, device, dtype),
        data_(data),
        methods_(methods) {}

  ~CAPICustomDeviceTensorHandle() override { methods_.deallocator(data_); }

      const Tensor* value = variable.var()->tensor();
      arg.type = value->dtype();
      arg.shape = value->shape();
      arg.initialized = true;
    } else {
      // Instead of embedding constant into HLO,
      // we handle tf.constant as parameter to reduce size.
      arg.kind = XlaCompiler::Argument::kParameter;
      arg.type = input->dtype();
      arg.shape = input->shape();
    }
    args.push_back(arg);

                                                void* data, size_t len,
                                                TF_Status* status) {
  auto dtype = static_cast<tensorflow::DataType>(data_type);
  DCHECK(tensorflow::DataTypeCanUseMemcpy(dtype));

  tensorflow::Tensor tensor(dtype, tensorflow::TensorShape({}));
  std::memcpy(tensorflow::TensorCApi::Buffer(tensor)->data(), data, len);

  status->status = absl::OkStatus();