tcatest.c

Tokyo Cabinet的Tokyo Cabinet 是一个DBM的实现。这里的数据库由一系列key-value对的记录构成。key和value都可以是任意长度的字节序列,既可以是二进制也可以是字符

    char *rbuf = tcadbget(adb, kbuf, ksiz, &rsiz);
    if(!rbuf){
      eprint(adb, "tcadbget");
      err = true;
      break;
    }
    if(rsiz != vsiz || memcmp(rbuf, vbuf, rsiz)){
      eprint(adb, "(validation)");
      err = true;
      tcfree(rbuf);
      break;
    }
    if(rnum > 250 && i % (rnum / 250) == 0){
      iputchar('.');
      if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
    }
    tcfree(rbuf);
  }
  iprintf("word writing:\n");
  const char *words[] = {
    "a", "A", "bb", "BB", "ccc", "CCC", "dddd", "DDDD", "eeeee", "EEEEEE",
    "mikio", "hirabayashi", "tokyo", "cabinet", "hyper", "estraier", "19780211", "birth day",
    "one", "first", "two", "second", "three", "third", "four", "fourth", "five", "fifth",
    "_[1]_", "uno", "_[2]_", "dos", "_[3]_", "tres", "_[4]_", "cuatro", "_[5]_", "cinco",
    "[\xe5\xb9\xb3\xe6\x9e\x97\xe5\xb9\xb9\xe9\x9b\x84]", "[\xe9\xa6\xac\xe9\xb9\xbf]", NULL
  };
  for(int i = 0; words[i] != NULL; i += 2){
    const char *kbuf = words[i];
    int ksiz = strlen(kbuf);
    const char *vbuf = words[i+1];
    int vsiz = strlen(vbuf);
    if(!tcadbputkeep(adb, kbuf, ksiz, vbuf, vsiz)){
      eprint(adb, "tcadbputkeep");
      err = true;
      break;
    }
    if(rnum > 250) iputchar('.');
  }
  if(rnum > 250) iprintf(" (%08d)\n", sizeof(words) / sizeof(*words));
  iprintf("random erasing:\n");
  for(int i = 1; i <= rnum; i++){
    char kbuf[RECBUFSIZ];
    int ksiz = sprintf(kbuf, "%d", myrand(rnum));
    tcadbout(adb, kbuf, ksiz);
    if(rnum > 250 && i % (rnum / 250) == 0){
      iputchar('.');
      if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
    }
  }
  iprintf("writing:\n");
  for(int i = 1; i <= rnum; i++){
    char kbuf[RECBUFSIZ];
    int ksiz = sprintf(kbuf, "[%d]", i);
    char vbuf[RECBUFSIZ];
    int vsiz = i % RECBUFSIZ;
    memset(vbuf, '*', vsiz);
    if(!tcadbputkeep(adb, kbuf, ksiz, vbuf, vsiz)){
      eprint(adb, "tcadbputkeep");
      err = true;
      break;
    }
    if(vsiz < 1){
      char tbuf[PATH_MAX];
      for(int j = 0; j < PATH_MAX; j++){
        tbuf[j] = myrand(0x100);
      }
      if(!tcadbput(adb, kbuf, ksiz, tbuf, PATH_MAX)){
        eprint(adb, "tcadbput");
        err = true;
        break;
      }
    }
    if(rnum > 250 && i % (rnum / 250) == 0){
      iputchar('.');
      if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
    }
  }
  iprintf("erasing:\n");
  for(int i = 1; i <= rnum; i++){
    if(i % 2 == 1){
      char kbuf[RECBUFSIZ];
      int ksiz = sprintf(kbuf, "[%d]", i);
      if(!tcadbout(adb, kbuf, ksiz)){
        eprint(adb, "tcadbout");
        err = true;
        break;
      }
      tcadbout(adb, kbuf, ksiz);
    }
    if(rnum > 250 && i % (rnum / 250) == 0){
      iputchar('.');
      if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
    }
  }
  iprintf("checking iterator:\n");
  if(!tcadbiterinit(adb)){
    eprint(adb, "tcadbiterinit");
    err = true;
  }
  char *kbuf;
  int ksiz;
  int inum = 0;
  for(int i = 1; (kbuf = tcadbiternext(adb, &ksiz)) != NULL; i++, inum++){
    int vsiz;
    char *vbuf = tcadbget(adb, kbuf, ksiz, &vsiz);
    if(!vbuf){
      eprint(adb, "tcadbget");
      err = true;
      tcfree(kbuf);
      break;
    }
    tcfree(vbuf);
    tcfree(kbuf);
    if(rnum > 250 && i % (rnum / 250) == 0){
      iputchar('.');
      if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
    }
  }
  if(rnum > 250) iprintf(" (%08d)\n", inum);
  if(inum != tcadbrnum(adb)){
    eprint(adb, "(validation)");
    err = true;
  }
  iprintf("checking versatile functions:\n");
  TCLIST *args = tclistnew();
  for(int i = 1; i <= rnum; i++){
    if(myrand(10) == 0){
      const char *name;
      switch(myrand(3)){
      default: name = "putlist"; break;
      case 1: name = "outlist"; break;
      case 2: name = "getlist"; break;
      }
      TCLIST *rv = tcadbmisc(adb, name, args);
      if(rv){
        tclistdel(rv);
      } else {
        eprint(adb, "tcadbmisc");
        err = true;
        break;
      }
    } else {
      char kbuf[RECBUFSIZ];
      int ksiz = sprintf(kbuf, "(%d)", i);
      tclistpush(args, kbuf, ksiz);
    }
    if(rnum > 250 && i % (rnum / 250) == 0){
      iputchar('.');
      if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
    }
  }
  tclistdel(args);
  if(myrand(10) == 0 && !tcadbsync(adb)){
    eprint(adb, "tcadbsync");
    err = true;
  }
  if(myrand(10) == 0 && !tcadboptimize(adb, NULL)){
    eprint(adb, "tcadboptimize");
    err = true;
  }
  if(!tcadbvanish(adb)){
    eprint(adb, "tcadbvanish");
    err = true;
  }
  int omode = tcadbomode(adb);
  if(omode == ADBOHDB || omode == ADBOBDB || omode == ADBOFDB){
    TCMAP *map = tcmapnew();
    iprintf("random writing:\n");
    for(int i = 1; i <= rnum; i++){
      char kbuf[RECBUFSIZ];
      int ksiz = sprintf(kbuf, "%d", myrand(rnum));
      char vbuf[RECBUFSIZ];
      int vsiz = sprintf(vbuf, "%d", myrand(rnum));
      switch(myrand(4)){
      case 0:
        if(!tcadbput(adb, kbuf, ksiz, vbuf, vsiz)){
          eprint(adb, "tcadbput");
          err = true;
        }
        tcmapput(map, kbuf, ksiz, vbuf, vsiz);
        break;
      case 1:
        tcadbputkeep(adb, kbuf, ksiz, vbuf, vsiz);
        tcmapputkeep(map, kbuf, ksiz, vbuf, vsiz);
        break;
      case 2:
        tcadbputcat(adb, kbuf, ksiz, vbuf, vsiz);
        tcmapputcat(map, kbuf, ksiz, vbuf, vsiz);
        break;
      case 3:
        tcadbout(adb, kbuf, ksiz);
        tcmapout(map, kbuf, ksiz);
        break;
      }
      if(rnum > 250 && i % (rnum / 250) == 0){
        iputchar('.');
        if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
      }
    }
    iprintf("checking transaction commit:\n");
    if(!tcadbtranbegin(adb)){
      eprint(adb, "tcadbtranbegin");
      err = true;
    }
    for(int i = 1; i <= rnum; i++){
      char kbuf[RECBUFSIZ];
      int ksiz = sprintf(kbuf, "%d", myrand(rnum));
      char vbuf[RECBUFSIZ];
      int vsiz = sprintf(vbuf, "[%d]", myrand(rnum));
      switch(myrand(6)){
      case 0:
        if(!tcadbput(adb, kbuf, ksiz, vbuf, vsiz)){
          eprint(adb, "tcadbput");
          err = true;
        }
        tcmapput(map, kbuf, ksiz, vbuf, vsiz);
        break;
      case 1:
        tcadbputkeep(adb, kbuf, ksiz, vbuf, vsiz);
        tcmapputkeep(map, kbuf, ksiz, vbuf, vsiz);
        break;
      case 2:
        tcadbputcat(adb, kbuf, ksiz, vbuf, vsiz);
        tcmapputcat(map, kbuf, ksiz, vbuf, vsiz);
        break;
      case 3:
        tcadbaddint(adb, kbuf, ksiz, 1);
        tcmapaddint(map, kbuf, ksiz, 1);
        break;
      case 4:
        tcadbadddouble(adb, kbuf, ksiz, 1.0);
        tcmapadddouble(map, kbuf, ksiz, 1.0);
        break;
      case 5:
        tcadbout(adb, kbuf, ksiz);
        tcmapout(map, kbuf, ksiz);
        break;
      }
      if(rnum > 250 && i % (rnum / 250) == 0){
        iputchar('.');
        if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
      }
    }
    if(!tcadbtrancommit(adb)){
      eprint(adb, "tcadbtrancommit");
      err = true;
    }
    iprintf("checking transaction abort:\n");
    uint64_t ornum = tcadbrnum(adb);
    uint64_t osize = tcadbsize(adb);
    if(!tcadbtranbegin(adb)){
      eprint(adb, "tcadbtranbegin");
      err = true;
    }
    for(int i = 1; i <= rnum; i++){
      char kbuf[RECBUFSIZ];
      int ksiz = sprintf(kbuf, "%d", myrand(rnum));
      char vbuf[RECBUFSIZ];
      int vsiz = sprintf(vbuf, "((%d))", myrand(rnum));
      switch(myrand(6)){
      case 0:
        if(!tcadbput(adb, kbuf, ksiz, vbuf, vsiz)){
          eprint(adb, "tcadbput");
          err = true;
        }
        break;
      case 1:
        tcadbputkeep(adb, kbuf, ksiz, vbuf, vsiz);
        break;
      case 2:
        tcadbputcat(adb, kbuf, ksiz, vbuf, vsiz);
        break;
      case 3:
        tcadbaddint(adb, kbuf, ksiz, 1);
        break;
      case 4:
        tcadbadddouble(adb, kbuf, ksiz, 1.0);
        break;
      case 5:
        tcadbout(adb, kbuf, ksiz);
        break;
      }
      if(rnum > 250 && i % (rnum / 250) == 0){
        iputchar('.');
        if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
      }
    }
    if(!tcadbtranabort(adb)){
      eprint(adb, "tcadbtranabort");
      err = true;
    }
    iprintf("checking consistency:\n");
    if(tcadbrnum(adb) != ornum || tcadbsize(adb) != osize || tcadbrnum(adb) != tcmaprnum(map)){
      eprint(adb, "(validation)");
      err = true;
    }
    inum = 0;
    tcmapiterinit(map);
    const char *tkbuf;
    int tksiz;
    for(int i = 1; (tkbuf = tcmapiternext(map, &tksiz)) != NULL; i++, inum++){
      int tvsiz;
      const char *tvbuf = tcmapiterval(tkbuf, &tvsiz);
      int rsiz;
      char *rbuf = tcadbget(adb, tkbuf, tksiz, &rsiz);
      if(!rbuf || rsiz != tvsiz || memcmp(rbuf, tvbuf, rsiz)){
        eprint(adb, "(validation)");
        err = true;
        tcfree(rbuf);
        break;
      }
      tcfree(rbuf);
      if(rnum > 250 && i % (rnum / 250) == 0){
        iputchar('.');
        if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
      }
    }
    if(rnum > 250) iprintf(" (%08d)\n", inum);
    inum = 0;
    if(!tcadbiterinit(adb)){
      eprint(adb, "tcadbiterinit");
      err = true;
    }
    for(int i = 1; (kbuf = tcadbiternext(adb, &ksiz)) != NULL; i++, inum++){
      int vsiz;
      char *vbuf = tcadbget(adb, kbuf, ksiz, &vsiz);
      int rsiz;
      const char *rbuf = tcmapget(map, kbuf, ksiz, &rsiz);
      if(!rbuf || rsiz != vsiz || memcmp(rbuf, vbuf, rsiz)){
        eprint(adb, "(validation)");
        err = true;
        tcfree(vbuf);
        tcfree(kbuf);
        break;
      }
      tcfree(vbuf);
      tcfree(kbuf);
      if(rnum > 250 && i % (rnum / 250) == 0){
        iputchar('.');
        if(i == rnum || i % (rnum / 10) == 0) iprintf(" (%08d)\n", i);
      }
    }
    if(rnum > 250) iprintf(" (%08d)\n", inum);
    tcmapdel(map);
    if(!tcadbvanish(adb)){
      eprint(adb, "tcadbvanish");
      err = true;
    }
  }
  if(!tcadbput2(adb, "mikio", "hirabayashi")){
    eprint(adb, "tcadbput2");
    err = true;
  }
  for(int i = 0; i < 10; i++){
    char buf[RECBUFSIZ];
    int size = sprintf(buf, "%d", myrand(rnum));
    if(!tcadbput(adb, buf, size, buf, size)){
      eprint(adb, "tcadbput");
      err = true;
    }
  }
  for(int i = myrand(3) + 1; i < PATH_MAX; i = i * 2 + myrand(3)){
    char vbuf[i];
    memset(vbuf, '@', i - 1);
    vbuf[i-1] = '\0';
    if(!tcadbput2(adb, "mikio", vbuf)){
      eprint(adb, "tcadbput2");
      err = true;
    }
  }
  if(!tcadbforeach(adb, iterfunc, NULL)){
    eprint(adb, "tcadbforeach");
    err = true;
  }
  iprintf("record number: %llu\n", (unsigned long long)tcadbrnum(adb));
  iprintf("size: %llu\n", (unsigned long long)tcadbsize(adb));
  sysprint();
  if(!tcadbclose(adb)){
    eprint(adb, "tcadbclose");
    err = true;
  }
  tcadbdel(adb);
  iprintf("time: %.3f\n", tctime() - stime);
  iprintf("%s\n\n", err ? "error" : "ok");
  return err ? 1 : 0;
}


