ASSERT_EQ(TF_GetCode(status_), TF_OUT_OF_RANGE) << TF_Message(status_);
  result.resize(read);
  ASSERT_EQ(result, "6789") << "Result: " << result << "\n";
}

TEST_F(GCSFilesystemTest, NewRandomAccessFile_Buffered) {
  tf_gcs_filesystem::InitTest(filesystem_, false, 10, 0, 0, 0, 0, status_);
  ASSERT_TF_OK(status_) << "Could not initialize filesystem. "
                        << TF_Message(status_);

}

TEST(RamFileBlockCacheTest, ValidateAndUpdateFileSignature) {
  int calls = 0;
  auto fetcher = [&calls](const string& filename, size_t offset, size_t n,
                          char* buffer, TF_Status* status) -> int64_t {
    calls++;
    memset(buffer, 'x', n);
    TF_SetStatus(status, TF_OK, "");
    return n;
  };
  string filename = "file";
  tf_gcs_filesystem::RamFileBlockCache cache(16, 32, 0, fetcher);
  std::vector<char> out;

// Transfers up to `size` bytes from `dst_fd` to `src_fd`.
//
// This method uses a temporary buffer to hold contents.
int CopyFileContents(int dst_fd, int src_fd, off_t size) {
  // Use a copy buffer of 128KB but don't store it on the stack.
  constexpr static size_t kPosixCopyFileBufferSize = 128 * 1024;
  std::unique_ptr<char[]> buffer(new char[kPosixCopyFileBufferSize]);

  off_t offset = 0;
  int bytes_transferred = 0;
  int rc = 1;

                                              graph_def->length));
  TF_Buffer graph_def_buffer;
  graph_def_buffer.data = reinterpret_cast<const void*>(&graph_def_proto);
  graph_def_buffer.length = sizeof(tensorflow::GraphDef*);
  TF_ImportGraphDefResults* results =
      TF_GraphImportGraphDefWithResultsNoSerialization(graph, &graph_def_buffer,
                                                       opts, s);

#define TF_CLEANUP_AND_RETURN_IF_ERROR(C_STATUS, BUFFER, __VA_ARGS__) \
  do {                                                                \
    ::tensorflow::Status _s(__VA_ARGS__);                             \
    if (TF_PREDICT_TRUE(!_s.ok())) {                                  \
      TF_DeleteStatus(C_STATUS);                                      \
      TF_DeleteBuffer(BUFFER);                                        \

                                size_t n, char* buffer, TF_Status* status) {
  if (n == 0) {
    TF_SetStatus(status, TF_OK, "");
    return 0;
  }
  if (!IsCacheEnabled() || (n > max_bytes_)) {
    // The cache is effectively disabled, so we pass the read through to the
    // fetcher without breaking it up into blocks.
    return block_fetcher_(filename, offset, n, buffer, status);
  }

  const int BUFFER_SIZE = 10;
  char buffer[BUFFER_SIZE];
  std::strncpy(buffer, "VALID", BUFFER_SIZE);
  TFE_OpSetAttrString(op, "padding", buffer, std::strlen(buffer));
  // Overwriting value in "buffer", should be fine since TFE_Op
  // shouldn't be holding on to it.
  std::strncpy(buffer, "NHWC", BUFFER_SIZE);
  TFE_OpSetAttrString(op, "data_format", buffer, std::strlen(buffer));

  option_value.type_tag = TF_Filesystem_Option_Type_Buffer;
  option_value.num_values = values.size();
  std::vector<TF_Filesystem_Option_Value_Union> option_values(values.size());
  for (size_t i = 0; i < values.size(); i++) {
    memset(&option_values[i], 0, sizeof(option_values[i]));
    option_values[i].buffer_val.buf = const_cast<char*>(values[i].c_str());
    option_values[i].buffer_val.buf_length = values[i].size();
  }

  CHECK_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
  auto* cell2 = TFE_MonitoringGetCellStringGauge2(gauge2, "foo", "bar");
  TFE_MonitoringStringGaugeCellSet(cell2, "str");
  auto* buf = new TF_Buffer;
  TFE_MonitoringStringGaugeCellValue(cell2, buf);
  string data(static_cast<const char*>(buf->data), buf->length);
  TF_DeleteBuffer(buf);
  EXPECT_EQ(data, "str");
  TFE_MonitoringDeleteStringGauge2(gauge2);

struct TF_SessionOptions {
  tensorflow::SessionOptions options;
};

struct TF_DeprecatedSession {
  tensorflow::Session* session;
};

struct TF_Library {
  void* lib_handle;
  TF_Buffer op_list;
};

struct TF_Graph {
  TF_Graph();

  mutable tensorflow::mutex mu;
  tensorflow::Graph graph TF_GUARDED_BY(mu);

  // Runs shape inference.
  tensorflow::ShapeRefiner refiner TF_GUARDED_BY(mu);