test for cursor stickyness. addresses #196

git-svn-id: file:///svn/tokudb@1173 c7de825b-a66e-492c-adef-691d508d4ae1

src/tests/test_cursor_stickyness.c

+/* -*- mode: C; c-basic-offset: 4 -*- */
+#ident "Copyright (c) 2007 Tokutek Inc.  All rights reserved."
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <arpa/inet.h>
+#include <db.h>
+
+#include "test.h"
+
+
+
+void db_put(DB *db, int k, int v) {
+    DB_TXN * const null_txn = 0;
+    DBT key, val;
+    int r = db->put(db, null_txn, dbt_init(&key, &k, sizeof k), dbt_init(&val, &v, sizeof v), 0);
+    assert(r == 0);
+}
+
+void db_get(DB *db, int k) {
+    DB_TXN * const null_txn = 0;
+    DBT key, val;
+    int r = db->get(db, null_txn, dbt_init(&key, &k, sizeof k), dbt_init_malloc(&val), 0);
+    assert(r == 0);
+    int vv;
+    assert(val.size == sizeof vv);
+    memcpy(&vv, val.data, val.size);
+    printf("do_search %d\n", htonl(vv));
+    free(val.data);
+}
+
+void db_del(DB *db, int k) {
+    DB_TXN * const null_txn = 0;
+    DBT key;
+    int r = db->del(db, null_txn, dbt_init(&key, &k, sizeof k), 0);
+    assert(r == 0);
+}
+
+void expect_db_get(DB *db, int k, int v) {
+    DB_TXN * const null_txn = 0;
+    DBT key, val;
+    int r = db->get(db, null_txn, dbt_init(&key, &k, sizeof k), dbt_init_malloc(&val), 0);
+    assert(r == 0);
+    int vv;
+    assert(val.size == sizeof vv);
+    memcpy(&vv, val.data, val.size);
+    assert(vv == v);
+    free(val.data);
+}
+
+int cursor_get(DBC *cursor, int *k, int *v, int op) {
+    DBT key, val;
+    int r = cursor->c_get(cursor, dbt_init_malloc(&key), dbt_init_malloc(&val), op);
+    if (r == 0) {
+        assert(key.size == sizeof *k); memcpy(k, key.data, key.size);
+        assert(val.size == sizeof *v); memcpy(v, val.data, val.size);
+    }
+    if (key.data) free(key.data);
+    if (val.data) free(val.data);
+    return r;
+}
+
+void expect_cursor_get(DBC *cursor, int k, int v) {
+    DBT key, val;
+    int r = cursor->c_get(cursor, dbt_init_malloc(&key), dbt_init_malloc(&val), DB_NEXT);
+    assert(r == 0);
+    assert(key.size == sizeof k);
+    int kk;
+    memcpy(&kk, key.data, key.size);
+    assert(val.size == sizeof v);
+    int vv;
+    memcpy(&vv, val.data, val.size);
+    if (kk != k || vv != v) printf("expect key %d got %d - %d %d\n", htonl(k), htonl(kk), htonl(v), htonl(vv));
+    assert(kk == k);
+    assert(vv == v);
+
+    free(key.data);
+    free(val.data);
+}
+
+void expect_cursor_set(DBC *cursor, int k, int expectr) {
+    DBT key, val;
+    int r = cursor->c_get(cursor, dbt_init(&key, &k, sizeof k), dbt_init_malloc(&val), DB_SET);
+    assert(r == expectr);
+    if (val.data) free(val.data);
+}
+
+void expect_cursor_get_both(DBC *cursor, int k, int v) {
+    DBT key, val;
+    int r = cursor->c_get(cursor, dbt_init(&key, &k, sizeof k), dbt_init(&val, &v, sizeof v), DB_GET_BOTH);
+    assert(r == 0);
+}
+
+void expect_cursor_get_current(DBC *cursor, int k, int v) {
+    DBT key, val;
+    int r = cursor->c_get(cursor, dbt_init_malloc(&key), dbt_init_malloc(&val), DB_CURRENT);
+    assert(r == 0);
+    int kk, vv;
+    assert(key.size == sizeof kk); memcpy(&kk, key.data, key.size); assert(kk == k);
+    assert(val.size == sizeof vv); memcpy(&vv, val.data, val.size); assert(vv == v);
+    free(key.data); free(val.data);
+}
+
+
+void test_cursor_sticky(int n, int dup_mode) {
+    if (verbose) printf("test_cursor_sticky:%d %d\n", n, dup_mode);
+
+    DB_ENV * const null_env = 0;
+    DB *db;
+    DB_TXN * const null_txn = 0;
+    const char * const fname = DIR "/" "test_cursor_sticky.brt";
+    int r;
+
+    unlink(fname);
+
+    /* create the dup database file */
+    r = db_create(&db, null_env, 0); assert(r == 0);
+    r = db->set_flags(db, dup_mode); assert(r == 0);
+    r = db->set_pagesize(db, 4096); assert(r == 0);
+    r = db->open(db, null_txn, fname, "main", DB_BTREE, DB_CREATE, 0666); assert(r == 0);
+
+    int i;
+    int k, v;
+    for (i=0; i<n; i++) {
+        db_put(db, htonl(i), htonl(i));
+    } 
+
+    /* walk the tree */
+    DBC *cursor;
+    r = db->cursor(db, 0, &cursor, 0); assert(r == 0);
+    for (i=0; i<n; i++) {
+        r = cursor_get(cursor, &k, &v, DB_NEXT); assert(r == 0);
+        assert(k == htonl(i)); assert(v == htonl(i));
+    }
+
+    r = cursor_get(cursor, &k, &v, DB_NEXT); assert(r == DB_NOTFOUND);
+
+    r = cursor_get(cursor, &k, &v, DB_CURRENT); assert(r == 0); assert(k == htonl(n-1)); assert(v == htonl(n-1));
+
+    r = cursor->c_close(cursor); assert(r == 0);
+
+    r = db->close(db, 0); assert(r == 0);
+}
+
+
+int main(int argc, const char *argv[]) {
+    int i;
+
+    parse_args(argc, argv);
+  
+    system("rm -rf " DIR);
+    mkdir(DIR, 0777);
+
+    for (i=1; i<65537; i *= 2) {
+        test_cursor_sticky(i, 0);
+    }
+    return 0;
+}

