ASSERT_TRUE(status.ok()) << status.message();

  TF_DataType dtype = TypeParam::kDType;
  // This is our 1D tensor of varying dtype.
  std::vector<typename TypeParam::type> value = {42, 100, 0, 1, 4, 29};
  // Shape is Rank 2 vector with shape 2 x 3.
  std::vector<int64_t> shape({2, 3});

  Tensor original_tensor = Tensor::FromBuffer(
      /*dtype=*/dtype, /*shape=*/shape,
      /*data=*/value.data(),

    switch (itype.getWidth()) {
      case 1:
        *dtype = DT_BOOL;
        return absl::OkStatus();
      case 4:
        *dtype = itype.isUnsigned() ? DT_UINT4 : DT_INT4;
        return absl::OkStatus();
      case 8:
        *dtype = itype.isUnsigned() ? DT_UINT8 : DT_INT8;
        return absl::OkStatus();
      case 16:

  tensorflow::PartialTensorShape unknown_shape;
  TensorSpec ts1;
  ts1.shape = unknown_shape;
  ts1.dtype = tensorflow::DT_FLOAT;

  TensorSpec ts2;
  ts2.shape = tensorflow::PartialTensorShape({2});
  ts2.dtype = tensorflow::DT_FLOAT;

  TensorSpec ts3;
  ts3.shape = tensorflow::PartialTensorShape({1, 2});
  ts3.dtype = tensorflow::DT_FLOAT;

  EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly({ts1, ts2, ts3}));
}

  Tensor tensor = Tensor::FromBuffer(
      /*dtype=*/dtype, /*shape=*/shape,
      /*data=*/value.data(),
      /*len=*/value.size() * sizeof(typename TypeParam::type),
      /*deleter=*/[](void*, size_t) {}, &status);
  ASSERT_TRUE(status.ok()) << status.message();

  EXPECT_EQ(tensor.dims(), 1);
  EXPECT_EQ(tensor.dtype(), dtype);
  absl::Span<const typename TypeParam::type> tensor_view(

        auto operand_or_result = value_shaped_type.getElementType();
        std::string dtype;

        TypeSwitch<Type>(operand_or_result)
            .Case<IntegerType>([&](Type) {
              dtype =
                  absl::StrCat("i", operand_or_result.getIntOrFloatBitWidth());
            })
            .Case<FloatType>([&](Type) {
              dtype =
                  absl::StrCat("f", operand_or_result.getIntOrFloatBitWidth());

                                           DataType dtype, TensorShape shape,
                                           const char* raw_device_name,
                                           ImmediateTensorHandlePtr* handle) {
  ImmediateOpPtr varhandle_op(ctx->CreateOperation());

  TF_RETURN_IF_ERROR(varhandle_op->Reset("VarHandleOp", raw_device_name));
  TF_RETURN_IF_ERROR(varhandle_op->SetAttrType("dtype", dtype));

}

TEST(OStreamTest, TestTensorSpec) {
  std::stringstream stream;
  TensorSpec tensor_spec;
  tensor_spec.shape = tensorflow::PartialTensorShape({2});
  tensor_spec.dtype = tensorflow::DT_FLOAT;
  stream << tensor_spec;
  ASSERT_EQ(stream.str(), "TensorSpec(shape = [2], dtype = 1)");
}

}  // namespace impl
}  // namespace libtf

        xla_shape.dimensions(), &tensor_shape));
    arg_shapes.emplace_back(tensor_shape);

    DataType dtype;
    TF_RETURN_IF_ERROR(ConvertToDataType(input_type, &dtype));

    auto metadata_arg = metadata_proto.add_args();
    metadata_arg->set_kind(tpu::TPUCompileMetadataProto::Arg::PARAMETER);
    metadata_arg->set_dtype(dtype);
  }

  return absl::OkStatus();
}

absl::Status SetupReturnValues(mlir::ModuleOp module,

  TF_DeleteExecutionContext(ctx);
  return wrap(func);
}

TF_AbstractTensor* TF_AddFunctionParameter(TF_ExecutionContext* func,
                                           TF_DataType dtype, TF_Shape shape,
                                           TF_Status* s) {
  DCHECK_GE(shape.num_dims, -1);
  TracingTensorHandle* t;
  TracingContext* tracing_ctx = dyn_cast<TracingContext>(unwrap(func));

absl::StatusOr<std::pair<tensorflow::DataType, tensorflow::PartialTensorShape>>
ProcessTensorSpec(mlir::TensorType type) {
  tensorflow::DataType dtype;
  TF_RETURN_IF_ERROR(
      ConvertScalarTypeToDataType(type.getElementType(), &dtype));

  if (!type.hasRank())
    return std::make_pair(dtype, tensorflow::PartialTensorShape());

  auto shape = type.getShape();
  llvm::SmallVector<int64_t, 4> dims;
  dims.assign(shape.begin(), shape.end());