namespace tflite {

std::vector<uint8_t> PackInt4ValuesDensely(std::vector<uint8_t> src_buffer) {
  auto num_elements = src_buffer.size();
  auto packed_size = (num_elements + 1) / 2;
  std::vector<uint8_t> packed_buffer((num_elements + 1) / 2);

  for (int i = 0; i < num_elements - 1; i += 2) {
    packed_buffer[i / 2] = src_buffer[i] & 0x0F;
    packed_buffer[i / 2] |= src_buffer[i + 1] << 4;
  }

// filled first, followed by the upper nibble.
std::vector<uint8_t> PackInt4ValuesDensely(std::vector<uint8_t> src_buffer);

// Assumes `src_buffer` contains 2 4-bit elements packed in 8-bit.
// Returns a vector where each int8 element contains a int4 sign-extended value.
std::vector<char> UnpackDenseInt4IntoInt8(
    const std::vector<uint8_t>& src_buffer, int64_t num_elements);
}  // namespace tflite

  TF_ASSERT_OK_AND_ASSIGN(auto c_buffer, GetPjRtCBufferFromTensor(&tensor));

  EXPECT_THAT(c_buffer, NotNull());
}

TEST(TensorPjRtBufferUtilTest, SetPjRtCBufferToTensorNotAsyncValueTensor) {
  tensorflow::Tensor tensor(DT_FLOAT, {1});
  TF_ASSERT_OK_AND_ASSIGN(auto pjrt_client, xla::GetCApiClient(DEVICE_CPU));
  PJRT_Buffer* c_buffer = CreateCBuffer();

  TF_EXPECT_OK(SetPjRtCBufferToTensor(

    return nullptr;
  }
  absl::StatusOr<PJRT_Buffer*> c_buffer =
      tensorflow::GetPjRtCBufferFromTensor(&tensor);
  if (!c_buffer.ok()) {
    status->status = c_buffer.status();
    return nullptr;
  }
  status->status = absl::OkStatus();
  return *c_buffer;
}

void TF_CreatePjRtBuffer(TF_Tensor* c_tensor, PJRT_Buffer* c_buffer,
                         const char* device_type, TF_Status* status) {

  }
  return c_api_buffer->c_buffer();
}

absl::Status SetPjRtCBufferToTensor(PJRT_Buffer* c_buffer,
                                    xla::PjRtCApiClient* c_api_client,
                                    Tensor* tensor) {
  auto buffer = std::make_unique<xla::PjRtCApiBuffer>(c_api_client, c_buffer);
  tensorflow::AsyncValueTensor* av_tensor =

    return;
  }
  // TODO(b/288585098): consider whether to support same device copy in PJRT
  // API.
  absl::StatusOr<PJRT_Buffer*> c_src_buffer =
      GetPjRtCBufferFromTensor(input_tensor);
  if (!c_src_buffer.ok()) {
    done(c_src_buffer.status());
    return;
  }
  absl::StatusOr<xla::PjRtCApiClient*> c_api_client =
      tensorflow::GetPjRtCApiClient(

#include "tensorflow/core/framework/tensor.h"

namespace tensorflow {

absl::StatusOr<PJRT_Buffer*> GetPjRtCBufferFromTensor(const Tensor* tensor);

absl::Status SetPjRtCBufferToTensor(PJRT_Buffer* c_buffer,
                                    xla::PjRtCApiClient* c_api_client,
                                    Tensor* tensor);

absl::StatusOr<xla::PjRtCApiClient*> GetPjRtCApiClient(
    const DeviceType& device_type);

// Creates a `PjRtCApiBuffer` with the `PJRT_Buffer*` passed in and set to the
// tensor.
TF_CAPI_EXPORT extern void TF_CreatePjRtBuffer(TF_Tensor* c_tensor,
                                               PJRT_Buffer* c_buffer,
                                               const char* device_type,
                                               TF_Status* status);

#ifdef __cplusplus
}  // extern "C"
#endif

      // they have ownership of the buffer (see comment in
      // PopulateExecutionInputBuffer). Release ownership from output to avoid
      // double free.
      output.set_buffer(se::OwningDeviceMemory(), {output_num});
      return input_tensor;
    }
  }

  if (allocate_xla_tensors) {
    Tensor output_tensor;
    TF_RETURN_IF_ERROR(