// Wraps a TF_Tensor. Takes ownership of handle.
  explicit Tensor(TF_Tensor* tensor) : tensor_(tensor) {}

  // Tensor is not copyable
  Tensor(const Tensor&) = delete;
  Tensor& operator=(const Tensor&) = delete;

  // Returns the underlying TF_Tensor that this object wraps.
  // This object retains ownership of the pointer.
  TF_Tensor* GetTFTensor() const { return tensor_.get(); }

  struct DeleterStruct {

# CHECK:  tf.TensorListReserve{{.*}}(tensor<2xi32>, tensor<i32>) -> tensor<!tf_type.variant<tensor<*xf32>>>

# Nested variant type.
# CHECK:  tf.TensorListReserve{{.*}}(tensor<2xi32>, tensor<i32>) -> tensor<!tf_type.variant<tensor<*x!tf_type.variant>>>

# CHECK:  tf.TensorListSetItem{{.*}}(tensor<!tf_type.variant<tensor<*xf32>>>, tensor<i32>, tensor<2x2xf32>) -> tensor<*x!tf_type.variant>

  func.return %0#0 : tensor<8x8x8x8xf32>
}

// -----

// CHECK-LABEL: fusedBatchNormV3_noTraining_mixedPrecision

  %0 = "tf.TensorListFromTensor"(%arg0, %arg1) : (tensor<*xf32>, tensor<1xi32>) -> tensor<!tf_type.variant<tensor<*xf32>>>
  %1 = "tf.TensorListGetItem"(%0, %arg2, %arg1) : (tensor<!tf_type.variant<tensor<*xf32>>>, tensor<i32>, tensor<1xi32>) -> tensor<*xf32>
  %2 = "tf.TensorListStack"(%0, %arg1) : (tensor<!tf_type.variant<tensor<*xf32>>>, tensor<1xi32>) -> tensor<*xf32>
  func.return %1, %2 : tensor<*xf32>, tensor<*xf32>

    %tl_set_item = "tf.TensorListSetItem"(%tl, %idx, %elem_1) : (tensor<!tf_type.variant<tensor<*xf32>>>, tensor<i32>, tensor<8xf32>) -> tensor<!tf_type.variant<tensor<*xf32>>>
    %elem_shape_2 = "tf.Const"() {value = dense<-1> : tensor<1xi32>} : () -> tensor<1xi32>

# This test is intended to verify the tensor_content field on import of an empty
# tensor.
# CHECK:  tf.Const
# CHECK-SAME: value = dense<0.000000e+00>

node {
  name: "Const"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
          dim {
            size: 1

  TF_ASSERT_OK_AND_ASSIGN(Tensor tensor1,
                          runtime.CreateHostTensor<float>({}, TF_FLOAT, {2.0f}))
  TF_ASSERT_OK_AND_ASSIGN(Tensor tensor2,
                          runtime.CreateHostTensor<float>({}, TF_FLOAT, {3.0f}))

  TF_ASSERT_OK_AND_ASSIGN(Tensor result_tensor,
                          fn.Call<Tensor>(tensor1, tensor2));
  float out_val[1];

using ::tflite::IsValidBufferOffset;

// Create the MLIR NamedLoc location corresponding to a given tensor
Location TensorLoc(const TensorT& tensor, Builder builder, Location base) {
  if (tensor.name.empty()) {
    return base;
  }
  return mlir::NameLoc::get(builder.getStringAttr(tensor.name), base);
}

// Create the MLIR Location corresponding to a given op. This is an

    std::vector<int> tensors;  // The tensors that are used (input or output) by
                               // this operation. They needn't correspond to
                               // tensors in the TF graph -- we may add fake
                               // tensors to model memory consumed in addition
                               // to input and output tensors. This vector is

    TensorProto AsTensorProto() {
      TensorProto tensor_proto;
      if (tensor.NumElements() > 1) {
        tensor.AsProtoTensorContent(&tensor_proto);
      } else {
        tensor.AsProtoField(&tensor_proto);
      }
      return tensor_proto;
    }

    Status status;
    Tensor tensor;
  };

  /// All of Input's constructors are implicit. Input can be implicitly