kit

cas_test.c (4894B)

---

 /* cas_test -- public <kit/cas.h> by-id blob read surface.
  *
  * Run by: make test-cas-api
  */
 
 #include <kit/cas.h>
 #include <kit/core.h>
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 
 #include "lib/kit_unit.h"
 
 static KitUnit g_u;
 #define EXPECT(c, ...) CU_EXPECT(&g_u, c, __VA_ARGS__)
 
 typedef struct CasTestWriter {
   KitWriter w;
   FILE* f;
 } CasTestWriter;
 
 static KitStatus cas_test_writer_write(KitWriter* w, const void* data,
                                        size_t n) {
   CasTestWriter* cw = (CasTestWriter*)w;
   return fwrite(data, 1, n, cw->f) == n ? KIT_OK : KIT_IO;
 }
 
 static KitStatus cas_test_writer_seek(KitWriter* w, uint64_t offset) {
   CasTestWriter* cw = (CasTestWriter*)w;
   return fseek(cw->f, (long)offset, SEEK_SET) == 0 ? KIT_OK : KIT_IO;
 }
 
 static uint64_t cas_test_writer_tell(KitWriter* w) {
   CasTestWriter* cw = (CasTestWriter*)w;
   long pos = ftell(cw->f);
   return pos < 0 ? 0 : (uint64_t)pos;
 }
 
 static KitStatus cas_test_writer_status(KitWriter* w) {
   CasTestWriter* cw = (CasTestWriter*)w;
   return ferror(cw->f) ? KIT_IO : KIT_OK;
 }
 
 static void cas_test_writer_close(KitWriter* w) {
   CasTestWriter* cw = (CasTestWriter*)w;
   if (cw->f) fclose(cw->f);
   free(cw);
 }
 
 static KitStatus cas_test_read_all(void* user, const char* path,
                                    KitFileData* out) {
   FILE* f;
   long end;
   uint8_t* data;
   (void)user;
   out->data = NULL;
   out->size = 0;
   out->token = NULL;
   f = fopen(path, "rb");
   if (!f) return KIT_NOT_FOUND;
   if (fseek(f, 0, SEEK_END) != 0) {
     fclose(f);
     return KIT_IO;
   }
   end = ftell(f);
   if (end < 0 || fseek(f, 0, SEEK_SET) != 0) {
     fclose(f);
     return KIT_IO;
   }
   data = (uint8_t*)malloc((size_t)end ? (size_t)end : 1u);
   if (!data) {
     fclose(f);
     return KIT_NOMEM;
   }
   if ((size_t)end &&
       fread(data, 1, (size_t)end, f) != (size_t)end) {
     free(data);
     fclose(f);
     return KIT_IO;
   }
   fclose(f);
   out->data = data;
   out->size = (size_t)end;
   out->token = data;
   return KIT_OK;
 }
 
 static void cas_test_release(void* user, KitFileData* fd) {
   (void)user;
   free(fd->token);
   fd->data = NULL;
   fd->size = 0;
   fd->token = NULL;
 }
 
 static KitStatus cas_test_open_writer(void* user, const char* path,
                                       KitWriter** out) {
   CasTestWriter* cw;
   (void)user;
   *out = NULL;
   cw = (CasTestWriter*)calloc(1, sizeof *cw);
   if (!cw) return KIT_NOMEM;
   cw->f = fopen(path, "wb");
   if (!cw->f) {
     free(cw);
     return KIT_IO;
   }
   cw->w.write = cas_test_writer_write;
   cw->w.seek = cas_test_writer_seek;
   cw->w.tell = cas_test_writer_tell;
   cw->w.status = cas_test_writer_status;
   cw->w.close = cas_test_writer_close;
   *out = &cw->w;
   return KIT_OK;
 }
 
 static int cas_test_mkdir_p(void* user, const char* path) {
   char buf[1024];
   size_t i, n;
   (void)user;
   n = strlen(path);
   if (n == 0 || n >= sizeof buf) return 1;
   memcpy(buf, path, n + 1u);
   for (i = 1; i <= n; ++i) {
     if (buf[i] != '/' && buf[i] != '\0') continue;
     {
       char save = buf[i];
       buf[i] = '\0';
       if (mkdir(buf, 0777) != 0 && errno != EEXIST) return 1;
       buf[i] = save;
     }
   }
   return 0;
 }
 
 int main(void) {
   static const uint8_t data[] = "config=debug\n";
   static const char root[] = "build/test/cas_api_test_store";
   KitFileIO fio;
   KitCasHost host;
   KitCas* cas = NULL;
   KitBlobInfo info;
   KitFileData fd;
   uint8_t missing[KIT_CAS_HASH_LEN];
 
   kit_unit_init(&g_u);
   memset(&fio, 0, sizeof fio);
   fio.read_all = cas_test_read_all;
   fio.release = cas_test_release;
   fio.open_writer = cas_test_open_writer;
   memset(&host, 0, sizeof host);
   host.file_io = &fio;
   host.mkdir_p = cas_test_mkdir_p;
 
   EXPECT(kit_cas_open(&g_u.ctx, &host, root, &cas) == KIT_OK, "open CAS");
   EXPECT(kit_cas_add_blob(cas, data, sizeof data - 1u, &info) == KIT_OK,
          "add blob");
   EXPECT(kit_cas_has_blob(cas, info.id) == KIT_OK, "has added blob");
 
   memset(&fd, 0, sizeof fd);
   EXPECT(kit_cas_get_blob(cas, info.id, &fd) == KIT_OK, "get added blob");
   EXPECT(fd.size == sizeof data - 1u, "blob size matches");
   EXPECT(memcmp(fd.data, data, sizeof data - 1u) == 0, "blob bytes match");
   kit_cas_release(cas, &fd);
   kit_cas_release(cas, &fd);
   EXPECT(fd.data == NULL && fd.size == 0 && fd.token == NULL,
          "release is idempotent");
 
   memset(missing, 0, sizeof missing);
   EXPECT(kit_cas_has_blob(cas, missing) == KIT_NOT_FOUND,
          "has missing blob reports not found");
   memset(&fd, 0xff, sizeof fd);
   EXPECT(kit_cas_get_blob(cas, missing, &fd) == KIT_NOT_FOUND,
          "get missing blob reports not found");
   EXPECT(fd.data == NULL && fd.size == 0 && fd.token == NULL,
          "miss leaves output empty");
 
   kit_cas_close(cas);
   kit_unit_summary(&g_u, "cas_test");
   return kit_unit_status(&g_u);
 }