/*************************************************************************************************
* The test cases of the C language binding
* Copyright (C) 2009-2012 FAL Labs
* This file is part of Kyoto Cabinet.
* This program is free software: you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation, either version
* 3 of the License, or any later version.
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
* You should have received a copy of the GNU General Public License along with this program.
* If not, see <http://www.gnu.org/licenses/>.
*************************************************************************************************/
#include <kclangc.h>
#define RECBUFSIZ 64 /* buffer size for a record */
#define RECBUFSIZL 1024 /* buffer size for a long record */
#if !defined(TRUE)
#define TRUE 1 /* boolean true */
#endif
#if !defined(FALSE)
#define FALSE 0 /* boolean false */
#endif
typedef struct { /* arguments of visitor */
int64_t rnum;
int32_t rnd;
int64_t cnt;
char rbuf[RECBUFSIZ];
} VISARG;
/* global variables */
const char* g_progname; /* program name */
/* function prototypes */
int main(int argc, char** argv);
static void usage(void);
static int64_t myrand(int64_t range);
static void oprintf(const char* format, ...);
static void oputchar(char c);
static void eprintf(const char* format, ...);
static void dberrprint(KCDB* db, int32_t line, const char* func);
static void idxerrprint(KCIDX* idx, int32_t line, const char* func);
static void dbmetaprint(KCDB* db, int32_t verbose);
static void idxmetaprint(KCIDX* idx, int32_t verbose);
const char* visitfull(const char* kbuf, size_t ksiz,
const char* vbuf, size_t vsiz, size_t* sp, void* opq);
static int32_t runorder(int argc, char** argv);
static int32_t runindex(int argc, char** argv);
static int32_t runmap(int argc, char** argv);
static int32_t runlist(int argc, char** argv);
static int32_t procorder(const char* path, int64_t rnum, int32_t rnd, int32_t etc,
int32_t tran, int32_t oflags);
static int32_t procindex(const char* path, int64_t rnum, int32_t rnd, int32_t etc,
int32_t oflags);
static int32_t procmap(int64_t rnum, int32_t rnd, int32_t etc, int64_t bnum);
static int32_t proclist(int64_t rnum, int32_t rnd, int32_t etc);
/* main routine */
int main(int argc, char **argv) {
int32_t i, rv;
g_progname = argv[0];
srand(time(NULL));
if (argc < 2) usage();
rv = 0;
if (!strcmp(argv[1], "order")) {
rv = runorder(argc, argv);
} else if (!strcmp(argv[1], "index")) {
rv = runindex(argc, argv);
} else if (!strcmp(argv[1], "map")) {
rv = runmap(argc, argv);
} else if (!strcmp(argv[1], "list")) {
rv = runlist(argc, argv);
} else {
usage();
}
if (rv != 0) {
oprintf("FAILED:");
for (i = 0; i < argc; i++) {
oprintf(" %s", argv[i]);
}
oprintf("\n\n");
}
return rv;
}
/* print the usage and exit */
static void usage() {
eprintf("%s: test cases of the C binding of Kyoto Cabinet\n", g_progname);
eprintf("\n");
eprintf("usage:\n");
eprintf(" %s order [-rnd] [-etc] [-tran] [-oat|-oas|-onl|-otl|-onr] path rnum\n",
g_progname);
eprintf(" %s index [-rnd] [-etc] [-oat|-oas|-onl|-otl|-onr] path rnum\n", g_progname);
eprintf(" %s map [-rnd] [-etc] [-bnum num] rnum\n", g_progname);
eprintf(" %s list [-rnd] [-etc] rnum\n", g_progname);
eprintf("\n");
exit(1);
}
/* get a random number */
static int64_t myrand(int64_t range) {
uint64_t base, mask;
if (range < 2) return 0;
base = range * (rand() / (RAND_MAX + 1.0));
mask = (uint64_t)rand() << 30;
mask += (uint64_t)rand() >> 2;
return (base ^ mask) % range;
}
/* print formatted error string and flush the buffer */
static void oprintf(const char* format, ...) {
va_list ap;
va_start(ap, format);
vprintf(format, ap);
va_end(ap);
fflush(stdout);
}
/* print a character and flush the buffer */
static void oputchar(char c) {
putchar(c);
fflush(stdout);
}
/* print formatted error string and flush the buffer */
static void eprintf(const char* format, ...) {
va_list ap;
va_start(ap, format);
vfprintf(stderr, format, ap);
va_end(ap);
fflush(stderr);
}
/* print error message of database */
static void dberrprint(KCDB* db, int32_t line, const char* func) {
char* path;
const char* emsg;
int32_t ecode;
path = kcdbpath(db);
ecode = kcdbecode(db);
emsg = kcdbemsg(db);
oprintf("%s: %d: %s: %s: %d: %s: %s\n",
g_progname, line, func, path ? path : "-", ecode, kcecodename(ecode), emsg);
kcfree(path);
}
/* print error message of database */
static void idxerrprint(KCIDX* idx, int32_t line, const char* func) {
dberrprint(kcidxrevealinnerdb(idx), line, func);
}
/* print members of database */
static void dbmetaprint(KCDB* db, int32_t verbose) {
char* status, *rp;
if (verbose) {
status = kcdbstatus(db);
if (status) {
rp = status;
while (*rp != '\0') {
if (*rp == '\t') {
printf(": ");
} else {
putchar(*rp);
}
rp++;
}
kcfree(status);
}
} else {
oprintf("count: %ld\n", (long)kcdbcount(db));
oprintf("size: %ld\n", (long)kcdbsize(db));
}
}
/* print members of database */
static void idxmetaprint(KCIDX* idx, int32_t verbose) {
dbmetaprint(kcidxrevealinnerdb(idx), verbose);
}
/* visit a full record */
const char* visitfull(const char* kbuf, size_t ksiz,
const char* vbuf, size_t vsiz, size_t* sp, void* opq) {
VISARG* arg;
const char* rv;
arg = opq;
arg->cnt++;
rv = KCVISNOP;
switch (arg->rnd ? myrand(7) : arg->cnt % 7) {
case 0: {
rv = arg->rbuf;
*sp = arg->rnd ? (size_t)myrand(sizeof(arg->rbuf)) :
sizeof(arg->rbuf) / (arg->cnt % 5 + 1);
break;
}
case 1: {
rv = KCVISREMOVE;
break;
}
}
if (arg->rnum > 250 && arg->cnt % (arg->rnum / 250) == 0) {
oputchar('.');
if (arg->cnt == arg->rnum || arg->cnt % (arg->rnum / 10) == 0)
oprintf(" (%08ld)\n", (long)arg->cnt);
}
return rv;
}
/* parse arguments of order command */
static int32_t runorder(int argc, char** argv) {
int32_t argbrk = FALSE;
const char* path, *rstr;
int32_t rnd, etc, tran, mode, oflags, i;
int64_t rnum;
path = NULL;
rstr = NULL;
rnd = FALSE;
etc = FALSE;
mode = 0;
tran = FALSE;
oflags = 0;
for (i = 2; i < argc; i++) {
if (!argbrk && argv[i][0] == '-') {
if (!strcmp(argv[i], "--")) {
argbrk = TRUE;
} else if (!strcmp(argv[i], "-rnd")) {
rnd = TRUE;
} else if (!strcmp(argv[i], "-etc")) {
etc = TRUE;
} else if (!strcmp(argv[i], "-tran")) {
tran = TRUE;
} else if (!strcmp(argv[i], "-oat")) {
oflags |= KCOAUTOTRAN;
} else if (!strcmp(argv[i], "-oas")) {
oflags |= KCOAUTOSYNC;
} else if (!strcmp(argv[i], "-onl")) {
oflags |= KCONOLOCK;
} else if (!strcmp(argv[i], "-otl")) {
oflags |= KCOTRYLOCK;
} else if (!strcmp(argv[i], "-onr")) {
oflags |= KCONOREPAIR;
} else {
usage();
}
} else if (!path) {
argbrk = TRUE;
path = argv[i];
} else if (!rstr) {
rstr = argv[i];
} else {
usage();
}
}
if (!path || !rstr) usage();
rnum = kcatoix(rstr);
if (rnum < 1) usage();
return procorder(path, rnum, rnd, etc, tran, oflags);
}
/* parse arguments of index command */
static int32_t runindex(int argc, char** argv) {
int32_t argbrk = FALSE;
const char* path, *rstr;
int32_t rnd, etc, mode, oflags, i;
int64_t rnum;
path = NULL;
rstr = NULL;
rnd = FALSE;
etc = FALSE;
mode = 0;
oflags = 0;
for (i = 2; i < argc; i++) {
if (!argbrk && argv[i][0] == '-') {
if (!strcmp(argv[i], "--")) {
argbrk = TRUE;
} else if (!strcmp(argv[i], "-rnd")) {
rnd = TRUE;
} else if (!strcmp(argv[i], "-etc")) {
etc = TRUE;
} else if (!strcmp(argv[i], "-oat")) {
oflags |= KCOAUTOTRAN;
} else if (!strcmp(argv[i], "-oas")) {
oflags |= KCOAUTOSYNC;
} else if (!strcmp(argv[i], "-onl")) {
oflags |= KCONOLOCK;
} else if (!strcmp(argv[i], "-otl")) {
oflags |= KCOTRYLOCK;
} else if (!strcmp(argv[i], "-onr")) {
oflags |= KCONOREPAIR;
} else {
usage();
}
} else if (!path) {
argbrk = TRUE;
path = argv[i];
} else if (!rstr) {
rstr = argv[i];
} else {
usage();
}
}
if (!path || !rstr) usage();
rnum = kcatoix(rstr);
if (rnum < 1) usage();
return procindex(path, rnum, rnd, etc, oflags);
}
/* parse arguments of map command */
static int32_t runmap(int argc, char** argv) {
int32_t argbrk = FALSE;
const char* rstr;
int32_t rnd, etc, i;
int64_t rnum, bnum;
rstr = NULL;
rnd = FALSE;
etc = FALSE;
bnum = -1;
for (i = 2; i < argc; i++) {
if (!argbrk && argv[i][0] == '-') {
if (!strcmp(argv[i], "--")) {
argbrk = TRUE;
} else if (!strcmp(argv[i], "-rnd")) {
rnd = TRUE;
} else if (!strcmp(argv[i], "-etc")) {
etc = TRUE;
} else if (!strcmp(argv[i], "-bnum")) {
if (++i >= argc) usage();
bnum = kcatoix(argv[i]);
} else {
usage();
}
} else if (!rstr) {
argbrk = TRUE;
rstr = argv[i];
} else {
usage();
}
}
if (!rstr) usage();
rnum = kcatoix(rstr);
if (rnum < 1) usage();
return procmap(rnum, rnd, etc, bnum);
}
/* parse arguments of list command */
static int32_t runlist(int argc, char** argv) {
int32_t argbrk = FALSE;
const char* rstr;
int32_t rnd, etc, i;
int64_t rnum;
rstr = NULL;
rnd = FALSE;
etc = FALSE;
for (i = 2; i < argc; i++) {
if (!argbrk && argv[i][0] == '-') {
if (!strcmp(argv[i], "--")) {
argbrk = TRUE;
} else if (!strcmp(argv[i], "-rnd")) {
rnd = TRUE;
} else if (!strcmp(argv[i], "-etc")) {
etc = TRUE;
} else {
usage();
}
} else if (!rstr) {
argbrk = TRUE;
rstr = argv[i];
} else {
usage();
}
}
if (!rstr) usage();
rnum = kcatoix(rstr);
if (rnum < 1) usage();
return proclist(rnum, rnd, etc);
}
/* perform order command */
static int32_t procorder(const char* path, int64_t rnum, int32_t rnd, int32_t etc,
int32_t tran, int32_t oflags) {
KCDB* db;
KCCUR* cur, *paracur;
int32_t err;
char kbuf[RECBUFSIZ], *vbuf, wbuf[RECBUFSIZ], *corepath, *copypath, *snappath;
size_t ksiz, vsiz, psiz;
int32_t wsiz;
int64_t i, cnt;
double stime, etime;
VISARG visarg;
oprintf("<In-order Test>\n path=%s rnum=%ld rnd=%d etc=%d tran=%d oflags=%d\n\n",
path, (long)rnum, rnd, etc, tran, oflags);
err = FALSE;
db = kcdbnew();
oprintf("opening the database:\n");
stime = kctime();
if (!kcdbopen(db, path, KCOWRITER | KCOCREATE | KCOTRUNCATE | oflags)) {
dberrprint(db, __LINE__, "kcdbopen");
err = TRUE;
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
oprintf("setting records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
if (tran && !kcdbbegintran(db, FALSE)) {
dberrprint(db, __LINE__, "kcdbbegintran");
err = TRUE;
}
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
if (!kcdbset(db, kbuf, ksiz, kbuf, ksiz)) {
dberrprint(db, __LINE__, "kcdbset");
err = TRUE;
}
if (tran && !kcdbendtran(db, TRUE)) {
dberrprint(db, __LINE__, "kcdbendtran");
err = TRUE;
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
if (etc) {
oprintf("adding records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
if (tran && !kcdbbegintran(db, FALSE)) {
dberrprint(db, __LINE__, "kcdbbegintran");
err = TRUE;
}
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
if (!kcdbadd(db, kbuf, ksiz, kbuf, ksiz) && kcdbecode(db) != KCEDUPREC) {
dberrprint(db, __LINE__, "kcdbadd");
err = TRUE;
}
if (tran && !kcdbendtran(db, TRUE)) {
dberrprint(db, __LINE__, "kcdbendtran");
err = TRUE;
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
}
if (etc) {
oprintf("appending records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
if (tran && !kcdbbegintran(db, FALSE)) {
dberrprint(db, __LINE__, "kcdbbegintran");
err = TRUE;
}
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
if (!kcdbappend(db, kbuf, ksiz, kbuf, ksiz)) {
dberrprint(db, __LINE__, "kcdbadd");
err = TRUE;
}
if (tran && !kcdbendtran(db, TRUE)) {
dberrprint(db, __LINE__, "kcdbendtran");
err = TRUE;
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
}
oprintf("getting records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
if (tran && !kcdbbegintran(db, FALSE)) {
dberrprint(db, __LINE__, "kcdbbegintran");
err = TRUE;
}
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
vbuf = kcdbget(db, kbuf, ksiz, &vsiz);
if (vbuf) {
if (vsiz < ksiz || memcmp(vbuf, kbuf, ksiz)) {
dberrprint(db, __LINE__, "kcdbget");
err = TRUE;
}
kcfree(vbuf);
} else if (!rnd || kcdbecode(db) != KCENOREC) {
dberrprint(db, __LINE__, "kcdbget");
err = TRUE;
}
if (tran && !kcdbendtran(db, TRUE)) {
dberrprint(db, __LINE__, "kcdbendtran");
err = TRUE;
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
if (etc) {
oprintf("getting records with a buffer:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
if (tran && !kcdbbegintran(db, FALSE)) {
dberrprint(db, __LINE__, "kcdbbegintran");
err = TRUE;
}
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
wsiz = kcdbgetbuf(db, kbuf, ksiz, wbuf, sizeof(wbuf));
if (wsiz >= 0) {
if (wsiz < (int32_t)ksiz || memcmp(wbuf, kbuf, ksiz)) {
dberrprint(db, __LINE__, "kcdbgetbuf");
err = TRUE;
}
} else if (!rnd || kcdbecode(db) != KCENOREC) {
dberrprint(db, __LINE__, "kcdbgetbuf");
err = TRUE;
}
if (tran && !kcdbendtran(db, TRUE)) {
dberrprint(db, __LINE__, "kcdbendtran");
err = TRUE;
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
}
if (etc) {
oprintf("traversing the database by the inner iterator:\n");
stime = kctime();
cnt = kcdbcount(db);
visarg.rnum = rnum;
visarg.rnd = rnd;
visarg.cnt = 0;
memset(visarg.rbuf, '+', sizeof(visarg.rbuf));
if (tran && !kcdbbegintran(db, FALSE)) {
dberrprint(db, __LINE__, "kcdbbegintran");
err = TRUE;
}
if (!kcdbiterate(db, visitfull, &visarg, TRUE)) {
dberrprint(db, __LINE__, "kcdbiterate");
err = TRUE;
}
if (rnd) oprintf(" (end)\n");
if (tran && !kcdbendtran(db, TRUE)) {
dberrprint(db, __LINE__, "kcdbendtran");
err = TRUE;
}
if (visarg.cnt != cnt) {
dberrprint(db, __LINE__, "kcdbiterate");
err = TRUE;
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
}
if (etc) {
oprintf("traversing the database by the outer cursor:\n");
stime = kctime();
cnt = kcdbcount(db);
visarg.rnum = rnum;
visarg.rnd = rnd;
visarg.cnt = 0;
if (tran && !kcdbbegintran(db, FALSE)) {
dberrprint(db, __LINE__, "kcdbbegintran");
err = TRUE;
}
cur = kcdbcursor(db);
if (!kccurjump(cur) && kccurecode(cur) != KCENOREC) {
dberrprint(db, __LINE__, "kccurjump");
err = TRUE;
}
paracur = kcdbcursor(db);
while (!err && kccuraccept(cur, &visitfull, &visarg, TRUE, !rnd)) {
if (rnd) {
ksiz = sprintf(kbuf, "%08ld", (long)myrand(rnum));
switch (myrand(3)) {
case 0: {
if (!kcdbremove(db, kbuf, ksiz) && kcdbecode(db) != KCENOREC) {
dberrprint(db, __LINE__, "kcdbremove");
err = TRUE;
}
break;
}
case 1: {
if (!kccurjumpkey(paracur, kbuf, ksiz) && kccurecode(paracur) != KCENOREC) {
dberrprint(db, __LINE__, "kccurjump");
err = TRUE;
}
break;
}
default: {
if (!kccurstep(cur) && kccurecode(cur) != KCENOREC) {
dberrprint(db, __LINE__, "kccurstep");
err = TRUE;
}
break;
}
}
}
}
oprintf(" (end)\n");
kccurdel(paracur);
kccurdel(cur);
if (tran && !kcdbendtran(db, TRUE)) {
dberrprint(db, __LINE__, "kcdbendtran");
err = TRUE;
}
if (!rnd && visarg.cnt != cnt) {
dberrprint(db, __LINE__, "kccuraccept");
err = TRUE;
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
}
if (etc) {
oprintf("synchronizing the database:\n");
stime = kctime();
if (!kcdbsync(db, FALSE, NULL, NULL)) {
dberrprint(db, __LINE__, "kcdbsync");
err = TRUE;
}
if (!kcdboccupy(db, FALSE, NULL, NULL)) {
dberrprint(db, __LINE__, "kcdboccupy");
err = TRUE;
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
}
if (etc) {
corepath = kcdbpath(db);
psiz = strlen(corepath);
if (strstr(corepath, ".kch") || strstr(corepath, ".kct")) {
copypath = kcmalloc(psiz + 256);
sprintf(copypath, "%s.tmp", corepath);
snappath = kcmalloc(psiz + 256);
sprintf(snappath, "%s.kcss", corepath);
} else {
copypath = kcmalloc(256);
sprintf(copypath, "kclangctest.tmp");
snappath = kcmalloc(256);
sprintf(snappath, "kclangctest.kcss");
}
oprintf("copying the database file:\n");
stime = kctime();
if (!kcdbcopy(db, copypath)) {
dberrprint(db, __LINE__, "kcdbcopy");
err = TRUE;
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
remove(copypath);
oprintf("dumping records into snapshot:\n");
stime = kctime();
if (!kcdbdumpsnap(db, snappath)) {
dberrprint(db, __LINE__, "kcdbdumpsnap");
err = TRUE;
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
oprintf("loading records into snapshot:\n");
stime = kctime();
cnt = kcdbcount(db);
if (rnd && myrand(2) == 0 && !kcdbclear(db)) {
dberrprint(db, __LINE__, "kcdbclear");
err = TRUE;
}
if (!kcdbloadsnap(db, snappath) || kcdbcount(db) != cnt) {
dberrprint(db, __LINE__, "kcdbloadsnap");
err = TRUE;
}
etime = kctime();
dbmetaprint(db, FALSE);
oprintf("time: %.3f\n", etime - stime);
remove(snappath);
kcfree(copypath);
kcfree(snappath);
kcfree(corepath);
}
oprintf("removing records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
if (tran && !kcdbbegintran(db, FALSE)) {
dberrprint(db, __LINE__, "kcdbbegintran");
err = TRUE;
}
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
if (!kcdbremove(db, kbuf, ksiz) &&
((!rnd && !etc) || kcdbecode(db) != KCENOREC)) {
dberrprint(db, __LINE__, "kcdbremove");
err = TRUE;
}
if (tran && !kcdbendtran(db, TRUE)) {
dberrprint(db, __LINE__, "kcdbendtran");
err = TRUE;
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
dbmetaprint(db, TRUE);
oprintf("time: %.3f\n", etime - stime);
oprintf("closing the database:\n");
stime = kctime();
if (!kcdbclose(db)) {
dberrprint(db, __LINE__, "kcdbclose");
err = TRUE;
}
etime = kctime();
oprintf("time: %.3f\n", etime - stime);
kcdbdel(db);
oprintf("%s\n\n", err ? "error" : "ok");
return err ? 1 : 0;
}
/* perform index command */
static int32_t procindex(const char* path, int64_t rnum, int32_t rnd, int32_t etc,
int32_t oflags) {
KCIDX* idx;
int32_t err;
char kbuf[RECBUFSIZ], *vbuf;
size_t ksiz, vsiz;
int64_t i;
double stime, etime;
oprintf("<Index Database Test>\n path=%s rnum=%ld rnd=%d etc=%d oflags=%d\n\n",
path, (long)rnum, rnd, etc, oflags);
err = FALSE;
idx = kcidxnew();
oprintf("opening the database:\n");
stime = kctime();
if (!kcidxopen(idx, path, KCOWRITER | KCOCREATE | KCOTRUNCATE | oflags)) {
idxerrprint(idx, __LINE__, "kcidxopen");
err = TRUE;
}
etime = kctime();
idxmetaprint(idx, FALSE);
oprintf("time: %.3f\n", etime - stime);
oprintf("setting records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
if (!kcidxset(idx, kbuf, ksiz, kbuf, ksiz)) {
idxerrprint(idx, __LINE__, "kcidxset");
err = TRUE;
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
idxmetaprint(idx, FALSE);
oprintf("time: %.3f\n", etime - stime);
if (etc) {
oprintf("adding records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
if (!kcidxadd(idx, kbuf, ksiz, kbuf, ksiz) && kcidxecode(idx) != KCEDUPREC) {
idxerrprint(idx, __LINE__, "kcidxadd");
err = TRUE;
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
idxmetaprint(idx, FALSE);
oprintf("time: %.3f\n", etime - stime);
}
if (etc) {
oprintf("appending records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
if (!kcidxappend(idx, kbuf, ksiz, kbuf, ksiz)) {
idxerrprint(idx, __LINE__, "kcidxadd");
err = TRUE;
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
idxmetaprint(idx, FALSE);
oprintf("time: %.3f\n", etime - stime);
}
oprintf("getting records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
vbuf = kcidxget(idx, kbuf, ksiz, &vsiz);
if (vbuf) {
if (vsiz < ksiz || memcmp(vbuf, kbuf, ksiz)) {
idxerrprint(idx, __LINE__, "kcidxget");
err = TRUE;
}
kcfree(vbuf);
} else if (!rnd || kcidxecode(idx) != KCENOREC) {
idxerrprint(idx, __LINE__, "kcidxget");
err = TRUE;
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
idxmetaprint(idx, FALSE);
oprintf("time: %.3f\n", etime - stime);
if (etc) {
oprintf("synchronizing the database:\n");
stime = kctime();
if (!kcidxsync(idx, FALSE, NULL, NULL)) {
idxerrprint(idx, __LINE__, "kcidxsync");
err = TRUE;
}
etime = kctime();
idxmetaprint(idx, FALSE);
oprintf("time: %.3f\n", etime - stime);
}
oprintf("removing records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
if (!kcidxremove(idx, kbuf, ksiz) &&
((!rnd && !etc) || kcidxecode(idx) != KCENOREC)) {
idxerrprint(idx, __LINE__, "kcidxremove");
err = TRUE;
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
idxmetaprint(idx, TRUE);
oprintf("time: %.3f\n", etime - stime);
oprintf("closing the database:\n");
stime = kctime();
if (!kcidxclose(idx)) {
idxerrprint(idx, __LINE__, "kcidxclose");
err = TRUE;
}
etime = kctime();
oprintf("time: %.3f\n", etime - stime);
kcidxdel(idx);
oprintf("%s\n\n", err ? "error" : "ok");
return err ? 1 : 0;
}
/* perform map command */
static int32_t procmap(int64_t rnum, int32_t rnd, int32_t etc, int64_t bnum) {
KCMAP* map;
KCMAPITER* iter;
KCMAPSORT* sort;
int32_t err;
char kbuf[RECBUFSIZ];
const char* vbuf, *ikbuf;
size_t ksiz, vsiz;
int64_t i, cnt;
double stime, etime;
oprintf("<Memory-saving Hash Map Test>\n rnum=%ld rnd=%d etc=%d bnum=%ld\n\n",
(long)rnum, rnd, etc, (long)bnum);
err = FALSE;
if (bnum < 0) bnum = 0;
map = kcmapnew(bnum);
oprintf("setting records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
kcmapset(map, kbuf, ksiz, kbuf, ksiz);
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
oprintf("count: %ld\n", (long)kcmapcount(map));
oprintf("time: %.3f\n", etime - stime);
if (etc) {
oprintf("adding records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
kcmapadd(map, kbuf, ksiz, kbuf, ksiz);
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
oprintf("count: %ld\n", (long)kcmapcount(map));
oprintf("time: %.3f\n", etime - stime);
}
if (etc) {
oprintf("appending records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
kcmapappend(map, kbuf, ksiz, kbuf, ksiz);
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
oprintf("count: %ld\n", (long)kcmapcount(map));
oprintf("time: %.3f\n", etime - stime);
}
oprintf("getting records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
vbuf = kcmapget(map, kbuf, ksiz, &vsiz);
if (vbuf) {
if (vsiz < ksiz || memcmp(vbuf, kbuf, ksiz)) {
eprintf("%s: kcmapget failed\n", g_progname);
err = TRUE;
}
} else if (!rnd) {
eprintf("%s: kcmapget failed\n", g_progname);
err = TRUE;
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
oprintf("count: %ld\n", (long)kcmapcount(map));
oprintf("time: %.3f\n", etime - stime);
if (etc) {
oprintf("traversing records:\n");
stime = kctime();
cnt = 0;
iter = kcmapiterator(map);
while (!err && (ikbuf = kcmapiterget(iter, &ksiz, &vbuf, &vsiz)) != NULL) {
if (rnd) {
ksiz = sprintf(kbuf, "%08ld", (long)myrand(rnum));
switch (myrand(3)) {
case 0: {
kcmapremove(map, kbuf, ksiz);
break;
}
case 1: {
kcmapappend(map, kbuf, ksiz, kbuf, ksiz);
break;
}
}
}
if (!kcmapitergetkey(iter, &ksiz)) {
eprintf("%s: kcmapitergetkey failed\n", g_progname);
err = TRUE;
}
if (!kcmapitergetvalue(iter, &vsiz)) {
eprintf("%s: kcmapitergetvalue failed\n", g_progname);
err = TRUE;
}
cnt++;
if (rnum > 250 && cnt % (rnum / 250) == 0) {
oputchar('.');
if (cnt == rnum || cnt % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)cnt);
}
kcmapiterstep(iter);
}
if (rnd) oprintf(" (end)\n");
kcmapiterdel(iter);
if (!rnd && cnt != (int64_t)kcmapcount(map)) {
eprintf("%s: kcmapcount failed\n", g_progname);
err = TRUE;
}
etime = kctime();
oprintf("count: %ld\n", (long)kcmapcount(map));
oprintf("time: %.3f\n", etime - stime);
}
if (etc) {
oprintf("sorting records:\n");
stime = kctime();
cnt = 0;
sort = kcmapsorter(map);
while (!err && (ikbuf = kcmapsortget(sort, &ksiz, &vbuf, &vsiz)) != NULL) {
if (!kcmapsortgetkey(sort, &ksiz)) {
eprintf("%s: kcmapsortgetkey failed\n", g_progname);
err = TRUE;
}
if (!kcmapsortgetvalue(sort, &vsiz)) {
eprintf("%s: kcmapsortgetvalue failed\n", g_progname);
err = TRUE;
}
cnt++;
if (rnum > 250 && cnt % (rnum / 250) == 0) {
oputchar('.');
if (cnt == rnum || cnt % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)cnt);
}
kcmapsortstep(sort);
}
if (rnd) oprintf(" (end)\n");
kcmapsortdel(sort);
if (!rnd && cnt != (int64_t)kcmapcount(map)) {
eprintf("%s: kcmapcount failed\n", g_progname);
err = TRUE;
}
etime = kctime();
oprintf("count: %ld\n", (long)kcmapcount(map));
oprintf("time: %.3f\n", etime - stime);
}
oprintf("removing records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
ksiz = sprintf(kbuf, "%08ld", (long)(rnd ? myrand(rnum) + 1 : i));
if (!kcmapremove(map, kbuf, ksiz) && !rnd) {
eprintf("%s: kcmapremove failed\n", g_progname);
err = TRUE;
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
oprintf("count: %ld\n", (long)kcmapcount(map));
oprintf("time: %.3f\n", etime - stime);
kcmapdel(map);
oprintf("%s\n\n", err ? "error" : "ok");
return err ? 1 : 0;
}
/* perform list command */
static int32_t proclist(int64_t rnum, int32_t rnd, int32_t etc) {
KCLIST* list;
int32_t err;
char buf[RECBUFSIZ];
size_t size;
int64_t i, cnt;
double stime, etime;
oprintf("<Memory-saving Array List Test>\n rnum=%ld rnd=%d etc=%d\n\n",
(long)rnum, rnd, etc);
err = FALSE;
list = kclistnew();
oprintf("setting records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
size = sprintf(buf, "%08ld", (long)i);
if (rnd && myrand(2) == 0) {
kclistunshift(list, buf, size);
} else {
kclistpush(list, buf, size);
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
oprintf("count: %ld\n", (long)kclistcount(list));
oprintf("time: %.3f\n", etime - stime);
oprintf("getting records:\n");
stime = kctime();
cnt = kclistcount(list);
for (i = 1; !err && i <= rnum; i++) {
kclistget(list, rnd ? myrand(cnt) : i - 1, &size);
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
oprintf("count: %ld\n", (long)kclistcount(list));
oprintf("time: %.3f\n", etime - stime);
oprintf("removing records:\n");
stime = kctime();
for (i = 1; !err && i <= rnum; i++) {
if (rnd && myrand(2) == 0) {
kclistshift(list);
} else {
kclistpop(list);
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
oprintf("count: %ld\n", (long)kclistcount(list));
oprintf("time: %.3f\n", etime - stime);
if (etc) {
oprintf("wicked testing:\n");
stime = kctime();
memset(buf, '*', sizeof(buf));
for (i = 1; !err && i <= rnum; i++) {
size = rnd ? (size_t)myrand(sizeof(buf)) : sizeof(buf);
cnt = kclistcount(list);
switch (rnd ? myrand(10) : i % 10) {
case 0: {
kclistpop(list);
break;
}
case 1: {
kclistunshift(list, buf, size);
break;
}
case 2: {
kclistshift(list);
break;
}
case 3: {
kclistinsert(list, buf, size, rnd && cnt > 0 ? myrand(cnt) : cnt / 2);
break;
}
case 4: {
if (cnt > 0) kclistremove(list, rnd ? myrand(cnt) : cnt / 2);
break;
}
case 5: {
if (cnt > 0) kclistget(list, rnd ? myrand(cnt) : cnt / 2, &size);
break;
}
case 6: {
if (rnd ? myrand(100) == 0 : i % 127 == 0) kclistclear(list);
break;
}
default: {
kclistpush(list, buf, size);
break;
}
}
if (rnum > 250 && i % (rnum / 250) == 0) {
oputchar('.');
if (i == rnum || i % (rnum / 10) == 0) oprintf(" (%08ld)\n", (long)i);
}
}
etime = kctime();
oprintf("time: %.3f\n", etime - stime);
oprintf("count: %ld\n", (long)kclistcount(list));
}
kclistdel(list);
oprintf("%s\n\n", err ? "error" : "ok");
return err ? 1 : 0;
}
/* END OF FILE */