mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-02-02 12:01:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Get rid of many icc warnings. Addresses #1185.

Browse source 
git-svn-id: file:///svn/tokudb.1131b+1080a+1185@6397 c7de825b-a66e-492c-adef-691d508d4ae1
This commit is contained in:
Bradley C. Kuszmaul 2013-04-16 23:57:20 -04:00 • committed by Yoni Fogel
parent cb93aed2c6
commit 10ba8ccd81
74 changed files with 710 additions and 702 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/tests/Makefile
View file

@ -45,13 +45,13 @@ endif
LIBNAME=libdb.$(LIBEXT)
# GCOV_FLAGS = -fprofile-arcs -ftest-coverage
CFLAGS += -Wall $(OPTFLAGS) $(GCOV_FLAGS)
CFLAGS += -Werror -Wall $(OPTFLAGS) $(GCOV_FLAGS)
ifneq ($(CC),icc)
CFLAGS += -Werror -g3 -ggdb3
CFLAGS += -g3 -ggdb3
else
CFLAGS += -g
CFLAGS += -diag-disable 128 # Don't complain that loops are not reachable from preceeding code.
CFLAGS += -diag-disable 981 # Don't complain about "operands are evaluated in unspecified order". This seems to be generated whenever more than one argument to a function or operand is computed by function call.
endif
TDB_CPPFLAGS = -I../../include

39
src/tests/test_db_dbt_appmalloc.c
View file