src/tests/test_dupsort_get_both_range.c

@@ -141,10 +141,10 @@ void test_icdi_search(int n, int dup_mode) {
         r = db->cursor(db, null_txn, &cursor, 0); assert(r == 0);
         expect_cursor_get_both_range(cursor, k, v, 0);
         expect_cursor_get_current(cursor, k, v);
-
+#if USE_TDB
         expect_cursor_get_both_range(cursor, 0, 0, 0);
         expect_cursor_get_current(cursor, k, v);
-
+#endif
         r = cursor->c_close(cursor); assert(r == 0);
     } 
 
@@ -152,7 +152,10 @@ void test_icdi_search(int n, int dup_mode) {
     r = db->cursor(db, null_txn, &cursor, 0); assert(r == 0);
     expect_cursor_get_both_range(cursor, 0, 0, 0);
     expect_cursor_get_both_range(cursor, htonl(n), 0, DB_NOTFOUND);
-
+#if USE_BDB
+    r = cursor->c_close(cursor); assert(r == 0);
+    r = db->cursor(db, null_txn, &cursor, 0); assert(r == 0);
+#endif
     for (i=0; i<n; i++) {
         expect_cursor_get(cursor, htonl(n/2), htonl(n+i));
     }

src/tests/test_dupsort_set_range.c

@@ -12,12 +12,17 @@
 
 #include "test.h"
 
-
+#ifndef DB_DELETE_ANY
+#define DB_DELETE_ANY 0
+#endif
+#ifndef DB_YESOVERWRITE
+#define DB_YESOVERWRITE 0
+#endif
 
 void db_put(DB *db, int k, int v) {
     DB_TXN * const null_txn = 0;
     DBT key, val;
-    int r = db->put(db, null_txn, dbt_init(&key, &k, sizeof k), dbt_init(&val, &v, sizeof v), 0);
+    int r = db->put(db, null_txn, dbt_init(&key, &k, sizeof k), dbt_init(&val, &v, sizeof v), DB_YESOVERWRITE);
     assert(r == 0);
 }
 
@@ -36,7 +41,7 @@ void db_get(DB *db, int k) {
 void db_del(DB *db, int k) {
     DB_TXN * const null_txn = 0;
     DBT key;
-    int r = db->del(db, null_txn, dbt_init(&key, &k, sizeof k), 0);
+    int r = db->del(db, null_txn, dbt_init(&key, &k, sizeof k), DB_DELETE_ANY);
     assert(r == 0);
 }
 

src/tests/test_nodup_set.c

+/* -*- mode: C; c-basic-offset: 4 -*- */
+#ident "Copyright (c) 2007 Tokutek Inc.  All rights reserved."
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <arpa/inet.h>
+#include <db.h>
+
+#include "test.h"
+
+
+
+void db_put(DB *db, int k, int v) {
+    DB_TXN * const null_txn = 0;
+    DBT key, val;
+    int r = db->put(db, null_txn, dbt_init(&key, &k, sizeof k), dbt_init(&val, &v, sizeof v), 0);
+    assert(r == 0);
+}
+
+void db_get(DB *db, int k) {
+    DB_TXN * const null_txn = 0;
+    DBT key, val;
+    int r = db->get(db, null_txn, dbt_init(&key, &k, sizeof k), dbt_init_malloc(&val), 0);
+    assert(r == 0);
+    int vv;
+    assert(val.size == sizeof vv);
+    memcpy(&vv, val.data, val.size);
+    printf("do_search %d\n", htonl(vv));
+    free(val.data);
+}
+
+void db_del(DB *db, int k) {
+    DB_TXN * const null_txn = 0;
+    DBT key;
+    int r = db->del(db, null_txn, dbt_init(&key, &k, sizeof k), 0);
+    assert(r == 0);
+}
+
+void expect_db_get(DB *db, int k, int v) {
+    DB_TXN * const null_txn = 0;
+    DBT key, val;
+    int r = db->get(db, null_txn, dbt_init(&key, &k, sizeof k), dbt_init_malloc(&val), 0);
+    assert(r == 0);
+    int vv;
+    assert(val.size == sizeof vv);
+    memcpy(&vv, val.data, val.size);
+    assert(vv == v);
+    free(val.data);
+}
+
+void expect_cursor_get(DBC *cursor, int k, int v) {
+    DBT key, val;
+    int r = cursor->c_get(cursor, dbt_init_malloc(&key), dbt_init_malloc(&val), DB_NEXT);
+    assert(r == 0);
+    assert(key.size == sizeof k);
+    int kk;
+    memcpy(&kk, key.data, key.size);
+    assert(val.size == sizeof v);
+    int vv;
+    memcpy(&vv, val.data, val.size);
+    if (kk != k || vv != v) printf("expect key %d got %d - %d %d\n", htonl(k), htonl(kk), htonl(v), htonl(vv));
+    assert(kk == k);
+    assert(vv == v);
+
+    free(key.data);
+    free(val.data);
+}
+
+void expect_cursor_set(DBC *cursor, int k, int expectr) {
+    DBT key, val;
+    int r = cursor->c_get(cursor, dbt_init(&key, &k, sizeof k), dbt_init_malloc(&val), DB_SET);
+    assert(r == expectr);
+    if (val.data) free(val.data);
+}
+
+void expect_cursor_get_both(DBC *cursor, int k, int v) {
+    DBT key, val;
+    int r = cursor->c_get(cursor, dbt_init(&key, &k, sizeof k), dbt_init(&val, &v, sizeof v), DB_GET_BOTH);
+    assert(r == 0);
+}
+
+void expect_cursor_get_current(DBC *cursor, int k, int v) {
+    DBT key, val;
+    int r = cursor->c_get(cursor, dbt_init_malloc(&key), dbt_init_malloc(&val), DB_CURRENT);
+    assert(r == 0);
+    int kk, vv;
+    assert(key.size == sizeof kk); memcpy(&kk, key.data, key.size); assert(kk == k);
+    assert(val.size == sizeof vv); memcpy(&vv, val.data, val.size); assert(vv == v);
+    free(key.data); free(val.data);
+}
+
+
+/* insert, close, delete, insert, search */
+void test_icdi_search(int n, int dup_mode) {
+    if (verbose) printf("test_icdi_search:%d %d\n", n, dup_mode);
+
+    DB_ENV * const null_env = 0;
+    DB *db;
+    DB_TXN * const null_txn = 0;
+    const char * const fname = DIR "/" "test_icdi_search.brt";
+    int r;
+
+    unlink(fname);
+
+    /* create the dup database file */
+    r = db_create(&db, null_env, 0); assert(r == 0);
+    r = db->set_flags(db, dup_mode); assert(r == 0);
+    r = db->set_pagesize(db, 4096); assert(r == 0);
+    r = db->open(db, null_txn, fname, "main", DB_BTREE, DB_CREATE, 0666); assert(r == 0);
+
+    int i;
+    for (i=0; i<n; i++) {
+        int k = htonl(i);
+        int v = htonl(i);
+        db_put(db, k, v);
+
+        expect_db_get(db, k, v);
+    } 
+
+    /* reopen the database to force nonleaf buffering */
+    r = db->close(db, 0); assert(r == 0);
+    r = db_create(&db, null_env, 0); assert(r == 0);
+    r = db->set_flags(db, dup_mode); assert(r == 0);
+    r = db->set_pagesize(db, 4096); assert(r == 0);
+    r = db->open(db, null_txn, fname, "main", DB_BTREE, 0, 0666); assert(r == 0);
+
+    for (i=0; i<n; i++)
+        db_del(db, htonl(i));
+
+    {
+    DBC *cursor;
+    r = db->cursor(db, 0, &cursor, 0); assert(r == 0);
+    expect_cursor_set(cursor, 0, DB_NOTFOUND);
+    r = cursor->c_close(cursor); assert(r == 0);
+    }
+
+    for (i=0; i<n; i++) {
+        int k = htonl(i);
+        int v = htonl(n+i);
+        db_put(db, k, v);
+
+        DBC *cursor;
+        r = db->cursor(db, 0, &cursor, 0); assert(r == 0);
+        expect_cursor_set(cursor, k, 0);
+        expect_cursor_get_current(cursor, k, v);
+        r = cursor->c_close(cursor); assert(r == 0);
+    } 
+
+    DBC *cursor;
+    r = db->cursor(db, null_txn, &cursor, 0); assert(r == 0);
+
+    for (i=0; i<n; i++) {
+        expect_cursor_get(cursor, htonl(i), htonl(n+i));
+    }
+
+    r = cursor->c_close(cursor); assert(r == 0);
+
+    r = db->close(db, 0); assert(r == 0);
+}
+
+
+int main(int argc, const char *argv[]) {
+    int i;
+
+    parse_args(argc, argv);
+  
+    system("rm -rf " DIR);
+    mkdir(DIR, 0777);
+
+    for (i=1; i<65537; i *= 2) {
+        test_icdi_search(i, 0);
+    }
+    return 0;
+}