/* perform wicked command */
static int procwicked(const char *name, int rnum){
  iprintf("<Wicked Writing Test>\n  seed=%u  name=%s  rnum=%d\n\n", g_randseed, name, rnum);
  bool err = false;
  double stime = tctime();
  TCADB *adb = tcadbnew();
  if(!tcadbopen(adb, name)){
    eprint(adb, "tcadbopen");
    err = true;
  }
  TCMAP *map = tcmapnew2(rnum / 5);
  for(int i = 1; i <= rnum && !err; i++){
    char kbuf[RECBUFSIZ];
    int ksiz = sprintf(kbuf, "%d", myrand(rnum) + 1);
    char vbuf[RECBUFSIZ];
    int vsiz = myrand(RECBUFSIZ);
    memset(vbuf, '*', vsiz);
    vbuf[vsiz] = '\0';
    char *rbuf;
    switch(myrand(16)){
    case 0:
      iputchar('0');
      if(!tcadbput(adb, kbuf, ksiz, vbuf, vsiz)){
        eprint(adb, "tcadbput");
        err = true;
      }
      tcmapput(map, kbuf, ksiz, vbuf, vsiz);
      break;
    case 1:
      iputchar('1');
      if(!tcadbput2(adb, kbuf, vbuf)){
        eprint(adb, "tcadbput2");
        err = true;
      }
      tcmapput2(map, kbuf, vbuf);
      break;
    case 2:
      iputchar('2');
      tcadbputkeep(adb, kbuf, ksiz, vbuf, vsiz);
      tcmapputkeep(map, kbuf, ksiz, vbuf, vsiz);
      break;
    case 3:
      iputchar('3');
      tcadbputkeep2(adb, kbuf, vbuf);
      tcmapputkeep2(map, kbuf, vbuf);
      break;
    case 4:
      iputchar('4');
      if(!tcadbputcat(adb, kbuf, ksiz, vbuf, vsiz)){
        eprint(adb, "tcadbputcat");
        err = true;
      }
      tcmapputcat(map, kbuf, ksiz, vbuf, vsiz);
      break;
    case 5:
      iputchar('5');
      if(!tcadbputcat2(adb, kbuf, vbuf)){
        eprint(adb, "tcadbputcat2");
        err = true;
      }
      tcmapputcat2(map, kbuf, vbuf);
      break;
    case 6:
      iputchar('6');
      if(myrand(10) == 0){
        tcadbout(adb, kbuf, ksiz);
        tcmapout(map, kbuf, ksiz);
      }
      break;
    case 7:
      iputchar('7');
      if(myrand(10) == 0){
        tcadbout2(adb, kbuf);
        tcmapout2(map, kbuf);
      }
      break;
    case 8:
      iputchar('8');
      if((rbuf = tcadbget(adb, kbuf, ksiz, &vsiz)) != NULL) tcfree(rbuf);
      break;
    case 9:
      iputchar('9');
      if((rbuf = tcadbget2(adb, kbuf)) != NULL) tcfree(rbuf);
      break;
    case 10:
      iputchar('A');
      tcadbvsiz(adb, kbuf, ksiz);
      break;
    case 11:
      iputchar('B');
      tcadbvsiz2(adb, kbuf);
      break;
    case 12:
      iputchar('E');
      if(myrand(rnum / 50) == 0){
        if(!tcadbiterinit(adb)){
          eprint(adb, "tcadbiterinit");
          err = true;
        }
      }
      for(int j = myrand(rnum) / 1000 + 1; j >= 0; j--){
        int iksiz;
        char *ikbuf = tcadbiternext(adb, &iksiz);
        if(ikbuf) tcfree(ikbuf);
      }
      break;
    default:
      iputchar('@');
      if(myrand(10000) == 0) srand((unsigned int)(tctime() * 1000) % UINT_MAX);
      break;
    }
    if(i % 50 == 0) iprintf(" (%08d)\n", i);
  }
  if(rnum % 50 > 0) iprintf(" (%08d)\n", rnum);
  tcadbsync(adb);
  if(tcadbrnum(adb) != tcmaprnum(map)){
    eprint(adb, "(validation)");
    err = true;
  }
  for(int i = 1; i <= rnum && !err; i++){
    char kbuf[RECBUFSIZ];
    int ksiz = sprintf(kbuf, "%d", i - 1);
    int vsiz;
    const char *vbuf = tcmapget(map, kbuf, ksiz, &vsiz);
    int rsiz;
    char *rbuf = tcadbget(adb, kbuf, ksiz, &rsiz);
    if(vbuf){
      iputchar('.');
      if(!rbuf){
        eprint(adb, "tcadbget");
        err = true;
      } else if(rsiz != vsiz || memcmp(rbuf, vbuf, rsiz)){
        eprint(adb, "(validation)");
        err = true;
      }
    } else {
      iputchar('*');
      if(rbuf){
        eprint(adb, "(validation)");
        err = true;
      }
    }
    tcfree(rbuf);
    if(i % 50 == 0) iprintf(" (%08d)\n", i);
  }
  if(rnum % 50 > 0) iprintf(" (%08d)\n", rnum);
  tcmapiterinit(map);
  int ksiz;
  const char *kbuf;
  for(int i = 1; (kbuf = tcmapiternext(map, &ksiz)) != NULL; i++){
    iputchar('+');
    int vsiz;
    const char *vbuf = tcmapiterval(kbuf, &vsiz);
    int rsiz;
    char *rbuf = tcadbget(adb, kbuf, ksiz, &rsiz);
    if(!rbuf){
      eprint(adb, "tcadbget");
      err = true;