bool close()
{
if (_db_handle == NULL)
{
return true;
}
sqlite3_finalize(_statement);
_code = close_db_handle();
_statement = NULL;
_db_handle = NULL;
return _code == SQLITE_OK;
}
int TestSequencePreOpenSetterAndGetter(CuTest *ct) {
DB_ENV *dbenv;
DB *dbp;
DB_SEQUENCE *seq;
u_int32_t seq_flags;
CuAssert(ct, "db_env_create", create_dbenv_handle(&dbenv) == 0);
CuAssert(ct, "dbenv->open", dbenv->open(dbenv,
TEST_ENV, DB_CREATE | DB_INIT_MPOOL, 0644) == 0);
CuAssert(ct, "db_create", create_db_handle(&dbp, dbenv) == 0);
CuAssert(ct, "dbp->open", dbp->open(dbp,
NULL, "seq.db", NULL, DB_BTREE, DB_CREATE, 0644) == 0);
CuAssert(ct, "db_sequence_create",
create_seq_handle(&seq, dbp) == 0);
/* Test DB_SEQUENCE->set_cachesize(), DB_SEQUENCE->get_cachesize(). */
CHECK_1_DIGIT_VALUE(seq, set_cachesize, get_cachesize,
u_int32_t, rand());
/* Test DB_SEQUENCE->set_flags(), DB_SEQUENCE->get_flags(). */
seq_flags = 0;
CHECK_1_DIGIT_VALUE(seq, set_flags, get_flags,
u_int32_t, DB_SEQ_DEC | DB_SEQ_WRAP);
/* We make sure the DB_SEQ_DEC is cleared if we set DB_SEQ_INC. */
CuAssert(ct, "seq->set_flags", seq->set_flags(seq, DB_SEQ_INC) == 0);
CuAssert(ct, "seq->get_flags", seq->get_flags(seq, &seq_flags) == 0);
CuAssert(ct, "check seq flags",
seq_flags == (DB_SEQ_INC | DB_SEQ_WRAP));
/*
* Test DB_SEQUENCE->set_range(), DB_SEQUENCE->get_range().
* The max should be bigger than min.
*/
CHECK_2_DIGIT_VALUES(seq, set_range, get_range,
db_seq_t, 2, db_seq_t, 1048576);
CuAssert(ct, "seq->close", close_seq_handle(seq) == 0);
CuAssert(ct, "dbp->close", close_db_handle(dbp) == 0);
CuAssert(ct, "dbenv->close", close_dbenv_handle(dbenv) == 0);
return (0);
}
int TestDbPreOpenSetterAndGetter(CuTest *ct) {
DB_ENV *dbenv;
DB *db, *env_db, *hash_db, *heap_db, *queue_db, *recno_db;
const char **part_dirs;
u_int32_t encrypt_flags, heap_set_bytes, heap_set_gbytes,
heap_get_bytes, heap_get_gbytes;
int nowait, onoff;
/* ================ General and Btree Configuration =============== */
CuAssert(ct, "db_create", create_db_handle(&db, NULL) == 0);
/*
* Test DB->set_cachesize(), DB->get_cachesize().
* We use specific values to avoid adjustment.
*/
CHECK_3_DIGIT_VALUES(db, set_cachesize, get_cachesize,
u_int32_t, 3, u_int32_t, 1048576, int, 5);
/* Test DB->set_encrypt(), DB->get_encrypt_flags(). */
CuAssert(ct, "db->set_encrypt",
db->set_encrypt(db, passwd, DB_ENCRYPT_AES) == 0);
CuAssert(ct, "db->get_encrypt_flags",
db->get_encrypt_flags(db, &encrypt_flags) == 0);
CuAssert(ct, "check encrypt flags", encrypt_flags == DB_ENCRYPT_AES);
/* Test DB->set_errfile(), DB->get_errfile(). */
CHECK_1_PTR_VALUE_VOID(db, set_errfile, get_errfile, FILE, errfile);
/* Test DB->set_errpfx(), DB->get_errpfx().*/
CHECK_1_STR_VALUE_VOID(db, set_errpfx, get_errpfx, "dbp1");
/* Test DB->set_flags(), DB->get_flags(). */
CHECK_FLAG_VALUE(db, set_flags, get_flags,
u_int32_t, DB_CHKSUM | DB_RECNUM | DB_REVSPLITOFF);
/* Test DB->set_lk_exclusive(), DB->get_lk_exclusive(). */
CuAssert(ct, "db->set_lk_exclusive", db->set_lk_exclusive(db, 1) == 0);
CuAssert(ct, "db->get_lk_exclusive",
db->get_lk_exclusive(db, &onoff, &nowait) == 0);
CuAssert(ct, "check lk_exclusive onoff", onoff == 1);
CuAssert(ct, "check lk_exclusive nowait", nowait == 1);
/*
* Test DB->set_lorder(), DB->get_lorder().
* The only acceptable values are 1234 and 4321.
*/
CHECK_1_DIGIT_VALUE(db, set_lorder, get_lorder, int, 1234);
CHECK_1_DIGIT_VALUE(db, set_lorder, get_lorder, int, 4321);
/* Test DB->set_msgfile(), DB->get_msgfile(). */
CHECK_1_PTR_VALUE_VOID(db, set_msgfile, get_msgfile, FILE, msgfile);
/*
* Test DB->set_pagesize(), DB->get_pagesize().
* The pagesize should be 512-55536, and be power of two.
*/
CHECK_1_DIGIT_VALUE(db, set_pagesize, get_pagesize, u_int32_t, 512);
CHECK_1_DIGIT_VALUE(db, set_pagesize, get_pagesize, u_int32_t, 65536);
/*
* Test DB->set_bt_minkey(), DB->get_bt_minkey().
* The minkey value should be 2 at least.
*/
CHECK_1_DIGIT_VALUE(db, set_bt_minkey, get_bt_minkey, u_int32_t, 17);
CuAssert(ct, "db->close", close_db_handle(db) == 0);
/* =================== Recno-only Configuration ===================== */
CuAssert(ct, "db_create", create_db_handle(&recno_db, NULL) == 0);
/* Test DB->set_flags(), DB->get_flags(). */
CHECK_FLAG_VALUE(recno_db, set_flags, get_flags,
u_int32_t, DB_RENUMBER | DB_SNAPSHOT);
/* Test DB->set_re_delim(), DB->get_re_delim(). */
CHECK_1_DIGIT_VALUE(recno_db, set_re_delim, get_re_delim,
int, rand());
/* Test DB->set_re_len(), DB->get_re_len(). */
CHECK_1_DIGIT_VALUE(recno_db, set_re_len, get_re_len,
u_int32_t, rand());
/* Test DB->set_re_pad(), DB->get_re_pad(). */
CHECK_1_DIGIT_VALUE(recno_db, set_re_pad, get_re_pad, int, rand());
/* Test DB->set_re_source(), DB->get_re_source(). */
CHECK_1_STR_VALUE(recno_db, set_re_source, get_re_source, "re_source1");
CuAssert(ct, "recno_db->close", close_db_handle(recno_db) == 0);
/* ==================== Hash-only Configuration ===================== */
CuAssert(ct, "db_create", create_db_handle(&hash_db, NULL) == 0);
/* Test DB->set_flags(), DB->get_flags(). */
CHECK_FLAG_VALUE(hash_db, set_flags, get_flags,
u_int32_t, DB_DUP | DB_DUPSORT | DB_REVSPLITOFF);
/* Test DB->set_h_ffactor(), DB->get_h_ffactor(). */
CHECK_1_DIGIT_VALUE(hash_db, set_h_ffactor, get_h_ffactor,
u_int32_t, rand());
/* Test DB->set_h_nelem(), DB->get_h_nelem(). */
CHECK_1_DIGIT_VALUE(hash_db, set_h_nelem, get_h_nelem,
u_int32_t, rand());
CuAssert(ct, "hash_db->close", close_db_handle(hash_db) == 0);
/* =================== Queue-only Configuration ===================== */
CuAssert(ct, "db_create", create_db_handle(&queue_db, NULL) == 0);
/* Test DB->set_flags(), DB->get_flags(). */
CHECK_FLAG_VALUE(queue_db, set_flags, get_flags, u_int32_t, DB_INORDER);
/* Test DB->set_q_extentsize(), DB->get_q_extentsize(). */
CHECK_1_DIGIT_VALUE(queue_db, set_q_extentsize, get_q_extentsize,
u_int32_t, rand());
CuAssert(ct, "queue_db->close", close_db_handle(queue_db) == 0);
/* ==================== Heap-only Configuration ===================== */
CuAssert(ct, "db_create", create_db_handle(&heap_db, NULL) == 0);
/* Test DB->set_heapsize(), DB->get_heapsize(). */
heap_set_gbytes = 3;
heap_set_bytes = 1048576;
heap_get_gbytes = heap_get_bytes = 0;
CuAssert(ct, "DB->set_heapsize", heap_db->set_heapsize(heap_db,
heap_set_gbytes, heap_set_bytes, 0) == 0);
CuAssert(ct, "DB->get_heapsize", heap_db->get_heapsize(heap_db,
&heap_get_gbytes, &heap_get_bytes) == 0);
CuAssert(ct, "Check heap gbytes", heap_set_gbytes == heap_get_gbytes);
CuAssert(ct, "Check heap bytes", heap_set_bytes == heap_get_bytes);
/* Test DB->set_heap_regionsize(), DB->get_heap_regionsize(). */
CHECK_1_DIGIT_VALUE(heap_db, set_heap_regionsize, get_heap_regionsize,
u_int32_t, rand());
CuAssert(ct, "heap_db->close", close_db_handle(heap_db) == 0);
/*
* The following configurations require the database
* be opened in an environment.
*/
CuAssert(ct, "db_env_create", create_dbenv_handle(&dbenv) == 0);
CuAssert(ct, "dbenv->set_flags(DB_ENCRYPT)", dbenv->set_encrypt(dbenv,
passwd, DB_ENCRYPT_AES) == 0);
CuAssert(ct, "add_dirs_to_dbenv",
add_dirs_to_dbenv(dbenv, data_dirs) == 0);
CuAssert(ct, "dbenv->open", dbenv->open(dbenv, TEST_ENV,
DB_CREATE | DB_INIT_MPOOL | DB_INIT_TXN, 0644) == 0);
CuAssert(ct, "db_create", create_db_handle(&env_db, dbenv) == 0);
/* Test DB->set_flags(), DB->get_flags(). */
CHECK_FLAG_VALUE(env_db, set_flags, get_flags,
u_int32_t, DB_ENCRYPT | DB_TXN_NOT_DURABLE);
/* Test DB->set_create_dir(), DB->get_create_dir(). */
CHECK_1_STR_VALUE(env_db, set_create_dir, get_create_dir, data_dirs[0]);
/* Test DB->set_partition_dirs(), DB->get_partition_dirs(). */
CuAssert(ct, "env_db->set_partition_dirs",
env_db->set_partition_dirs(env_db, &data_dirs[1]) == 0);
CuAssert(ct, "env_db->get_partition_dirs",
env_db->get_partition_dirs(env_db, &part_dirs) == 0);
CuAssert(ct, "cmp_dirs", cmp_dirs(&data_dirs[1], part_dirs) == 0);
CuAssert(ct, "env_db->close", close_db_handle(env_db) == 0);
CuAssert(ct, "dbenv->close", close_dbenv_handle(dbenv) == 0);
return (0);
}
