uint64 size;
  status = env_->GetFileSize(filepath, &size);
  EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
  if (!status.ok()) GTEST_SKIP() << "GetFileSize() not supported: " << status;
  EXPECT_EQ(size, test_data.size());

  status = env_->GetFileSize(new_filepath, &size);
  EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);

                                     const char* path,
                                     TF_ReadOnlyMemoryRegion* region,
                                     TF_Status* status);
int64_t GetFileSize(const TF_Filesystem* filesystem, const char* path,
                    TF_Status* status);
void PathExists(const TF_Filesystem* filesystem, const char* path,
                TF_Status* status);

  ops_->is_directory(filesystem_.get(), translated_name.c_str(),
                     plugin_status.get());
  return StatusFromTF_Status(plugin_status.get());
}

Status ModularFileSystem::GetFileSize(const std::string& fname,
                                      TransactionToken* token,
                                      uint64* file_size) {
  if (ops_->get_file_size == nullptr) {
    FileStatistics stat;

  Status Stat(const std::string& fname, TransactionToken* token,
              FileStatistics* stat) override;
  Status IsDirectory(const std::string& fname,
                     TransactionToken* token) override;
  Status GetFileSize(const std::string& fname, TransactionToken* token,
                     uint64* file_size) override;
  Status RenameFile(const std::string& src, const std::string& target,
                    TransactionToken* token) override;

        }

        @Override
        public String getContentType() {
            return fileItem.getContentType();
        }

        @Override
        public int getFileSize() {
            return (int) fileItem.getSize();
        }

        @Override
        public String getFileName() {
            return getBaseFileName(fileItem.getName());
        }

            final MinioClient minioClient = createClient(fessConfig);
            final PutObjectArgs args = PutObjectArgs.builder().bucket(fessConfig.getStorageBucket()).object(objectName)
                    .stream(in, uploadFile.getFileSize(), -1).contentType("application/octet-stream").build();
            minioClient.putObject(args);
        } catch (final Exception e) {
            throw new StorageException("Failed to upload " + objectName, e);
        }

                                           reader.get(), status_);
    if (TF_GetCode(status_) != TF_OK) return "";

    auto file_size =
        tf_gcs_filesystem::GetFileSize(filesystem_, path.c_str(), status_);
    if (TF_GetCode(status_) != TF_OK) return "";

    std::string content;
    content.resize(file_size);
    auto read = tf_random_access_file::Read(reader.get(), 0, file_size,

                              .time_since_epoch()
                              .count();
    }
    TF_SetStatusFromGCSStatus(metadata.status(), status);
  }
}

int64_t GetFileSize(const TF_Filesystem* filesystem, const char* path,
                    TF_Status* status) {
  // Only validate the name.
  std::string bucket, object;
  ParseGCSPath(path, false, &bucket, &object, status);