@ -18,26 +18,28 @@ typedef struct {
char waste[10240];
} DATA;
int callback_set_malloc;
DB* db;
DB* sdb;
DB_TXN *const null_txn = 0;
DB_ENV *dbenv;
static int callback_set_malloc;
static DB* db;
static DB* sdb;
static DB_TXN *const null_txn = 0;
static DB_ENV *dbenv;
static __attribute__((__unused__)) void* lastmalloced;
void* lastmalloced;
void* my_malloc(size_t size) {
static void* my_malloc(size_t size) {
void* p = malloc(size);
return p;
}
void* my_realloc(void *p, size_t size) {
static __attribute__((__unused__))
void*
my_realloc (void *p, size_t size) {
return realloc(p, size);
}
void my_free(void * p) {
static __attribute__((__unused__))
void
my_free(void * p) {
if (lastmalloced == p) {
if (verbose) printf("Freeing %p.\n", p);
lastmalloced = NULL;
@ -49,7 +51,8 @@ void my_free(void * p) {
* getname -- extracts a secondary key (the last name) from a primary
* key/data pair
*/
int getskey(DB *UU(secondary), const DBT *UU(pkey), const DBT *pdata, DBT *skey)
static int
getskey (DB *UU(secondary), const DBT *UU(pkey), const DBT *pdata, DBT *skey)
{
DATA* entry;
@ -72,7 +75,8 @@ int getskey(DB *UU(secondary), const DBT *UU(pkey), const DBT *pdata, DBT *skey)
return 0;
}
void second_setup() {
static void
second_setup (void) {
int r;
dbenv = 0;
@ -93,7 +97,8 @@ void second_setup() {
r = db->associate(db, null_txn, sdb, getskey, 0); CKERR(r);
}
void insert_test() {
static void
insert_test (void) {
int r;
static DATA entry;
DBT data;
@ -108,7 +113,8 @@ void insert_test() {
r = db->put(db, null_txn, &key, &data, 0); CKERR(r);
}
void delete_test() {
static void
delete_test (void) {
int r;
static DATA entry;
DBT key;
@ -121,7 +127,8 @@ void delete_test() {
r = db->del(db, null_txn, &key, 0); CKERR(r);
}
void close_dbs() {
static void
close_dbs(void) {
int r;
r = db->close(db, 0); CKERR(r);

39
src/tests/test_db_dbt_malloc_leak.c
View file

@ -24,7 +24,8 @@ DB_ENV *dbenv;
int nummallocced = 0;
void* my_malloc(size_t size) {
static void *
my_malloc (size_t size) {
void* p = malloc(size);
if (size != 0) {
nummallocced++;
@ -33,13 +34,16 @@ void* my_malloc(size_t size) {
return p;
}
void* my_realloc(void *p, size_t size) {
static __attribute__((__unused__))
void*
my_realloc (void *p, size_t size) {
void* newp = realloc(p, size);
// if (verbose) printf("realloc [%d] %p.\n", (int)size, newp);
return newp;
}
void my_free(void * p) {
static void
my_free (void * p) {
if (p) {
nummallocced--;
// if (verbose) printf("Free %p.\n", p);
@ -51,7 +55,8 @@ void my_free(void * p) {
* getname -- extracts a secondary key (the last name) from a primary
* key/data pair
*/
int getskey(DB *UU(secondary), const DBT *UU(pkey), const DBT *pdata, DBT *skey)
static int
getskey (DB *UU(secondary), const DBT *UU(pkey), const DBT *pdata, DBT *skey)
{
DATA* entry;
@ -73,7 +78,7 @@ int getskey(DB *UU(secondary), const DBT *UU(pkey), const DBT *pdata, DBT *skey)
return 0;
}
void second_setup(u_int32_t dupflags) {
static void second_setup (u_int32_t dupflags) {
int r;
system("rm -rf " ENVDIR);
@ -99,7 +104,8 @@ void second_setup(u_int32_t dupflags) {
r = db->associate(db, null_txn, sdb, getskey, 0); CKERR(r);
}
void insert_test(int pkey, int skey) {
static void
insert_test (int pkey, int skey) {
int r;
DATA entry;
DBT data;
@ -114,7 +120,8 @@ void insert_test(int pkey, int skey) {
r = db->put(db, null_txn, &key, &data, 0); CKERR(r);
}
DBT* dbt_init_malloc_and_copy(DBT* dbt, int something) {
static DBT *
dbt_init_malloc_and_copy (DBT* dbt, int something) {
dbt_init_malloc(dbt);
dbt->size = sizeof(something);
dbt->data = my_malloc(dbt->size);
@ -122,7 +129,8 @@ DBT* dbt_init_malloc_and_copy(DBT* dbt, int something) {
return dbt;
}
void pget_test_set_skey_pkey(DBC* dbc, u_int32_t flag, int expect, int set_skey, int skey_set, int set_pkey, int pkey_set) {
static void
pget_test_set_skey_pkey (DBC* dbc, u_int32_t flag, int expect, int set_skey, int skey_set, int set_pkey, int pkey_set) {
int r;
DBT skey;
DBT pkey;
@ -140,11 +148,13 @@ void pget_test_set_skey_pkey(DBC* dbc, u_int32_t flag, int expect, int set_skey,
my_free(data.data);
}
void pget_test(DBC* dbc, u_int32_t flag, u_int32_t expect) {
static void
pget_test (DBC* dbc, u_int32_t flag, u_int32_t expect) {
pget_test_set_skey_pkey(dbc, flag, expect, 0, 0, 0, 0);
}
void close_dbs() {
static void
close_dbs (void) {
int r;
r = db->close(db, 0); CKERR(r);
@ -152,7 +162,8 @@ void close_dbs() {
}
u_int32_t get_dupflags(u_int32_t flag) {
static u_int32_t
get_dupflags (u_int32_t flag) {
if (flag == DB_NEXT_DUP) {
return DB_DUP | DB_DUPSORT;
}
@ -166,7 +177,8 @@ const int skeysmall = 11;
const int skeymid = 13;
const int skeybig = 17;
void insert_setup(u_int32_t flag) {
static void
insert_setup (u_int32_t flag) {
switch (flag) {
case (DB_SET_RANGE): //Must be inserted in descending
case (DB_SET): //Just insert any two.
@ -208,7 +220,8 @@ void insert_setup(u_int32_t flag) {
}
void cursor_setup(DBC* dbc, u_int32_t flag) {
static void
cursor_setup (DBC* dbc, u_int32_t flag) {
switch (flag) {
#ifdef DB_NEXT_NODUP
case (DB_NEXT_NODUP):

11
src/tests/test_db_dbt_mem_behavior.c
View file

@ -22,7 +22,8 @@ DB_ENV *dbenv;
u_int32_t set_ulen;
int32_t key_1 = 1;
void setup(void) {
static void
setup(void) {
int r;
system("rm -rf " ENVDIR);
@ -33,7 +34,8 @@ void setup(void) {
r = db->open(db, null_txn, ENVDIR "/primary.db", NULL, DB_BTREE, DB_CREATE, 0600); CKERR(r);
}
void insert_test(void) {
static void
insert_test (void) {
int r;
DATA entry;
DBT data;
@ -47,7 +49,8 @@ void insert_test(void) {
r = db->put(db, null_txn, &key, &data, 0); CKERR(r);
}
void close_dbs() {
static void
close_dbs (void) {
int r;
r = db->close(db, 0); CKERR(r);
@ -132,7 +135,7 @@ int main(int argc, const char *argv[]) {
BOOL ulen_should_change = FALSE;
#if defined(USE_TDB)
if (flags[j] == DB_DBT_REALLOC) {
ulen_should_change = old_ulen < sizeof(DATA);
ulen_should_change = (BOOL)(old_ulen < sizeof(DATA));
}
#endif
assert(ulen_should_change == ulen_changed);

16
src/tests/test_db_delboth.c
View file

@ -13,9 +13,10 @@
#include "test.h"
#if USE_TDB
#ifdef USE_TDB
enum {INFLATE=128};
void db_put(DB *db, int k, int v) {
static void
db_put (DB *db, int k, int v) {
DBT key, val;
static int vv[INFLATE];
vv[0] = v;
@ -23,7 +24,8 @@ void db_put(DB *db, int k, int v) {
CKERR(r);
}
void expect_db_delboth(DB *db, int k, int v, u_int32_t flags, int expectr) {
static void
expect_db_delboth (DB *db, int k, int v, u_int32_t flags, int expectr) {
DBT key, val;
static int vv[INFLATE];
vv[0] = v;
@ -31,7 +33,8 @@ void expect_db_delboth(DB *db, int k, int v, u_int32_t flags, int expectr) {
CKERR2(r, expectr);
}
void expect_db_getboth(DB *db, int k, int v, int expectr) {
static void
expect_db_getboth (DB *db, int k, int v, int expectr) {
DBT key, val;
static int vv[INFLATE];
vv[0] = v;
@ -39,7 +42,8 @@ void expect_db_getboth(DB *db, int k, int v, int expectr) {
CKERR2(r, expectr);
}
void test_db_delboth(int n, int dup_mode) {
static void
test_db_delboth (int n, int dup_mode) {
if (verbose) printf("test_db_delboth:%d %d\n", n, dup_mode);
DB_ENV * const null_env = 0;
@ -162,7 +166,7 @@ int main(int argc, const char *argv[]) {
parse_args(argc, argv);
#if USE_TDB
#ifdef USE_TDB
test_db_delboth(0, 0);
int i;

25
src/tests/test_db_delete.c
View file

@ -15,25 +15,29 @@
void db_put(DB *db, int k, int v) {
static void
db_put (DB *db, int k, int v) {
DBT key, val;
int r = db->put(db, 0, dbt_init(&key, &k, sizeof k), dbt_init(&val, &v, sizeof v), 0);
assert(r == 0);
}
void expect_db_del(DB *db, int k, int flags, int expectr) {
static void
expect_db_del (DB *db, int k, int flags, int expectr) {
DBT key;
int r = db->del(db, 0, dbt_init(&key, &k, sizeof k), flags);
assert(r == expectr);
}
void expect_db_get(DB *db, int k, int expectr) {
static void
expect_db_get (DB *db, int k, int expectr) {
DBT key, val;
int r = db->get(db, 0, dbt_init(&key, &k, sizeof k), dbt_init_malloc(&val), 0);
assert(r == expectr);
}
void test_db_delete(int n, int dup_mode) {
static void
test_db_delete (int n, int dup_mode) {
if (verbose) printf("test_db_delete:%d %d\n", n, dup_mode);
DB_ENV * const null_env = 0;
@ -83,22 +87,23 @@ void test_db_delete(int n, int dup_mode) {
}
expect_db_del(db, htonl(n), 0, DB_NOTFOUND);
#if USE_TDB
#if defined(USE_TDB)
expect_db_del(db, htonl(n), DB_DELETE_ANY, 0);
#endif
#if USE_BDB && defined(DB_DELETE_ANY)
#if DB_DELETE_ANY == 0
#if defined(USE_BDB) && defined(DB_DELETE_ANY)
#if DB_DELETE_ANY == 0
expect_db_del(db, htonl(n), DB_DELETE_ANY, DB_NOTFOUND);
#else
#else
expect_db_del(db, htonl(n), DB_DELETE_ANY, EINVAL);
#endif
#endif
#endif
r = db->close(db, 0);
assert(r == 0);
}
void test_db_get_datasize0() {
static void
test_db_get_datasize0 (void) {
if (verbose) printf("test_db_get_datasize0\n");
DB_ENV * const null_env = 0;

15
src/tests/test_db_donotindex.c
View file

@ -30,7 +30,8 @@ DB_ENV *dbenv = 0;
* getname -- extracts a secondary key (the last name) from a primary
* key/data pair
*/
int getskey(DB *UU(secondary), const DBT *UU(pkey), const DBT *pdata, DBT *skey)
static int
getskey (DB *UU(secondary), const DBT *UU(pkey), const DBT *pdata, DBT *skey)
{
/*
* Since the secondary key is a simple structure member of the
@ -69,7 +70,8 @@ int getskey(DB *UU(secondary), const DBT *UU(pkey), const DBT *pdata, DBT *skey)
return 0;
}
void second_setup() {
static void
second_setup (void) {
int r;
/* Open/create primary */
@ -83,7 +85,8 @@ void second_setup() {
r = db->associate(db, null_txn, sdb, getskey, 0); CKERR(r);
}
void insert() {
static void
insert (void) {
int r;
DATA entry;
DBT data;
@ -98,7 +101,8 @@ void insert() {
r = db->put(db, null_txn, &key, &data, 0); CKERR(r);
}
void check_secondary(int expect_r) {
static void
check_secondary (int expect_r) {
int r;
DBC *c;
DBT skey;
@ -111,7 +115,8 @@ void check_secondary(int expect_r) {
r = c->c_close(c); CKERR(r);
}
void close_dbs() {
static void
close_dbs (void) {
int r;
r = db->close(db, 0); CKERR(r);

3
src/tests/test_db_env_open_dir_priority.c
View file

@ -33,7 +33,8 @@ int extra_flags;
char* home;
void reinit_config(int set_home, int set_DB_ENVIRON, int set_DB_HOME) {
static void
reinit_config (int set_home, int set_DB_ENVIRON, int set_DB_HOME) {
int r = 0;
//Return to base dir
r = fchdir(rootfd); assert(r == 0);

2
src/tests/test_db_env_open_open_close.c
View file

@ -16,7 +16,7 @@
int main(int argc, char** argv) {
DB_ENV *dbenv;
int r;
int verbose = 0;
int __attribute__((__unused__)) verbose = 0;
if (argc == 2 && !strcmp(argv[1], "-v")) verbose = 1;
system("rm -rf " ENVDIR);

40
src/tests/test_db_get_put_flags.c
View file

@ -48,12 +48,13 @@ typedef struct {
TEST tests[4];
} STEST;
DB *dbp;
DB *sdbp;
DB_TXN *const null_txn = 0;
DB_ENV *dbenv;
static DB *dbp;
static DB *sdbp;
static DB_TXN *const null_txn = 0;
static DB_ENV *dbenv;
void setup(u_int32_t flags) {
static void
setup (u_int32_t flags) {
int r;
system("rm -rf " ENVDIR);
@ -67,17 +68,20 @@ void setup(u_int32_t flags) {
r = dbp->open(dbp, NULL, ENVDIR "/primary.db", NULL, DB_BTREE, DB_CREATE, 0600); CKERR(r);
}
void close_dbs() {
static void
close_dbs (void) {
int r;
r = dbp->close(dbp, 0); CKERR(r);
}
void close_secondary() {
static void
close_secondary (void) {
int r;
r = sdbp->close(sdbp, 0); CKERR(r);
}
void insert_bad_flags(DB* db, u_int32_t flags, int r_expect, int keyint, int dataint) {
static void
insert_bad_flags (DB* db, u_int32_t flags, int r_expect, int keyint, int dataint) {
DBT key;
DBT data;
int r;
@ -88,7 +92,8 @@ void insert_bad_flags(DB* db, u_int32_t flags, int r_expect, int keyint, int dat
CKERR2(r, r_expect);
}
void cinsert_bad_flags(DBC* dbc, u_int32_t flags, int r_expect, int keyint, int dataint) {
static void
cinsert_bad_flags (DBC* dbc, u_int32_t flags, int r_expect, int keyint, int dataint) {
DBT key;
DBT data;
int r;
@ -99,7 +104,8 @@ void cinsert_bad_flags(DBC* dbc, u_int32_t flags, int r_expect, int keyint, int
CKERR2(r, r_expect);
}
void get_bad_flags(DB* db, u_int32_t flags, int r_expect, int keyint, int dataint) {
static void
get_bad_flags (DB* db, u_int32_t flags, int r_expect, int keyint, int dataint) {
DBT key;
DBT data;
int r;
@ -113,7 +119,8 @@ void get_bad_flags(DB* db, u_int32_t flags, int r_expect, int keyint, int datain
assert(*(int*)data.data == dataint);
}
void cinsert_test(TEST tests[4]) {
static void
cinsert_test (TEST tests[4]) {
int r;
int i;
DBC *dbc;
@ -134,7 +141,8 @@ void cinsert_test(TEST tests[4]) {
r = dbc->c_close(dbc); CKERR(r);
}
void stest(TEST tests[4]) {
static void
stest (TEST tests[4]) {
int i;
for (i = 0; i < 4; i++) {
@ -206,16 +214,18 @@ const int num_get = sizeof(get_tests) / sizeof(get_tests[0]);
STEST stests[] = {
{0, 0, {{SGET, DB_GET_BOTH, EINVAL, 0, 1}, {NONE, 0, 0, 0, 0}, }},
};
const int num_stests = sizeof(stests) / sizeof(stests[0]);
static const int num_stests = sizeof(stests) / sizeof(stests[0]);
int identity_callback(DB *secondary __attribute__((__unused__)), const DBT *key, const DBT *UU(data), DBT *result) {
static int
identity_callback (DB *secondary __attribute__((__unused__)), const DBT *key, const DBT *UU(data), DBT *result) {
memset(result, 0, sizeof(result));
result->size = key->size;
result->data = key->data;
return 0;
}
void setup_secondary(u_int32_t flags) {
static void
setup_secondary (u_int32_t flags) {
int r;
/* Open/create primary */

24
src/tests/test_db_secondary.c
View file

@ -11,7 +11,8 @@
// ENVDIR is defined in the Makefile
int dbtcmp(DBT *dbt1, DBT *dbt2) {
static int
dbtcmp (DBT *dbt1, DBT *dbt2) {
int r;
r = dbt1->size - dbt2->size; if (r) return r;
@ -32,7 +33,8 @@ DB_ENV *dbenv;
* getname -- extracts a secondary key (the last name) from a primary
* key/data pair
*/
int getname(DB *UU(secondary), const DBT *UU(pkey), const DBT *pdata, DBT *skey)
static int
getname(DB *UU(secondary), const DBT *UU(pkey), const DBT *pdata, DBT *skey)
{
/*
* Since the secondary key is a simple structure member of the
@ -49,7 +51,8 @@ int getname(DB *UU(secondary), const DBT *UU(pkey), const DBT *pdata, DBT *skey)
return (0);
}
void second_setup() {
static void
second_setup (void) {
int r;
/* Open/create primary */
@ -71,7 +74,8 @@ void second_setup() {
r = dbp->associate(dbp, NULL, sdbp, getname, 0); CKERR(r);
}
void setup_student(struct student_record *s) {
static void
setup_student (struct student_record *s) {
memset(s, 0, sizeof(struct student_record));
memcpy(&s->student_id, "WC42" SPACES, sizeof(s->student_id));
//Padded with enough spaces to fill out last/first name.
@ -79,7 +83,8 @@ void setup_student(struct student_record *s) {
memcpy(&s->first_name, "Winston" SPACES, sizeof(s->first_name));
}
void insert_test() {
static void
insert_test (void) {
struct student_record s;
DBT data;
DBT key;
@ -124,7 +129,8 @@ void insert_test() {
r = dbp->pget(dbp, null_txn, &key, &testkey, &data, 0); assert(r == EINVAL);
}
void delete_from_primary() {
static void
delete_from_primary (void) {
int r;
DBT key;
@ -134,7 +140,8 @@ void delete_from_primary() {
r = dbp->del(dbp, null_txn, &key, 0); CKERR(r);
}
void delete_from_secondary() {
static void
delete_from_secondary (void) {
int r;
DBT skey;
DBT data;
@ -150,7 +157,8 @@ void delete_from_secondary() {
r = sdbp->del(sdbp, null_txn, &skey, 0); CKERR(r);
}
void verify_gone() {
static void
verify_gone (void) {
int r;
DBT key;
DBT skey;

3
src/tests/test_db_set_flags.c
View file

@ -13,7 +13,8 @@
#include "test.h"
void test_db_set_flags(int flags, int expectr, int flags2, int expectr2) {
static void
test_db_set_flags (int flags, int expectr, int flags2, int expectr2) {
if (verbose) printf("test_db_set_flags:%d %d %d %d\n", flags, expectr, flags2, expectr2);
DB_ENV * const null_env = 0;

166
src/tests/test_db_txn_locks.c
View file

@ -15,7 +15,8 @@ struct heavi_extra {
DB* db;
};
int heavi_after(const DBT *key, const DBT *val, void *extra) {
static int
heavi_after (const DBT *key, const DBT *val, void *extra) {
//Assumes cmp is int_dbt_cmp
struct heavi_extra *info = extra;
int cmp = int_dbt_cmp(info->db, key, &info->key);
@ -28,7 +29,8 @@ int heavi_after(const DBT *key, const DBT *val, void *extra) {
//Returns >0 for greater with different key
}
int heavi_before(const DBT *key, const DBT *val, void *extra) {
static int
heavi_before (const DBT *key, const DBT *val, void *extra) {
struct heavi_extra *info = extra;
int cmp = int_dbt_cmp(info->db, key, &info->key);
if (cmp!=0) return cmp;
@ -42,19 +44,13 @@ int heavi_before(const DBT *key, const DBT *val, void *extra) {
// ENVDIR is defined in the Makefile
int dbtcmp(DBT *dbt1, DBT *dbt2) {
int r;
r = dbt1->size - dbt2->size; if (r) return r;
return memcmp(dbt1->data, dbt2->data, dbt1->size);
}
static DB *db;
static DB_TXN* txns[(int)256];
static DB_ENV* dbenv;
static DBC* cursors[(int)256];
DB *db;
DB_TXN* txns[(int)256];
DB_ENV* dbenv;
DBC* cursors[(int)256];
void put(BOOL success, char txn, int _key, int _data) {
static void
put(BOOL success, char txn, int _key, int _data) {
assert(txns[(int)txn]);
int r;
@ -70,8 +66,9 @@ void put(BOOL success, char txn, int _key, int _data) {
else CKERR2s(r, DB_LOCK_DEADLOCK, DB_LOCK_NOTGRANTED);
}
void cget(BOOL success, BOOL find, char txn, int _key, int _data,
int _key_expect, int _data_expect, u_int32_t flags) {
static void
cget(BOOL success, BOOL find, char txn, int _key, int _data,
int _key_expect, int _data_expect, u_int32_t flags) {
assert(txns[(int)txn] && cursors[(int)txn]);
int r;
@ -93,7 +90,8 @@ void cget(BOOL success, BOOL find, char txn, int _key, int _data,
else CKERR2s(r, DB_LOCK_DEADLOCK, DB_LOCK_NOTGRANTED);
}
void cdel(BOOL success, BOOL find, char txn) {
static void
cdel (BOOL success, BOOL find, char txn) {
int r;
r = cursors[(int)txn]->c_del(cursors[(int)txn], 0);
@ -104,7 +102,8 @@ void cdel(BOOL success, BOOL find, char txn) {
else CKERR2s(r, DB_LOCK_DEADLOCK, DB_LOCK_NOTGRANTED);
}
void dbdel(BOOL success, BOOL find, char txn, int _key) {
static void
dbdel (BOOL success, BOOL find, char txn, int _key) {
int r;
DBT key;
@ -119,7 +118,8 @@ void dbdel(BOOL success, BOOL find, char txn, int _key) {
else CKERR2s(r, DB_LOCK_DEADLOCK, DB_LOCK_NOTGRANTED);
}
void init_txn(char name) {
static void
init_txn (char name) {
int r;
assert(!txns[(int)name]);
r = dbenv->txn_begin(dbenv, NULL, &txns[(int)name], DB_TXN_NOWAIT);
@ -127,7 +127,8 @@ void init_txn(char name) {
assert(txns[(int)name]);
}
void init_dbc(char name) {
static void
init_dbc (char name) {
int r;
assert(!cursors[(int)name] && txns[(int)name]);
@ -136,7 +137,8 @@ void init_dbc(char name) {
assert(cursors[(int)name]);
}
void commit_txn(char name) {
static void
commit_txn (char name) {
int r;
assert(txns[(int)name] && !cursors[(int)name]);
@ -145,7 +147,8 @@ void commit_txn(char name) {
txns[(int)name] = NULL;
}
void abort_txn(char name) {
static void
abort_txn (char name) {
int r;
assert(txns[(int)name] && !cursors[(int)name]);
@ -154,7 +157,8 @@ void abort_txn(char name) {
txns[(int)name] = NULL;
}
void close_dbc(char name) {
static void
close_dbc (char name) {
int r;
assert(cursors[(int)name]);
@ -163,19 +167,22 @@ void close_dbc(char name) {
cursors[(int)name] = NULL;
}
void early_commit(char name) {
static void
early_commit (char name) {
assert(cursors[(int)name] && txns[(int)name]);
close_dbc(name);
commit_txn(name);
}
void early_abort(char name) {
static void
early_abort (char name) {
assert(cursors[(int)name] && txns[(int)name]);
close_dbc(name);
abort_txn(name);
}
void setup_dbs(u_int32_t dup_flags) {
static void
setup_dbs (u_int32_t dup_flags) {
int r;
system("rm -rf " ENVDIR);
@ -210,7 +217,8 @@ void setup_dbs(u_int32_t dup_flags) {
for (a = 'a'; a <= 'z'; a++) init_dbc(a);
}
void close_dbs(void) {
static void
close_dbs(void) {
char a;
for (a = 'a'; a <= 'z'; a++) {
if (cursors[(int)a]) close_dbc(a);
@ -227,7 +235,9 @@ void close_dbs(void) {
}
void test_abort(u_int32_t dup_flags) {
static __attribute__((__unused__))
void
test_abort (u_int32_t dup_flags) {
/* ********************************************************************** */
setup_dbs(dup_flags);
put(TRUE, 'a', 1, 1);
@ -250,7 +260,8 @@ void test_abort(u_int32_t dup_flags) {
/* ********************************************************************** */
}
void test_both(u_int32_t dup_flags, u_int32_t db_flags) {
static void
test_both (u_int32_t dup_flags, u_int32_t db_flags) {
/* ********************************************************************** */
setup_dbs(dup_flags);
cget(TRUE, FALSE, 'a', 1, 1, 0, 0, db_flags);
@ -291,7 +302,8 @@ void test_both(u_int32_t dup_flags, u_int32_t db_flags) {
}
void test_last(u_int32_t dup_flags) {
static void
test_last (u_int32_t dup_flags) {
/* ********************************************************************** */
setup_dbs(dup_flags);
cget(TRUE, FALSE, 'a', 0, 0, 0, 0, DB_LAST);
@ -324,11 +336,12 @@ void test_last(u_int32_t dup_flags) {
setup_dbs(dup_flags);
put(TRUE, 'a', 1, 1);
cget(TRUE, TRUE, 'a', 0, 0, 1, 1, DB_LAST);
put(dup_flags != 0, 'b', 1, 0);
put((BOOL)(dup_flags != 0), 'b', 1, 0);
close_dbs();
}
void test_first(u_int32_t dup_flags) {
static void
test_first (u_int32_t dup_flags) {
/* ********************************************************************** */
setup_dbs(dup_flags);
cget(TRUE, FALSE, 'a', 0, 0, 0, 0, DB_FIRST);
@ -361,11 +374,12 @@ void test_first(u_int32_t dup_flags) {
setup_dbs(dup_flags);
put(TRUE, 'a', 1, 1);
cget(TRUE, TRUE, 'a', 0, 0, 1, 1, DB_FIRST);
put(dup_flags != 0, 'b', 1, 2);
put((BOOL)(dup_flags != 0), 'b', 1, 2);
close_dbs();
}
void test_set_range(u_int32_t dup_flags) {
static void
test_set_range (u_int32_t dup_flags) {
/* ********************************************************************** */
setup_dbs(dup_flags);
cget(TRUE, FALSE, 'a', 1, 1, 0, 0, DB_SET_RANGE);
@ -413,7 +427,8 @@ void test_set_range(u_int32_t dup_flags) {
close_dbs();
}
void test_both_range(u_int32_t dup_flags) {
static void
test_both_range (u_int32_t dup_flags) {
if (dup_flags == 0) {
test_both(dup_flags, DB_GET_BOTH_RANGE);
return;
@ -464,7 +479,8 @@ void test_both_range(u_int32_t dup_flags) {
close_dbs();
}
void test_next(u_int32_t dup_flags, u_int32_t next_type) {
static void
test_next (u_int32_t dup_flags, u_int32_t next_type) {
/* ********************************************************************** */
setup_dbs(dup_flags);
put(TRUE, 'a', 2, 1);
@ -493,7 +509,8 @@ void test_next(u_int32_t dup_flags, u_int32_t next_type) {
close_dbs();
}
void test_prev(u_int32_t dup_flags, u_int32_t next_type) {
static void
test_prev (u_int32_t dup_flags, u_int32_t next_type) {
/* ********************************************************************** */
setup_dbs(dup_flags);
put(TRUE, 'a', -2, -1);
@ -522,7 +539,8 @@ void test_prev(u_int32_t dup_flags, u_int32_t next_type) {
close_dbs();
}
void test_nextdup(u_int32_t dup_flags, u_int32_t next_type, int i) {
static void
test_nextdup (u_int32_t dup_flags, u_int32_t next_type, int i) {
/* ****************************************** */
if (dup_flags == 0) return;
setup_dbs(dup_flags);
@ -551,7 +569,8 @@ void test_nextdup(u_int32_t dup_flags, u_int32_t next_type, int i) {
close_dbs();
}
void test_cdel(u_int32_t dup_flags) {
static void
test_cdel (u_int32_t dup_flags) {
/* ********************************************************************** */
setup_dbs(dup_flags);
put(TRUE, 'c', 1, 1);
@ -559,8 +578,8 @@ void test_cdel(u_int32_t dup_flags) {
cget(TRUE, TRUE, 'a', 1, 1, 1, 1, DB_GET_BOTH);
cdel(TRUE, TRUE, 'a');
cget(FALSE, TRUE, 'b', 1, 1, 1, 1, DB_GET_BOTH);
cget(dup_flags != 0, FALSE, 'b', 1, 2, 1, 2, DB_GET_BOTH);
cget(dup_flags != 0, FALSE, 'b', 1, 0, 1, 0, DB_GET_BOTH);
cget((BOOL)(dup_flags != 0), FALSE, 'b', 1, 2, 1, 2, DB_GET_BOTH);
cget((BOOL)(dup_flags != 0), FALSE, 'b', 1, 0, 1, 0, DB_GET_BOTH);
cget(TRUE, FALSE, 'b', 0, 0, 0, 0, DB_GET_BOTH);
cget(TRUE, FALSE, 'b', 2, 10, 2, 10, DB_GET_BOTH);
close_dbs();
@ -574,7 +593,8 @@ void test_cdel(u_int32_t dup_flags) {
close_dbs();
}
void test_dbdel(u_int32_t dup_flags) {
static void
test_dbdel (u_int32_t dup_flags) {
if (dup_flags != 0) {
if (verbose) printf("Pinhead! Can't dbdel now with duplicates!\n");
return;
@ -612,7 +632,8 @@ void test_dbdel(u_int32_t dup_flags) {
close_dbs();
}
void test_current(u_int32_t dup_flags) {
static void
test_current (u_int32_t dup_flags) {
/* ********************************************************************** */
setup_dbs(dup_flags);
put(TRUE, 'a', 1, 1);
@ -636,7 +657,9 @@ struct int_pair {
int got_r_h;
void f_heavi(DBT const *key, DBT const *val, void *extra_f, int r_h) {
static __attribute__((__unused__))
void
f_heavi (DBT const *key, DBT const *val, void *extra_f, int r_h) {
struct int_pair *info = extra_f;
if (r_h==0) got_r_h = 0;
@ -647,11 +670,28 @@ void f_heavi(DBT const *key, DBT const *val, void *extra_f, int r_h) {
info->val = *(int*)val->data;
}
void cget_heavi(BOOL success, BOOL find, char txn, int _key, int _val,
int _key_expect, int _val_expect, int direction,
int r_h_expect,
int (*h)(const DBT*,const DBT*,void*)) {
static __attribute__((__unused__))
void
ignore (void *ignore __attribute__((__unused__))) {
}
#define IGNORE(x) ignore((void*)x)
static void
cget_heavi (BOOL success, BOOL find, char txn, int _key, int _val,
int _key_expect, int _val_expect, int direction,
int r_h_expect,
int (*h)(const DBT*,const DBT*,void*)) {
#if defined(USE_BDB)
IGNORE(success);
IGNORE(find);
IGNORE(txn);
IGNORE(_key);
IGNORE(_val);
IGNORE(_key_expect);
IGNORE(_val_expect);
IGNORE(direction);
IGNORE(h);
IGNORE(r_h_expect);
return;
#else
assert(txns[(int)txn] && cursors[(int)txn]);
@ -686,7 +726,8 @@ void cget_heavi(BOOL success, BOOL find, char txn, int _key, int _val,
}
void test_heavi(u_int32_t dup_flags) {
static void
test_heavi (u_int32_t dup_flags) {
/* ********************************************************************** */
setup_dbs(dup_flags);
cget_heavi(TRUE, FALSE, 'a', 0, 0, 0, 0, 1, 0, heavi_after);
@ -744,7 +785,7 @@ void test_heavi(u_int32_t dup_flags) {
put(FALSE, 'b', 105, 2);
put(FALSE, 'b', 106, 0);
put(TRUE, 'b', 99, 0);
put(dup_flags!=0, 'b', 100, 104);
put((BOOL)(dup_flags!=0), 'b', 100, 104);
close_dbs();
/* ********************************************************************** */
// Test behavior of heavi_after
@ -780,7 +821,8 @@ void test_heavi(u_int32_t dup_flags) {
close_dbs();
}
void test(u_int32_t dup_flags) {
static void
test (u_int32_t dup_flags) {
/* ********************************************************************** */
setup_dbs(dup_flags);
close_dbs();
@ -832,17 +874,17 @@ void test(u_int32_t dup_flags) {
int main(int argc, const char* argv[]) {
parse_args(argc, argv);
#if defined(USE_BDB)
if (verbose) {
printf("Warning: " __FILE__" does not work in BDB.\n");
if (!IS_TDB) {
if (verbose) {
printf("Warning: " __FILE__" does not work in BDB.\n");
}
} else {
test(0);
test(DB_DUP | DB_DUPSORT);
/*
test_abort(0);
test_abort(DB_DUP | DB_DUPSORT);
*/
}
return 0;
#endif
test(0);
test(DB_DUP | DB_DUPSORT);
/*
test_abort(0);
test_abort(DB_DUP | DB_DUPSORT);
*/
return 0;
}

42
src/tests/test_dup_delete.c
View file

@ -12,14 +12,16 @@
#include "test.h"
void db_put(DB *db, int k, int v) {
static 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), DB_YESOVERWRITE);
assert(r == 0);
}
void expect(DBC *cursor, int k, int v) {
static void
expect (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);
@ -29,7 +31,7 @@ void expect(DBC *cursor, int k, int v) {
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));
if (kk != k || vv != v) printf("expect key %u got %u - %u %u\n", htonl(k), htonl(kk), htonl(v), htonl(vv));
assert(kk == k);
assert(vv == v);
@ -38,7 +40,8 @@ void expect(DBC *cursor, int k, int v) {
}
/* verify dup keys delete */
void test_dup_delete(int n, int dup_mode) {
static void
test_dup_delete (int n, int dup_mode) {
if (verbose) printf("test_dup_delete:%d %d\n", n, dup_mode);
DB_ENV * const null_env = 0;
@ -131,7 +134,9 @@ void test_dup_delete(int n, int dup_mode) {
assert(r == 0);
}
void test_dup_delete_delete(int n) {
static __attribute__((__unused__))
void
test_dup_delete_delete (int n) {
if (verbose) printf("test_dup_delete_delete:%d\n", n);
DB_ENV * const null_env = 0;
@ -211,7 +216,8 @@ void test_dup_delete_delete(int n) {
assert(r == 0);
}
void test_dup_delete_insert(int n, int dup_mode) {
static void
test_dup_delete_insert (int n, int dup_mode) {
if (verbose) printf("test_dup_delete_insert:%d %d\n", n, dup_mode);
DB_ENV * const null_env = 0;
@ -316,7 +322,9 @@ void test_dup_delete_insert(int n, int dup_mode) {
assert(r == 0);
}
void test_all_dup_delete_insert(int n) {
static __attribute__((__unused__))
void
test_all_dup_delete_insert (int n) {
if (verbose) printf("test_all_dup_delete_insert:%d\n", n);
DB_ENV * const null_env = 0;
@ -391,7 +399,8 @@ void test_all_dup_delete_insert(int n) {
assert(r == 0);
}
void test_walk_empty(int n, int dup_mode) {
static void
test_walk_empty (int n, int dup_mode) {
if (verbose) printf("test_walk_empty:%d %d\n", n, dup_mode);
DB_ENV * const null_env = 0;
@ -463,7 +472,9 @@ void test_walk_empty(int n, int dup_mode) {
}
/* insert, close, delete, insert, search */
void test_icdi_search(int n, int dup_mode) {
static __attribute__((__unused__))
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;
@ -552,7 +563,9 @@ void test_icdi_search(int n, int dup_mode) {
}
/* insert, close, insert, search */
void test_ici_search(int n, int dup_mode) {
static __attribute__((__unused__))
void
test_ici_search (int n, int dup_mode) {
if (verbose) printf("test_ici_search:%d %d\n", n, dup_mode);
DB_ENV * const null_env = 0;
@ -633,7 +646,8 @@ void test_ici_search(int n, int dup_mode) {
assert(r == 0);
}
void expect_db_lookup(DB *db, int k, int v) {
static void
expect_db_lookup (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);
@ -646,7 +660,9 @@ void expect_db_lookup(DB *db, int k, int v) {
}
/* insert 0, insert 1, close, insert 0, search 0 */
void test_i0i1ci0_search(int n, int dup_mode) {
static __attribute__((__unused__))
void
test_i0i1ci0_search (int n, int dup_mode) {
if (verbose) printf("test_i0i1ci0_search:%d %d\n", n, dup_mode);
DB_ENV * const null_env = 0;
@ -709,7 +725,7 @@ int main(int argc, const char *argv[]) {
system("rm -rf " ENVDIR);
mkdir(ENVDIR, 0777);
#if USE_BDB
#ifdef USE_BDB
/* dup tests */
for (i = 1; i <= (1<<16); i *= 2) {
test_dup_delete(i, DB_DUP);

89
src/tests/test_dup_dup.c
View file

@ -15,7 +15,8 @@
int errors;
void db_put(DB *db, int k, int v, u_int32_t put_flags, int rexpect) {
static void
db_put (DB *db, int k, int v, u_int32_t put_flags, int rexpect) {
DBT key, val;
// Turn off error messages if we expect there to be an error.
if (rexpect!=0) {
@ -25,35 +26,38 @@ void db_put(DB *db, int k, int v, u_int32_t put_flags, int rexpect) {
}
int r = db->put(db, 0, dbt_init(&key, &k, sizeof k), dbt_init(&val, &v, sizeof v), put_flags);
if (r != rexpect) {
#if USE_TDB
if (r == EINVAL && put_flags == DB_NODUPDATA) {
static int did_warn = 0;
if (!did_warn) {
if (verbose) printf("%s:%d:WARNING:tokdub does not support DB_NODUPDATA yet\n", __FILE__, __LINE__);
did_warn=1;
if (IS_TDB) {
if (r == EINVAL && put_flags == DB_NODUPDATA) {
static int did_warn = 0;
if (!did_warn) {
if (verbose) printf("%s:%d:WARNING:tokdub does not support DB_NODUPDATA yet\n", __FILE__, __LINE__);
did_warn=1;
}
return;
}
return;
}
#endif
}
printf("Expected %d, got %d\n", rexpect, r);
if (r != rexpect) errors = 1;
}
}
int maybe_do_db_dup_warning (int r, int dup_mode) {
#if USE_TDB
static int did_warn=0;
if (r != 0 && dup_mode == DB_DUP) {
if (did_warn==0) {
did_warn=1;
if (verbose) printf("%s:%d:WARNING: tokudb does not support DB_DUP\n", __FILE__, __LINE__);
static int
maybe_do_db_dup_warning (int r, int dup_mode) {
if (IS_TDB) {
static int did_warn=0;
if (r != 0 && dup_mode == DB_DUP) {
if (did_warn==0) {
did_warn=1;
if (verbose) printf("%s:%d:WARNING: tokudb does not support DB_DUP\n", __FILE__, __LINE__);
}
return 1;
}
return 1;
}
#endif
return 0;
}
void test_dup_key(int dup_mode, u_int32_t put_flags, int rexpect, int rexpectdupdup) {
static void
test_dup_key (int dup_mode, u_int32_t put_flags, int rexpect, int rexpectdupdup) {
if (verbose) printf("test_dup_key: %d, %u, %d, %d\n", dup_mode, put_flags, rexpect, rexpectdupdup);
DB_ENV * const null_env = 0;
@ -104,7 +108,8 @@ void test_dup_key(int dup_mode, u_int32_t put_flags, int rexpect, int rexpectdup
r = db->close(db, 0); assert(r == 0);
}
void test_dup_dup(int dup_mode, u_int32_t put_flags, int rexpect, int rexpectdupdup) {
static void
test_dup_dup (int dup_mode, u_int32_t put_flags, int rexpect, int rexpectdupdup) {
if (verbose) printf("test_dup_dup: %d, %u, %d, %d\n", dup_mode, put_flags, rexpect, rexpectdupdup);
DB_ENV * const null_env = 0;
@ -155,7 +160,8 @@ void test_dup_dup(int dup_mode, u_int32_t put_flags, int rexpect, int rexpectdup
r = db->close(db, 0); assert(r == 0);
}
void test_put_00_01_01(int dup_mode, u_int32_t put_flags) {
static void
test_put_00_01_01 (int dup_mode, u_int32_t put_flags) {
if (verbose) printf("test_put_00_01_01: %d, %u\n", dup_mode, put_flags);
DB_ENV * const null_env = 0;
@ -185,9 +191,9 @@ void test_put_00_01_01(int dup_mode, u_int32_t put_flags) {
db_put(db, 0, 1, put_flags, expectr);
expectr = (put_flags == DB_NOOVERWRITE || dup_mode & DB_DUPSORT) ? DB_KEYEXIST : 0;
#if USE_TDB
if (put_flags == DB_YESOVERWRITE) expectr = 0;
#endif
if (IS_TDB) {
if (put_flags == DB_YESOVERWRITE) expectr = 0;
}
db_put(db, 0, 1, put_flags, expectr);
DBC *cursor;
@ -215,9 +221,8 @@ void test_put_00_01_01(int dup_mode, u_int32_t put_flags) {
int main(int argc, const char *argv[]) {
int yes_overwrite=0;
#ifdef USE_TDB
yes_overwrite = DB_YESOVERWRITE;
#endif
if (IS_TDB)
yes_overwrite = DB_YESOVERWRITE;
parse_args(argc, argv);
@ -239,13 +244,13 @@ int main(int argc, const char *argv[]) {
test_dup_key(DB_DUP, DB_NODUPDATA, EINVAL, EINVAL);
test_dup_key(DB_DUP, DB_NOOVERWRITE, 0, DB_KEYEXIST);
#if USE_TDB
test_dup_key(DB_DUP | DB_DUPSORT, 0, EINVAL, EINVAL);
//test_dup_key(DB_DUP | DB_DUPSORT, 0, 0, 0);
test_dup_key(DB_DUP | DB_DUPSORT, DB_YESOVERWRITE, 0, 0);
#else
test_dup_key(DB_DUP | DB_DUPSORT, 0, 0, 0);
#endif
if (IS_TDB) {
test_dup_key(DB_DUP | DB_DUPSORT, 0, EINVAL, EINVAL);
//test_dup_key(DB_DUP | DB_DUPSORT, 0, 0, 0);
test_dup_key(DB_DUP | DB_DUPSORT, DB_YESOVERWRITE, 0, 0);
} else {
test_dup_key(DB_DUP | DB_DUPSORT, 0, 0, 0);
}
test_dup_key(DB_DUP | DB_DUPSORT, DB_NODUPDATA, 0, 0);
test_dup_key(DB_DUP | DB_DUPSORT, DB_NOOVERWRITE, 0, DB_KEYEXIST);
@ -258,13 +263,13 @@ int main(int argc, const char *argv[]) {
test_dup_dup(DB_DUP, DB_NODUPDATA, EINVAL, EINVAL);
test_dup_dup(DB_DUP, DB_NOOVERWRITE, 0, DB_KEYEXIST);
#if USE_TDB
// test_dup_dup(DB_DUP | DB_DUPSORT, 0, EINVAL, EINVAL);
//test_dup_dup(DB_DUP | DB_DUPSORT, 0, 0, DB_KEYEXIST);
test_dup_dup(DB_DUP | DB_DUPSORT, DB_YESOVERWRITE, 0, 0);
#else
test_dup_dup(DB_DUP | DB_DUPSORT, 0 , 0, DB_KEYEXIST);
#endif
if (IS_TDB) {
// test_dup_dup(DB_DUP | DB_DUPSORT, 0, EINVAL, EINVAL);
//test_dup_dup(DB_DUP | DB_DUPSORT, 0, 0, DB_KEYEXIST);
test_dup_dup(DB_DUP | DB_DUPSORT, DB_YESOVERWRITE, 0, 0);
} else {
test_dup_dup(DB_DUP | DB_DUPSORT, 0 , 0, DB_KEYEXIST);
}
test_dup_dup(DB_DUP | DB_DUPSORT, DB_NODUPDATA, 0, DB_KEYEXIST);
test_dup_dup(DB_DUP | DB_DUPSORT, DB_NOOVERWRITE, 0, DB_KEYEXIST);

31
src/tests/test_dup_flags.c
View file

@ -13,8 +13,9 @@
#include "test.h"
/* verify that the dup flags are written and read from the database file correctly */
void test_dup_flags(u_int32_t dup_flags) {
if (verbose) printf("test_dup_flags:%d\n", dup_flags);
static void
test_dup_flags (u_int32_t dup_flags) {
if (verbose) printf("test_dup_flags:%u\n", dup_flags);
DB_ENV * const null_env = 0;
DB *db;
@ -27,23 +28,23 @@ void test_dup_flags(u_int32_t dup_flags) {
/* create the dup database file */
r = db_create(&db, null_env, 0); assert(r == 0);
r = db->set_flags(db, dup_flags);
#if USE_TDB
if (r != 0 && dup_flags == DB_DUP) {
if (verbose) printf("%s:%d: WARNING: tokudb does not support DB_DUP\n", __FILE__, __LINE__);
r = db->close(db, 0); assert(r == 0);
return;
if (IS_TDB) {
if (r != 0 && dup_flags == DB_DUP) {
if (verbose) printf("%s:%d: WARNING: tokudb does not support DB_DUP\n", __FILE__, __LINE__);
r = db->close(db, 0); assert(r == 0);
return;
}
}
#endif
assert(r == 0);
u_int32_t flags; r = db->get_flags(db, &flags); assert(r == 0); assert(flags == dup_flags);
r = db->open(db, null_txn, fname, "main", DB_BTREE, DB_CREATE, 0666);
#if USE_TDB
if (r != 0 && dup_flags == DB_DUP) {
if (verbose) printf("%s:%d: WARNING: tokudb does not support DB_DUP\n", __FILE__, __LINE__);
r = db->close(db, 0); assert(r == 0);
return;
if (IS_TDB) {
if (r != 0 && dup_flags == DB_DUP) {
if (verbose) printf("%s:%d: WARNING: tokudb does not support DB_DUP\n", __FILE__, __LINE__);
r = db->close(db, 0); assert(r == 0);
return;
}
}
#endif
assert(r == 0);
r = db->close(db, 0); assert(r == 0);
@ -51,7 +52,7 @@ void test_dup_flags(u_int32_t dup_flags) {
r = db_create(&db, null_env, 0); assert(r == 0);
r = db->open(db, null_txn, fname, "main", DB_BTREE, 0, 0666);
if (r == 0 && verbose)
printf("%s:%d: WARNING:open ok:dup_mode:%d\n", __FILE__, __LINE__, dup_flags);
printf("%s:%d: WARNING:open ok:dup_mode:%u\n", __FILE__, __LINE__, dup_flags);
r = db->close(db, 0); assert(r == 0);
r = db_create(&db, null_env, 0); assert(r == 0);

28
src/tests/test_dup_insert.c
View file

@ -12,14 +12,16 @@
#include "test.h"
void db_put(DB *db, int k, int v) {
static 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), DB_YESOVERWRITE);
assert(r == 0);
}
void expect(DBC *cursor, int k, int v) {
static void
expect (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);
@ -29,7 +31,7 @@ void expect(DBC *cursor, int k, int v) {
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));
if (kk != k || vv != v) printf("expect key %u got %u - %u %u\n", htonl(k), htonl(kk), htonl(v), htonl(vv));
assert(kk == k);
assert(vv == v);
@ -42,7 +44,8 @@ static int mycmp(const void *a, const void *b) {
}
/* verify that key insertions are stored in insert order */
void test_insert(int n, int dup_mode) {
static void
test_insert (int n, int dup_mode) {
if (verbose) printf("test_insert:%d %d\n", n, dup_mode);
DB_ENV * const null_env = 0;
@ -138,7 +141,8 @@ void test_insert(int n, int dup_mode) {
}
/* verify dup keys are buffered in order in non-leaf nodes */
void test_nonleaf_insert(int n, int dup_mode) {
static void
test_nonleaf_insert (int n, int dup_mode) {
if (verbose) printf("test_nonleaf_insert:%d %d\n", n, dup_mode);
DB_ENV * const null_env = 0;
@ -260,14 +264,14 @@ int main(int argc, const char *argv[]) {
}
/* dup tests */
#if USE_TDB
// printf("%s:%d:WARNING:tokudb does not support DB_DUP\n", __FILE__, __LINE__);
#else
for (i = 1; i <= (1<<16); i *= 2) {
test_insert(i, DB_DUP);
test_nonleaf_insert(i, DB_DUP);
if (IS_TDB) {
// printf("%s:%d:WARNING:tokudb does not support DB_DUP\n", __FILE__, __LINE__);
} else {
for (i = 1; i <= (1<<16); i *= 2) {
test_insert(i, DB_DUP);
test_nonleaf_insert(i, DB_DUP);
}
}
#endif
/* dupsort tests */
for (i = 1; i <= (1<<16); i *= 2) {

50
src/tests/test_dup_next.c
View file

@ -15,52 +15,24 @@
#include "test.h"
int testlevel = 0;
static int testlevel = 0;
DBT *dbt_init_zero(DBT *dbt) {
static DBT *
dbt_init_zero (DBT *dbt) {
memset(dbt, 0, sizeof *dbt);
return dbt;
}
void db_put(DB *db, int k, int v) {
static 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), DB_YESOVERWRITE);
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_set(DBC *cursor, int k, int expectv) {
static void
expect_cursor_set (DBC *cursor, int k, int expectv) {
DBT key, val;
int r = cursor->c_get(cursor, dbt_init(&key, &k, sizeof k), dbt_init_zero(&val), DB_SET);
assert(r == 0);
@ -70,7 +42,8 @@ void expect_cursor_set(DBC *cursor, int k, int expectv) {
assert(expectv == vv);
}
int expect_cursor_get(DBC *cursor, int expectk, int expectv, int op) {
static int
expect_cursor_get (DBC *cursor, int expectk, int expectv, int op) {
DBT key, val;
int r = cursor->c_get(cursor, dbt_init_zero(&key), dbt_init_zero(&val), op);
if (r == 0) {
@ -80,14 +53,15 @@ int expect_cursor_get(DBC *cursor, int expectk, int expectv, int op) {
assert(val.size == sizeof expectv);
int vv;
memcpy(&vv, val.data, val.size);
if (kk != expectk || vv != expectv) printf("expect key %d got %d - %d %d\n", htonl(expectk), htonl(kk), htonl(expectv), htonl(vv));
if (kk != expectk || vv != expectv) printf("expect key %u got %u - %u %u\n", htonl(expectk), htonl(kk), htonl(expectv), htonl(vv));
assert(kk == expectk);
assert(vv == expectv);
}
return r;
}
void test_dup_next(int n, int dup_mode) {
static void
test_dup_next (int n, int dup_mode) {
if (verbose) printf("test_dup_next:%d %d\n", n, dup_mode);
DB_ENV * const null_env = 0;

56
src/tests/test_dup_search.c
View file

@ -14,33 +14,24 @@
void db_put(DB *db, int k, int v) {
static 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), DB_YESOVERWRITE);
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) {
static 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) {
static 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);
@ -52,7 +43,8 @@ void expect_db_get(DB *db, int k, int v) {
free(val.data);
}
void expect_cursor_get(DBC *cursor, int k, int v) {
static 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);
@ -62,7 +54,7 @@ void expect_cursor_get(DBC *cursor, int k, int v) {
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));
if (kk != k || vv != v) printf("expect key %u got %u - %u %u\n", htonl(k), htonl(kk), htonl(v), htonl(vv));
assert(kk == k);
assert(vv == v);
@ -71,7 +63,8 @@ void expect_cursor_get(DBC *cursor, int k, int v) {
}
/* insert, close, delete, insert, search */
void test_icdi_search(int n, int dup_mode) {
static 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;
@ -141,7 +134,8 @@ void test_icdi_search(int n, int dup_mode) {
}
/* insert, close, insert, search */
void test_ici_search(int n, int dup_mode) {
static void
test_ici_search (int n, int dup_mode) {
if (verbose) printf("test_ici_search:%d %d\n", n, dup_mode);
DB_ENV * const null_env = 0;
@ -209,7 +203,8 @@ void test_ici_search(int n, int dup_mode) {
}
/* insert 0, insert 1, close, insert 0, search 0 */
void test_i0i1ci0_search(int n, int dup_mode) {
static void
test_i0i1ci0_search (int n, int dup_mode) {
if (verbose) printf("test_i0i1ci0_search:%d %d\n", n, dup_mode);
DB_ENV * const null_env = 0;
@ -265,7 +260,8 @@ void test_i0i1ci0_search(int n, int dup_mode) {
}
/* insert dup keys with data descending from n to 1 */
void test_reverse_search(int n, int dup_mode) {
static void
test_reverse_search (int n, int dup_mode) {
if (verbose) printf("test_reverse_search:%d %d\n", n, dup_mode);
DB_ENV * const null_env = 0;
@ -337,15 +333,15 @@ int main(int argc, const char *argv[]) {
limit = 1<<16;
/* dup search */
#if USE_TDB
if (verbose) printf("%s:%d:WARNING:tokudb does not support DB_DUP\n", __FILE__, __LINE__);
#else
for (i = 1; i <= limit; i *= 2) {
test_ici_search(i, DB_DUP);
test_icdi_search(i, DB_DUP);
test_i0i1ci0_search(i, DB_DUP);
if (IS_TDB) {
if (verbose) printf("%s:%d:WARNING:tokudb does not support DB_DUP\n", __FILE__, __LINE__);
} else {
for (i = 1; i <= limit; i *= 2) {
test_ici_search(i, DB_DUP);
test_icdi_search(i, DB_DUP);
test_i0i1ci0_search(i, DB_DUP);
}
}
#endif
/* dupsort search */
for (i = 1; i <= limit; i *= 2) {
@ -357,7 +353,7 @@ int main(int argc, const char *argv[]) {
/* insert data in descending order */
for (i = 1; i <= limit; i *= 2) {
test_reverse_search(i, 0);
#if USE_BDB
#ifdef USE_BDB
test_reverse_search(i, DB_DUP);
#endif
test_reverse_search(i, DB_DUP + DB_DUPSORT);

3
src/tests/test_dupsort_del.c
View file

@ -66,7 +66,8 @@ static void lookup (int i, int expect, int expectj) {
}
}
void test_dupsort_del (void) {
static void
test_dupsort_del (void) {
int r;
system("rm -rf " ENVDIR);
r=mkdir(ENVDIR, 0777); assert(r==0);

3
src/tests/test_dupsort_del_checksum.c
View file

@ -68,7 +68,8 @@ static void lookup (int i, int expect, int expectj) {
}
}
void test_abort3 (void) {
static void
test_abort3 (void) {
int r;
system("rm -rf " ENVDIR);
r=mkdir(ENVDIR, 0777); assert(r==0);

12
src/tests/test_dupsort_delete.c
View file

@ -12,21 +12,24 @@
#include "test.h"
void db_put(DB *db, int k, int v) {
static 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), DB_YESOVERWRITE);
assert(r == 0);
}
void db_del(DB *db, int k) {
static 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), DB_DELETE_ANY);
assert(r == 0);
}
void expect_cursor_get(DBC *cursor, int op, int expectr) {
static void
expect_cursor_get (DBC *cursor, int op, int expectr) {
DBT key, val;
int r = cursor->c_get(cursor, dbt_init_malloc(&key), dbt_init_malloc(&val), op);
assert(r == expectr);
@ -36,7 +39,8 @@ static int mycmp(const void *a, const void *b) {
return memcmp(a, b, sizeof (int));
}
void test_dupsort_delete(int n) {
static void
test_dupsort_delete (int n) {
if (verbose) printf("test_dupsort_delete:%d\n", n);
DB_ENV * const null_env = 0;

54
src/tests/test_dupsort_get.c
View file

@ -14,33 +14,24 @@
void db_put(DB *db, int k, int v) {
static 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), DB_YESOVERWRITE);
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) {
static 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) {
static 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);
@ -52,38 +43,16 @@ void expect_db_get(DB *db, int k, int 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) {
static void
expect_cursor_set (DBC *cursor, int k) {
DBT key, val;
int r = cursor->c_get(cursor, dbt_init(&key, &k, sizeof k), dbt_init_malloc(&val), DB_SET);
assert(r == 0);
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) {
static 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);
@ -94,7 +63,8 @@ void expect_cursor_get_current(DBC *cursor, int k, int v) {
}
void test_dupsort_get(int n, int dup_mode) {
static void
test_dupsort_get (int n, int dup_mode) {
if (verbose) printf("test_dupsort_get:%d %d\n", n, dup_mode);
DB_ENV * const null_env = 0;

44
src/tests/test_dupsort_get_both.c
View file

@ -12,35 +12,24 @@
#include "test.h"
void db_put(DB *db, int k, int v) {
static 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), DB_YESOVERWRITE);
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) {
static 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) {
static 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);
@ -52,7 +41,8 @@ void expect_db_get(DB *db, int k, int v) {
free(val.data);
}
void expect_cursor_get(DBC *cursor, int k, int v) {
static 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);
@ -62,7 +52,7 @@ void expect_cursor_get(DBC *cursor, int k, int v) {
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));
if (kk != k || vv != v) printf("expect key %u got %u - %u %u\n", htonl(k), htonl(kk), htonl(v), htonl(vv));
assert(kk == k);
assert(vv == v);
@ -70,20 +60,15 @@ void expect_cursor_get(DBC *cursor, int k, int v) {
free(val.data);
}
void expect_cursor_set(DBC *cursor, int k) {
DBT key, val;
int r = cursor->c_get(cursor, dbt_init(&key, &k, sizeof k), dbt_init_malloc(&val), DB_SET);
assert(r == 0);
free(val.data);
}
void expect_cursor_get_both(DBC *cursor, int k, int v) {
static 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) {
static 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);
@ -95,7 +80,8 @@ void expect_cursor_get_current(DBC *cursor, int k, int v) {
/* insert, close, delete, insert, search */
void test_icdi_search(int n, int dup_mode) {
static 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;

42
src/tests/test_dupsort_get_both_range.c
View file

@ -12,33 +12,24 @@
#include "test.h"
void db_put(DB *db, int k, int v) {
static 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), DB_YESOVERWRITE);
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) {
static 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) {
static 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);
@ -50,7 +41,8 @@ void expect_db_get(DB *db, int k, int v) {
free(val.data);
}
void expect_cursor_get(DBC *cursor, int k, int v) {
static 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);
@ -60,7 +52,7 @@ void expect_cursor_get(DBC *cursor, int k, int v) {
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", ntohl(k), ntohl(kk), ntohl(v), ntohl(vv));
if (kk != k || vv != v) printf("expect key %u got %u - %u %u\n", ntohl(k), ntohl(kk), ntohl(v), ntohl(vv));
assert(kk == k);
assert(vv == v);
@ -68,20 +60,15 @@ void expect_cursor_get(DBC *cursor, int k, int v) {
free(val.data);
}
void expect_cursor_set(DBC *cursor, int k) {
DBT key, val;
int r = cursor->c_get(cursor, dbt_init(&key, &k, sizeof k), dbt_init_malloc(&val), DB_SET);
assert(r == 0);
free(val.data);
}
void expect_cursor_get_both_range(DBC *cursor, int k, int v, int expectr) {
static void
expect_cursor_get_both_range (DBC *cursor, int k, int v, int expectr) {
DBT key, val;
int r = cursor->c_get(cursor, dbt_init(&key, &k, sizeof k), dbt_init(&val, &v, sizeof v), DB_GET_BOTH_RANGE);
assert(r == expectr);
}
void expect_cursor_get_current(DBC *cursor, int k, int v) {
static 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);
@ -93,7 +80,8 @@ void expect_cursor_get_current(DBC *cursor, int k, int v) {
/* insert, close, delete, insert, search */
void test_icdi_search(int n, int dup_mode) {
static 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;

43
src/tests/test_dupsort_set.c
View file

@ -12,35 +12,24 @@
#include "test.h"
void db_put(DB *db, int k, int v) {
static 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), DB_YESOVERWRITE);
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) {
static 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) {
static 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);
@ -52,7 +41,8 @@ void expect_db_get(DB *db, int k, int v) {
free(val.data);
}
void expect_cursor_get(DBC *cursor, int k, int v) {
static 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);
@ -62,7 +52,7 @@ void expect_cursor_get(DBC *cursor, int k, int v) {
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));
if (kk != k || vv != v) printf("expect key %u got %u - %u %u\n", htonl(k), htonl(kk), htonl(v), htonl(vv));
assert(kk == k);
assert(vv == v);
@ -70,20 +60,16 @@ void expect_cursor_get(DBC *cursor, int k, int v) {
free(val.data);
}
void expect_cursor_set(DBC *cursor, int k) {
static void
expect_cursor_set (DBC *cursor, int k) {
DBT key, val;
int r = cursor->c_get(cursor, dbt_init(&key, &k, sizeof k), dbt_init_malloc(&val), DB_SET);
assert(r == 0);
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) {
static 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);
@ -95,7 +81,8 @@ void expect_cursor_get_current(DBC *cursor, int k, int v) {
/* insert, close, delete, insert, search */
void test_icdi_search(int n, int dup_mode) {
static 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;

48
src/tests/test_dupsort_set_range.c
View file

@ -19,33 +19,24 @@
#define DB_YESOVERWRITE 0
#endif
void db_put(DB *db, int k, int v) {
static 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), DB_YESOVERWRITE);
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) {
static 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), DB_DELETE_ANY);
assert(r == 0);
}
void expect_db_get(DB *db, int k, int v) {
static 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);
@ -57,7 +48,8 @@ void expect_db_get(DB *db, int k, int v) {
free(val.data);
}
void expect_cursor_get(DBC *cursor, int k, int v) {
static 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);
@ -67,7 +59,7 @@ void expect_cursor_get(DBC *cursor, int k, int v) {
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));
if (kk != k || vv != v) printf("expect key %u got %u - %u %u\n", htonl(k), htonl(kk), htonl(v), htonl(vv));
assert(kk == k);
assert(vv == v);
@ -75,27 +67,16 @@ void expect_cursor_get(DBC *cursor, int k, int v) {
free(val.data);
}
void expect_cursor_set(DBC *cursor, int k) {
DBT key, val;
int r = cursor->c_get(cursor, dbt_init(&key, &k, sizeof k), dbt_init_malloc(&val), DB_SET);
assert(r == 0);
free(val.data);
}
void expect_cursor_set_range(DBC *cursor, int k) {
static void
expect_cursor_set_range (DBC *cursor, int k) {
DBT key, val;
int r = cursor->c_get(cursor, dbt_init(&key, &k, sizeof k), dbt_init_malloc(&val), DB_SET_RANGE);
assert(r == 0);
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) {
static 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);
@ -107,7 +88,8 @@ void expect_cursor_get_current(DBC *cursor, int k, int v) {
/* insert, close, delete, insert, search */
void test_icdi_search(int n, int dup_mode) {
static 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;

3
src/tests/test_env_open_flags.c
View file

@ -13,7 +13,8 @@
#include "test.h"
void test_env_open_flags(int env_open_flags, int expectr) {
static void
test_env_open_flags (int env_open_flags, int expectr) {
if (verbose) printf("test_env_open_flags:%d\n", env_open_flags);
DB_ENV *env;

3
src/tests/test_error.c
View file

@ -8,7 +8,8 @@
char const* expect_errpfx;
int n_handle_error=0;
void handle_error (const DB_ENV *UU(dbenv), const char *errpfx, const char *UU(msg)) {
static void
handle_error (const DB_ENV *UU(dbenv), const char *errpfx, const char *UU(msg)) {
assert(errpfx==expect_errpfx);
n_handle_error++;
}

3
src/tests/test_forkjoin.c
View file

@ -2,7 +2,8 @@
#include <assert.h>
#include <pthread.h>
void *f(void *arg) {
static void *
f (void *arg) {
//pthread_exit(arg); // pthread_exit has a memoryh leak.
return arg;
}

81
src/tests/test_get_both_range.c
View file

@ -12,7 +12,8 @@
#include "test.h"
DBT *dbt_init_user(DBT *d, void *uptr, int ulen) {
static DBT *
dbt_init_user (DBT *d, void *uptr, int ulen) {
memset(d, 0, sizeof *d);
d->data = uptr;
d->ulen = ulen;
@ -20,87 +21,17 @@ DBT *dbt_init_user(DBT *d, void *uptr, int ulen) {
return d;
}
void db_put(DB *db, int k, int v) {
static 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), DB_YESOVERWRITE);
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);
free(val.data);
}
static char annotated_envdir[]= ENVDIR " ";
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", ntohl(k), ntohl(kk), ntohl(v), ntohl(vv));
assert(kk == k);
assert(vv == v);
free(key.data);
free(val.data);
}
void expect_cursor_set(DBC *cursor, int k) {
DBT key, val;
int r = cursor->c_get(cursor, dbt_init(&key, &k, sizeof k), dbt_init_malloc(&val), DB_SET);
assert(r == 0);
free(val.data);
}
void expect_cursor_get_both_range(DBC *cursor, int k, int v, int expectr) {
DBT key, val;
int r = cursor->c_get(cursor, dbt_init(&key, &k, sizeof k), dbt_init(&val, &v, sizeof v), DB_GET_BOTH_RANGE);
assert(r == expectr);
}
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);
}
char annotated_envdir[]= ENVDIR " ";
void test_get_both(int n, int dup_mode, int op) {
static void test_get_both(int n, int dup_mode, int op) {
if (verbose) printf("test_get_both_range:%d %d %d\n", n, dup_mode, op);
DB_ENV * const null_env = 0;

3
src/tests/test_get_zeroed_dbt.c
View file

@ -9,7 +9,8 @@
#include "test.h"
void test_get (int dup_mode) {
static void
test_get (int dup_mode) {
DB_ENV * const null_env = 0;
DB_TXN * const null_txn = 0;
DB *db;

26
src/tests/test_groupcommit_count.c
View file

@ -15,7 +15,7 @@ DB *db;
#define NITER 100
void *start_a_thread (void *i_p) {
static void *start_a_thread (void *i_p) {
int *which_thread_p = i_p;
int i,r;
for (i=0; i<NITER; i++) {
@ -33,7 +33,8 @@ void *start_a_thread (void *i_p) {
return 0;
}
void test_groupcommit (int nthreads) {
static void
test_groupcommit (int nthreads) {
int r;
DB_TXN *tid;
@ -64,25 +65,30 @@ void test_groupcommit (int nthreads) {
// Also, it doesn't happen every time, making helgrind unsuitable for regression tests.
// So we must put locks around things that are properly serialized anyway.
int fsync_count_maybe_lockprotected=0;
void inc_fsync_count(void) {
static int fsync_count_maybe_lockprotected=0;
static void
inc_fsync_count (void) {
fsync_count_maybe_lockprotected++;
}
int get_fsync_count(void) {
static int
get_fsync_count (void) {
int result=fsync_count_maybe_lockprotected;
return result;
}
int do_fsync (int fd) {
static int
do_fsync (int fd) {
inc_fsync_count();
return fsync(fd);
}
const char *progname;
struct timeval prevtime;
int prev_count;
void printtdiff (char *str) {
static const char *progname;
static struct timeval prevtime;
static int prev_count;
static void
printtdiff (char *str) {
struct timeval thistime;
gettimeofday(&thistime, 0);
double tdiff = thistime.tv_sec-prevtime.tv_sec+1e-6*(thistime.tv_usec-prevtime.tv_usec);

12
src/tests/test_groupcommit_perf.c
View file

@ -14,7 +14,8 @@ DB *db;
#define NITER 100
void *start_a_thread (void *i_p) {
static void *
start_a_thread (void *i_p) {
int *which_thread_p = i_p;
int i,r;
for (i=0; i<NITER; i++) {
@ -32,7 +33,8 @@ void *start_a_thread (void *i_p) {
return 0;
}
void test_groupcommit (int nthreads) {
static void
test_groupcommit (int nthreads) {
int r;
DB_TXN *tid;
@ -82,8 +84,10 @@ void test_groupcommit (int nthreads) {
}
struct timeval prevtime;
void printtdiff (char *str) {
static struct timeval prevtime;
static void
printtdiff (char *str) {
struct timeval thistime;
gettimeofday(&thistime, 0);
if (verbose) printf("%10.6f %s\n", thistime.tv_sec-prevtime.tv_sec+1e-6*(thistime.tv_usec-prevtime.tv_usec), str);

8
src/tests/test_hsoc.c
View file

@ -12,11 +12,12 @@
#include "test.h"
#if USE_BDB
#ifdef USE_BDB
#define DB_YESOVERWRITE 0
#endif
int db_put(DB *db, DB_TXN *txn, int k, int v) {
static int
db_put (DB *db, DB_TXN *txn, int k, int v) {
DBT key, val;
int r = db->put(db, txn, dbt_init(&key, &k, sizeof k), dbt_init(&val, &v, sizeof v), DB_YESOVERWRITE);
return r;
@ -34,7 +35,8 @@ int db_put(DB *db, DB_TXN *txn, int k, int v) {
the magic number where found via experimentation */
void test_hsoc(int pagesize, int dup_mode) {
static void
test_hsoc (int pagesize, int dup_mode) {
if (verbose) printf("test_hsoc:%d %d\n", pagesize, dup_mode);
int npp = pagesize / 16;

5
src/tests/test_insert_cursor_delete_insert.c
View file

@ -12,9 +12,8 @@
#include "test.h"
void test_insert_delete_insert(int dup_mode) {
static void
test_insert_delete_insert (int dup_mode) {
if (verbose) printf("test_insert_delete_insert:%d\n", dup_mode);
DB_ENV * const null_env = 0;

5
src/tests/test_insert_memleak.c
View file

@ -12,9 +12,8 @@
#include "test.h"
void test_insert(int n, int dup_mode) {
static void
test_insert (int n, int dup_mode) {
if (verbose) printf("test_insert:%d %d\n", n, dup_mode);
DB_ENV * const null_env = 0;

10
src/tests/test_kv_limits.c
View file

@ -15,7 +15,8 @@
u_int64_t lorange = 0;
u_int64_t hirange = 1<<24;
void test_key_size_limit(int dup_mode) {
static void
test_key_size_limit (int dup_mode) {
if (verbose > 1) printf("%s:%d\n", __FUNCTION__, dup_mode);
DB_ENV * const null_env = 0;
@ -64,13 +65,14 @@ void test_key_size_limit(int dup_mode) {
free(k);
free(v);
assert(bigest > 0);
if (verbose && bigest >= 0) printf("%s bigest %d\n", __FUNCTION__, bigest);
if (verbose) printf("%s bigest %u\n", __FUNCTION__, bigest);
r = db->close(db, 0);
assert(r == 0);
}
void test_data_size_limit(int dup_mode) {
static void
test_data_size_limit (int dup_mode) {
if (verbose > 1) printf("%s:%d\n", __FUNCTION__, dup_mode);
DB_ENV * const null_env = 0;
@ -118,7 +120,7 @@ void test_data_size_limit(int dup_mode) {
}
free(k);
free(v);
if (verbose && bigest > 0) printf("%s bigest %d\n", __FUNCTION__, bigest);
if (verbose && bigest > 0) printf("%s bigest %u\n", __FUNCTION__, bigest);
r = db->close(db, 0);
assert(r == 0);

18
src/tests/test_log6a_abort.c
View file

@ -23,19 +23,21 @@
// How many iterations are we going to do insertions and deletions. This is a bound to the number of distinct keys in the DB.
#define N 1000
int n_keys_mentioned=0;
int random_keys_mentioned[N];
static int n_keys_mentioned=0;
static int random_keys_mentioned[N];
DB *pending_i, *pending_d, *committed;
static DB *pending_i, *pending_d, *committed;
// Keep track of what's in the committed database separately
struct pair {int x,y;};
void insert_in_mem (int x, int y, int *count, struct pair *pairs) {
static void
insert_in_mem (int x, int y, int *count, struct pair *pairs) {
assert(*count<N);
pairs[(*count)++]=(struct pair){x,y};
}
void delete_in_mem (int x, int *count, struct pair *pairs) {
static void
delete_in_mem (int x, int *count, struct pair *pairs) {
int i;
for (i=0; i<*count; i++) {
if (pairs[i].x==x) {
@ -48,7 +50,8 @@ void delete_in_mem (int x, int *count, struct pair *pairs) {
static int com_count=0, pend_count=0, peni_count=0;
static struct pair com_data[N], pend_data[N], peni_data[N];
void insert_pending(int key, int val, DB_TXN *bookx) {
static void
insert_pending (int key, int val, DB_TXN *bookx) {
DBT keyd,datad;
//printf("IP %u,%u\n", key,val);
@ -182,7 +185,8 @@ static void abort_items (DB_ENV *env) {
r=txn->commit(txn, 0); assert(r==0);
}
int compare_pairs (const void *a, const void *b) {
static int
compare_pairs (const void *a, const void *b) {
return memcmp(a,b,4);
}

3
src/tests/test_logflush.c
View file

@ -8,7 +8,8 @@
#include "test.h"
// Return the offset
int grep_for_in_logs(const char *str) {
static int
grep_for_in_logs (const char *str) {
#ifdef TOKUDB
#define lname ENVDIR "//log000000000000.tokulog"
#else

6
src/tests/test_logmax.c
View file

@ -8,7 +8,8 @@
#include <sys/stat.h>
#include "test.h"
void check_logmax (int max) {
static void
check_logmax (int max) {
int any_too_big=0;
DIR *dir = opendir(ENVDIR);
struct dirent *ent;
@ -31,7 +32,8 @@ void check_logmax (int max) {
assert(r==0);
}
void test_logmax (int logmax) {
static void
test_logmax (int logmax) {
int r;
DB_ENV *env;
DB *db;

3
src/tests/test_mostly_seq.c
View file

@ -7,7 +7,8 @@
#include <db.h>
#include "test.h"
void seqinsert(int n, float p) {
static void
seqinsert (int n, float p) {
if (verbose) printf("%s %d %f\n", __FUNCTION__, n, p);
system("rm -rf " ENVDIR);

3
src/tests/test_nested.c
View file

@ -52,7 +52,8 @@ static void lookup (int i, DB_TXN *x, int expect) {
static DB_TXN *txn, *txn2;
void test_nested (void) {
static void
test_nested (void) {
int r;
system("rm -rf " ENVDIR);
r=mkdir(ENVDIR, 0777); assert(r==0);

41
src/tests/test_nodup_set.c
View file

@ -14,33 +14,24 @@
void db_put(DB *db, int k, int v) {
static 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) {
static 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) {
static 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);
@ -52,7 +43,8 @@ void expect_db_get(DB *db, int k, int v) {
free(val.data);
}
void expect_cursor_get(DBC *cursor, int k, int v) {
static 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);
@ -62,7 +54,7 @@ void expect_cursor_get(DBC *cursor, int k, int v) {
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));
if (kk != k || vv != v) printf("expect key %u got %u - %u %u\n", htonl(k), htonl(kk), htonl(v), htonl(vv));
assert(kk == k);
assert(vv == v);
@ -70,20 +62,16 @@ void expect_cursor_get(DBC *cursor, int k, int v) {
free(val.data);
}
void expect_cursor_set(DBC *cursor, int k, int expectr) {
static 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) {
static 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);
@ -95,7 +83,8 @@ void expect_cursor_get_current(DBC *cursor, int k, int v) {
/* insert, close, delete, insert, search */
void test_icdi_search(int n, int dup_mode) {
static 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;

5
src/tests/test_rand_insert.c
View file

@ -12,9 +12,8 @@
#include "test.h"
void test_rand_insert(int n, int dup_mode) {
static void
test_rand_insert (int n, int dup_mode) {
if (verbose) printf("test_rand_insert:%d %d\n", n, dup_mode);
DB_ENV * const null_env = 0;

16
src/tests/test_reverse_compare_fun.c
View file

@ -16,9 +16,8 @@
#include "test.h"
int keycompare (const void *key1, unsigned int key1len, const void *key2, unsigned int key2len) {
static int
keycompare (const void *key1, unsigned int key1len, const void *key2, unsigned int key2len) {
if (key1len==key2len) {
return memcmp(key1,key2,key1len);
} else if (key1len<key2len) {
@ -30,11 +29,13 @@ int keycompare (const void *key1, unsigned int key1len, const void *key2, unsign
}
}
int reverse_compare(DB *db __attribute__((__unused__)), const DBT *a, const DBT*b) {
static int
reverse_compare (DB *db __attribute__((__unused__)), const DBT *a, const DBT*b) {
return -keycompare(a->data, a->size, b->data, b->size);
}
void expect(DBC *cursor, int k, int v) {
static void
expect (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);
CKERR(r);
@ -44,7 +45,7 @@ void expect(DBC *cursor, int k, int v) {
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));
if (kk != k || vv != v) printf("expect key %u got %u - %u %u\n", htonl(k), htonl(kk), htonl(v), htonl(vv));
assert(kk == k);
assert(vv == v);
@ -52,7 +53,8 @@ void expect(DBC *cursor, int k, int v) {
free(val.data);
}
void test_reverse_compare(int n, int dup_flags) {
static void
test_reverse_compare (int n, int dup_flags) {
if (verbose) printf("test_reverse_compare:%d %d\n", n, dup_flags);
DB_ENV * const null_env = 0;

12
src/tests/test_set_lk_max_locks.c
View file

@ -59,7 +59,7 @@ static void make_db (int n_locks) {
char hello[30], there[datasize+30];
DBT key,data;
snprintf(hello, sizeof(hello), "hello%09d", 2*i);
snprintf(there, sizeof(there), "there%d%0*d", 2*i, datasize, 2*i); // For BDB this is chosen so that different locks are on different pages
snprintf(there, sizeof(there), "there%d%0*d", 2*i, (int)datasize, 2*i); // For BDB this is chosen so that different locks are on different pages
memset(&key, 0, sizeof(key));
memset(&data, 0, sizeof(data));
key.data = hello; key.size=strlen(hello)+1;
@ -88,7 +88,7 @@ static void make_db (int n_locks) {
DBT key,data;
int num = 16*i+8*j+1;
snprintf(hello, sizeof(hello), "hello%09d", num);
snprintf(there, sizeof(there), "there%d%*d", num, datasize, num); // For BDB this is chosen so that different locks are on different pages
snprintf(there, sizeof(there), "there%d%*d", num, (int)datasize, num); // For BDB this is chosen so that different locks are on different pages
memset(&key, 0, sizeof(key));
memset(&data, 0, sizeof(data));
//printf("Writing %s in %d\n", hello, j);
@ -118,8 +118,10 @@ static void make_db (int n_locks) {
int main (int argc __attribute__((__unused__)), char *argv[] __attribute__((__unused__))) {
make_db(-1);
make_db(100); return 0;
make_db(1000);
make_db(2000);
make_db(100);
if (0) {
make_db(1000);
make_db(2000);
}
return 0;
}

12
src/tests/test_thread_flags.c
View file

@ -11,13 +11,15 @@
const char *dbfile = ENVDIR "/" "test.db";
const char *dbname = 0;
int db_put(DB *db, int k, int v) {
static int
db_put (DB *db, int k, int v) {
DBT key, val;
int r = db->put(db, 0, dbt_init(&key, &k, sizeof k), dbt_init(&val, &v, sizeof v), 0);
return r;
}
int db_get(DB *db, int k, int expectv, int val_flags) {
static int
db_get (DB *db, int k, int expectv, int val_flags) {
int v;
DBT key, val;
memset(&val, 0, sizeof val); val.flags = val_flags;
@ -37,7 +39,8 @@ int db_get(DB *db, int k, int expectv, int val_flags) {
return r;
}
void test_db_create() {
static void
test_db_create (void) {
int r;
DB *db;
@ -51,7 +54,8 @@ void test_db_create() {
r = db->close(db, 0); assert(r == 0);
}
void test_db_thread() {
static void
test_db_thread (void) {
int r;
DB *db;

11
src/tests/test_thread_insert.c
View file

@ -27,13 +27,15 @@ struct db_inserter {
int do_exit;
};
int db_put(DB *db, my_t k, my_t v) {
static int
db_put (DB *db, my_t k, my_t v) {
DBT key, val;
int r = db->put(db, 0, dbt_init(&key, &k, sizeof k), dbt_init(&val, &v, sizeof v), DB_YESOVERWRITE);
return r;
}
void *do_inserts(void *arg) {
static void *
do_inserts (void *arg) {
struct db_inserter *mywork = (struct db_inserter *) arg;
if (verbose) printf("%lu:%u:do_inserts:start:%u-%u\n", (unsigned long)pthread_self(), getmyid(), mywork->startno, mywork->endno);
my_t i;
@ -47,7 +49,8 @@ void *do_inserts(void *arg) {
return 0;
}
int usage() {
static int
usage (void) {
fprintf(stderr, "test [-n NTUPLES] [-p NTHREADS]\n");
fprintf(stderr, "default NTUPLES=1000000\n");
fprintf(stderr, "default NTHREADS=2\n");
@ -108,7 +111,7 @@ int main(int argc, char *argv[]) {
work[i].endno = n;
}
if (verbose) printf("pid:%u\n", getpid());
if (verbose) printf("pid:%d\n", getpid());
for (i=1; i<nthreads; i++) {
r = pthread_create(&work[i].tid, 0, do_inserts, &work[i]); assert(r == 0);

32
src/tests/test_thread_secondary.c
View file

@ -11,7 +11,8 @@
// ENVDIR is defined in the Makefile
int dbtcmp(DBT *dbt1, DBT *dbt2) {
static int
dbtcmp (DBT *dbt1, DBT *dbt2) {
int r;
r = dbt1->size - dbt2->size; if (r) return r;
@ -24,15 +25,16 @@ struct student_record {
char first_name[15];
};
#define SPACES " "
DB *dbp;
DB *sdbp;
DB_TXN *const null_txn = 0;
DB_ENV *dbenv;
static DB *dbp;
static DB *sdbp;
static DB_TXN *const null_txn = 0;
static DB_ENV *dbenv;
/*
* getname -- extracts a secondary key (the last name) from a primary
* key/data pair
*/
int getname(DB *UU(secondary), const DBT *UU(pkey), const DBT *pdata, DBT *skey)
static int
getname(DB *UU(secondary), const DBT *UU(pkey), const DBT *pdata, DBT *skey)
{
/*
* Since the secondary key is a simple structure member of the
@ -49,7 +51,8 @@ int getname(DB *UU(secondary), const DBT *UU(pkey), const DBT *pdata, DBT *skey)
return (0);
}
void second_setup() {
static void
second_setup (void) {
int r;
/* Open/create primary */
@ -71,7 +74,8 @@ void second_setup() {
r = dbp->associate(dbp, NULL, sdbp, getname, 0); CKERR(r);
}
void setup_student(struct student_record *s) {
static void
setup_student (struct student_record *s) {
memset(s, 0, sizeof(struct student_record));
memcpy(&s->student_id, "WC42" SPACES, sizeof(s->student_id));
//Padded with enough spaces to fill out last/first name.
@ -79,7 +83,8 @@ void setup_student(struct student_record *s) {
memcpy(&s->first_name, "Winston" SPACES, sizeof(s->first_name));
}
void insert_test() {
static void
insert_test (void) {
struct student_record s;
DBT data;
DBT key;
@ -132,7 +137,8 @@ void insert_test() {
r = dbp->pget(dbp, null_txn, &key, &testkey, &data, 0); assert(r == EINVAL);
}
void delete_from_primary() {
static void
delete_from_primary (void) {
int r;
DBT key;
@ -142,7 +148,8 @@ void delete_from_primary() {
r = dbp->del(dbp, null_txn, &key, 0); CKERR(r);
}
void delete_from_secondary() {
static void
delete_from_secondary (void) {
int r;
DBT skey;
DBT data;
@ -158,7 +165,8 @@ void delete_from_secondary() {
r = sdbp->del(sdbp, null_txn, &skey, 0); CKERR(r);
}
void verify_gone() {
static void
verify_gone (void) {
int r;
DBT key;
DBT skey;

11
src/tests/test_thread_stack.c
View file

@ -31,13 +31,15 @@ struct db_inserter {
int do_exit;
};
int db_put(DB *db, my_t k, my_t v) {
static int
db_put (DB *db, my_t k, my_t v) {
DBT key, val;
int r = db->put(db, 0, dbt_init(&key, &k, sizeof k), dbt_init(&val, &v, sizeof v), DB_YESOVERWRITE);
return r;
}
void *do_inserts(void *arg) {
static void *
do_inserts (void *arg) {
struct db_inserter *mywork = (struct db_inserter *) arg;
if (verbose) printf("%lu:%u:do_inserts:start:%u-%u\n", (unsigned long)pthread_self(), getmyid(), mywork->startno, mywork->endno);
my_t i;
@ -50,7 +52,8 @@ void *do_inserts(void *arg) {
return 0;
}
int usage() {
static int
usage (void) {
fprintf(stderr, "test OPTIONS\n");
fprintf(stderr, "[-n NTUPLES] (default:1000000)\n");
fprintf(stderr, "[-p NTHREADS] (default:1)\n");
@ -132,7 +135,7 @@ int main(int argc, char *argv[]) {
work[i].endno = n;
}
if (verbose) printf("pid:%u\n", getpid());
if (verbose) printf("pid:%d\n", getpid());
for (i=all_on_threads ? 0 : 1; i<nthreads; i++) {
pthread_attr_t attr;

3
src/tests/test_truncate.c
View file

@ -10,7 +10,8 @@
#include <db.h>
#include "test.h"
int test_truncate(int n) {
static int
test_truncate (int n) {
int r;
DB_ENV *env;

3
src/tests/test_truncate_subdb.c
View file

@ -10,7 +10,8 @@
#include <db.h>
#include "test.h"
int test_truncate_subdb(int n) {
static int
test_truncate_subdb (int n) {
int r;
DB_ENV *env;

3
src/tests/test_truncate_txn_abort.c
View file

@ -10,7 +10,8 @@
#include <db.h>
#include "test.h"
int test_truncate_txn_abort(int n) {
static int
test_truncate_txn_abort (int n) {
int r;
DB_ENV *env;

3
src/tests/test_truncate_txn_commit.c
View file

@ -10,7 +10,8 @@
#include <db.h>
#include "test.h"
int test_truncate_txn_commit(int n) {
static int
test_truncate_txn_commit (int n) {
int r;
DB_ENV *env;

3
src/tests/test_truncate_txn_commit2.c
View file

@ -11,7 +11,8 @@
#include <db.h>
#include "test.h"
int test_truncate_txn_commit2(int n) {
static int
test_truncate_txn_commit2 (int n) {
int r;
DB_ENV *env;

3
src/tests/test_truncate_txn_commit3.c
View file

@ -11,7 +11,8 @@
#include <db.h>
#include "test.h"
int test_truncate_txn_commit2(int n) {
static int
test_truncate_txn_commit2 (int n) {
int r;
DB_ENV *env;

12
src/tests/test_truncate_with_cursors.c
View file

@ -11,10 +11,11 @@
#include <db.h>
#include "test.h"
#if USE_BDB
#ifdef USE_BDB
int test_errors = 0;
void test_errcall(const DB_ENV *emv, const char *errpfx, const char *msg) {
static void
test_errcall (const DB_ENV *env __attribute__((__unused__)), const char *errpfx, const char *msg) {
if (verbose) fprintf(stderr, "%s %s\n", errpfx, msg);
test_errors++;
}
@ -22,7 +23,8 @@ void test_errcall(const DB_ENV *emv, const char *errpfx, const char *msg) {
#endif
// try to truncate with cursors active
int test_truncate_with_cursors(int n) {
static int
test_truncate_with_cursors (int n) {
int r;
DB_ENV *env;
@ -64,13 +66,13 @@ int test_truncate_with_cursors(int n) {
assert(i == n);
// try to truncate with an active cursor
#if USE_BDB
#ifdef USE_BDB
db->set_errcall(db, test_errcall);
assert(test_errors == 0);
#endif
u_int32_t row_count = 0;
r = db->truncate(db, 0, &row_count, 0);
#if USE_BDB
#ifdef USE_BDB
// It looks like for 4.6 there's no error code, even though the documentation says "it is an error to truncate with open cursors".
// For 4.3 the error code is EINVAL
// I don't know where the boundary really is: Is it an error in 4.5 or 4.4?

3
src/tests/test_txn_abort5.c
View file

@ -7,7 +7,8 @@
#include <db.h>
#include "test.h"
void test_txn_abort(int n) {
static void
test_txn_abort (int n) {
if (verbose) printf("test_txn_abort:%d\n", n);
system("rm -rf " ENVDIR);

5
src/tests/test_txn_abort5a.c
View file

@ -9,7 +9,8 @@
#include "test.h"
void test_txn_abort(int n) {
static void
test_txn_abort (int n) {
if (verbose>1) printf("%s %s:%d\n", __FILE__, __FUNCTION__, n);
system("rm -rf " ENVDIR);
@ -65,7 +66,7 @@ void test_txn_abort(int n) {
for (i=0; 1; i++) {
r = cursor->c_get(cursor, &key, &val, DB_NEXT);
if (r!=0) break;
if (verbose>2) printf("%d present\n", ntohl(*(int*)key.data));
if (verbose>2) printf("%u present\n", ntohl(*(int*)key.data));
assert(key.size==4);
assert(ntohl(*(int*)key.data)==(unsigned int)(2*i));
}

9
src/tests/test_txn_abort6.c
View file

@ -9,7 +9,8 @@
#define N_TXNS 4
void test_txn_abort(int n, int which_guys_to_abort) {
static void
test_txn_abort (int n, int which_guys_to_abort) {
if (verbose>1) printf("test_txn_abort(%d,%x)\n", n, which_guys_to_abort);
system("rm -rf " ENVDIR);
@ -106,9 +107,9 @@ void test_txn_abort(int n, int which_guys_to_abort) {
int main(int argc, char *argv[]) {
int i,j;
#ifndef TOKUDB
return 0; // This test is inappropriate for BDB. It requires finer grained locking that BDB supports.
#endif
if (!IS_TDB) {
return 0; // This test is inappropriate for BDB. It requires finer grained locking that BDB supports.
}
for (i = 1; i < argc; i++) {
char *arg = argv[i];
if (strcmp(arg, "-v") == 0 || strcmp(arg, "--verbose") == 0) {

3
src/tests/test_txn_abort7.c
View file

@ -7,7 +7,8 @@
#include <db.h>
#include "test.h"
void test_abort_create(void) {
static void
test_abort_create (void) {
system("rm -rf " ENVDIR);
mkdir(ENVDIR, 0777);

3
src/tests/test_txn_abort8.c
View file

@ -9,7 +9,8 @@
#include "test.h"
//
void test_abort_close(void) {
static void
test_abort_close (void) {
#ifndef USE_TDB
#if DB_VERSION_MAJOR==4 && DB_VERSION_MINOR==3

3
src/tests/test_txn_abort9.c
View file

@ -9,7 +9,8 @@
#include "test.h"
//
void test_abort_close(void) {
static void
test_abort_close (void) {
#ifndef USE_TDB
#if DB_VERSION_MAJOR==4 && DB_VERSION_MINOR==3

3
src/tests/test_txn_close_open_commit.c
View file

@ -11,7 +11,8 @@
// Recreate a mysqld crash by closing and opening a db within a transaction.
// The crash occurs when writing a dirty cachetable pair, so we insert one
// row.
void test_txn_close_open_commit(void) {
static void
test_txn_close_open_commit (void) {
#ifndef USE_TDB
#if DB_VERSION_MAJOR==4 && DB_VERSION_MINOR==3

3
src/tests/test_txn_commit8.c
View file

@ -9,7 +9,8 @@
#include "test.h"
// like test_txn_abort8.c except commit
void test_abort_close(void) {
static void
test_abort_close (void) {
#ifndef USE_TDB
#if DB_VERSION_MAJOR==4 && DB_VERSION_MINOR==3

21
src/tests/test_txn_cursor_last.c
View file

@ -13,7 +13,8 @@
#include "test.h"
int db_put(DB *db, DB_TXN *txn, int k, int v) {
static int
db_put (DB *db, DB_TXN *txn, int k, int v) {
DBT key, val;
return db->put(db, txn, dbt_init(&key, &k, sizeof k), dbt_init(&val, &v, sizeof v), DB_NOOVERWRITE);
}
@ -32,7 +33,8 @@ static char *db_error(int error) {
}
/* t1 t2 l1 l2 p1 p2 c1 c2 */
void test_txn_cursor_last_1(int nrows) {
static void
test_txn_cursor_last_1 (int nrows) {
if (verbose) printf("test_txn_cursor_last_1:%d\n", nrows);
system("rm -rf " ENVDIR);
@ -115,7 +117,8 @@ void test_txn_cursor_last_1(int nrows) {
}
/* t1 t2 l1 p1 l2 c1 p2 c2 */
void test_txn_cursor_last_2(int nrows) {
static void
test_txn_cursor_last_2 (int nrows) {
if (verbose) printf("test_txn_cursor_last_2:%d\n", nrows);
system("rm -rf " ENVDIR);
@ -201,12 +204,12 @@ int main(int argc, const char *argv[]) {
parse_args(argc, argv);
#if USE_TDB
test_txn_cursor_last_1(0);
test_txn_cursor_last_1(1);
test_txn_cursor_last_2(0);
test_txn_cursor_last_2(1);
#endif
if (IS_TDB) {
test_txn_cursor_last_1(0);
test_txn_cursor_last_1(1);
test_txn_cursor_last_2(0);
test_txn_cursor_last_2(1);
}
return 0;
}

6
src/tests/test_txn_nested_abort.c
View file

@ -13,7 +13,8 @@
#include "test.h"
int db_put(DB *db, DB_TXN *txn, int k, int v) {
static int
db_put (DB *db, DB_TXN *txn, int k, int v) {
DBT key, val;
return db->put(db, txn, dbt_init(&key, &k, sizeof k), dbt_init(&val, &v, sizeof v), DB_NOOVERWRITE);
}
@ -31,7 +32,8 @@ static char *db_error(int error) {
}
}
void test_txn_nested(int do_commit) {
static void
test_txn_nested(int do_commit) {
if (verbose) printf("test_txn_nested:%d\n", do_commit);
system("rm -rf " ENVDIR);

3
src/tests/test_txn_nested_abort2.c
View file

@ -7,7 +7,8 @@
#include <db.h>
#include "test.h"
void test_txn_abort() {
static void
test_txn_abort (void) {
system("rm -rf " ENVDIR);
mkdir(ENVDIR, 0777);

3
src/tests/test_txn_nested_abort3.c
View file

@ -7,7 +7,8 @@
#include <db.h>
#include "test.h"
void test_txn_abort() {
static void
test_txn_abort (void) {
system("rm -rf " ENVDIR);
mkdir(ENVDIR, 0777);

26
src/tests/test_txn_nested_abort4.c
View file

@ -7,9 +7,11 @@
#include <db.h>
#include "test.h"
DB *db;
DB_ENV *env;
void setup_db(void) {
static DB *db;
static DB_ENV *env;
static void
setup_db (void) {
system("rm -rf " ENVDIR);
mkdir(ENVDIR, 0777);
@ -30,13 +32,17 @@ void setup_db(void) {
}
}
void close_db(void) {
#if 0
static void
close_db (void) {
int r;
r = db->close(db, 0); CKERR(r);
r = env->close(env, 0); CKERR(r);
}
#endif
void test_txn_abort(int insert, int secondnum) {
static void
test_txn_abort (int insert, int secondnum) {
setup_db();
DBT key, val;
@ -66,11 +72,11 @@ void test_txn_abort(int insert, int secondnum) {
}
else { // delete
r = db->del(db, child, dbt_init(&key, &i, sizeof i), DB_DELETE_ANY);
#if USE_TDB
CKERR(r);
#else
CKERR2(r, (secondnum==1 ? 0 : DB_NOTFOUND));
#endif
if (IS_TDB) {
CKERR(r);
} else {
CKERR2(r, (secondnum==1 ? 0 : DB_NOTFOUND));
}
}
r = child->commit(child,DB_TXN_NOSYNC);
child = NULL;

8
src/tests/test_txn_recover3.c
View file

@ -13,12 +13,8 @@
#include "test.h"
int db_put(DB *db, DB_TXN *txn, int k, int v) {
DBT key, val;
return db->put(db, txn, dbt_init(&key, &k, sizeof k), dbt_init(&val, &v, sizeof v), DB_NOOVERWRITE);
}
void test_txn_recover3(int nrows) {
static void
test_txn_recover3 (int nrows) {
if (verbose) printf("test_txn_recover1:%d\n", nrows);
system("rm -rf " ENVDIR);

14
src/tests/test_unused_memory_crash.c
View file

@ -12,9 +12,8 @@
#include "test.h"
void expect_cursor_get(DBC *cursor, int k, int v, int op) {
static void
expect_cursor_get (DBC *cursor, int k, int v, int op) {
int kk, vv;
DBT key, val;
int r = cursor->c_get(cursor, dbt_init_malloc(&key), dbt_init_malloc(&val), op);
@ -23,7 +22,8 @@ void expect_cursor_get(DBC *cursor, int k, int v, int op) {
assert(val.size == sizeof vv); memcpy(&vv, val.data, val.size); assert(vv == v); free(val.data);
}
DBC *new_cursor(DB *db, int k, int v, int op) {
static DBC *
new_cursor (DB *db, int k, int v, int op) {
DBC *cursor;
int r;
r = db->cursor(db, 0, &cursor, 0); assert(r == 0);
@ -31,13 +31,15 @@ DBC *new_cursor(DB *db, int k, int v, int op) {
return cursor;
}
int db_put(DB *db, int k, int v) {
static int
db_put (DB *db, int k, int v) {
DBT key, val;
int r = db->put(db, 0, dbt_init(&key, &k, sizeof k), dbt_init(&val, &v, sizeof v), 0);
return r;
}
void test_cursor_nonleaf_expand(int n, int reverse) {
static void
test_cursor_nonleaf_expand (int n, int reverse) {
if (verbose) printf("test_cursor_nonleaf_expand:%d %d\n", n, reverse);
DB_ENV * const null_env = 0;

3
src/tests/test_weakxaction.c
View file

@ -10,7 +10,8 @@
#include <sys/stat.h>
#include "test.h"
void test_autotxn(u_int32_t env_flags, u_int32_t db_flags) {
static void
test_autotxn (u_int32_t env_flags, u_int32_t db_flags) {
DB_ENV *env;
DB *db;
int r;