tomFlowee
c63519fa47
The leveldb and univalue 3rd party libraries are not installed and not needed by anyone outside of the Hub. So move them there, making it easier for 3rd party usage.
391 lines
11 KiB
C
391 lines
11 KiB
C
/* Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
|
Use of this source code is governed by a BSD-style license that can be
|
|
found in the LICENSE file. See the AUTHORS file for names of contributors. */
|
|
|
|
#include "leveldb/c.h"
|
|
|
|
#include <stddef.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
|
|
const char* phase = "";
|
|
static char dbname[200];
|
|
|
|
static void StartPhase(const char* name) {
|
|
fprintf(stderr, "=== Test %s\n", name);
|
|
phase = name;
|
|
}
|
|
|
|
static const char* GetTempDir(void) {
|
|
const char* ret = getenv("TEST_TMPDIR");
|
|
if (ret == NULL || ret[0] == '\0')
|
|
ret = "/tmp";
|
|
return ret;
|
|
}
|
|
|
|
#define CheckNoError(err) \
|
|
if ((err) != NULL) { \
|
|
fprintf(stderr, "%s:%d: %s: %s\n", __FILE__, __LINE__, phase, (err)); \
|
|
abort(); \
|
|
}
|
|
|
|
#define CheckCondition(cond) \
|
|
if (!(cond)) { \
|
|
fprintf(stderr, "%s:%d: %s: %s\n", __FILE__, __LINE__, phase, #cond); \
|
|
abort(); \
|
|
}
|
|
|
|
static void CheckEqual(const char* expected, const char* v, size_t n) {
|
|
if (expected == NULL && v == NULL) {
|
|
// ok
|
|
} else if (expected != NULL && v != NULL && n == strlen(expected) &&
|
|
memcmp(expected, v, n) == 0) {
|
|
// ok
|
|
return;
|
|
} else {
|
|
fprintf(stderr, "%s: expected '%s', got '%s'\n",
|
|
phase,
|
|
(expected ? expected : "(null)"),
|
|
(v ? v : "(null"));
|
|
abort();
|
|
}
|
|
}
|
|
|
|
static void Free(char** ptr) {
|
|
if (*ptr) {
|
|
free(*ptr);
|
|
*ptr = NULL;
|
|
}
|
|
}
|
|
|
|
static void CheckGet(
|
|
leveldb_t* db,
|
|
const leveldb_readoptions_t* options,
|
|
const char* key,
|
|
const char* expected) {
|
|
char* err = NULL;
|
|
size_t val_len;
|
|
char* val;
|
|
val = leveldb_get(db, options, key, strlen(key), &val_len, &err);
|
|
CheckNoError(err);
|
|
CheckEqual(expected, val, val_len);
|
|
Free(&val);
|
|
}
|
|
|
|
static void CheckIter(leveldb_iterator_t* iter,
|
|
const char* key, const char* val) {
|
|
size_t len;
|
|
const char* str;
|
|
str = leveldb_iter_key(iter, &len);
|
|
CheckEqual(key, str, len);
|
|
str = leveldb_iter_value(iter, &len);
|
|
CheckEqual(val, str, len);
|
|
}
|
|
|
|
// Callback from leveldb_writebatch_iterate()
|
|
static void CheckPut(void* ptr,
|
|
const char* k, size_t klen,
|
|
const char* v, size_t vlen) {
|
|
int* state = (int*) ptr;
|
|
CheckCondition(*state < 2);
|
|
switch (*state) {
|
|
case 0:
|
|
CheckEqual("bar", k, klen);
|
|
CheckEqual("b", v, vlen);
|
|
break;
|
|
case 1:
|
|
CheckEqual("box", k, klen);
|
|
CheckEqual("c", v, vlen);
|
|
break;
|
|
}
|
|
(*state)++;
|
|
}
|
|
|
|
// Callback from leveldb_writebatch_iterate()
|
|
static void CheckDel(void* ptr, const char* k, size_t klen) {
|
|
int* state = (int*) ptr;
|
|
CheckCondition(*state == 2);
|
|
CheckEqual("bar", k, klen);
|
|
(*state)++;
|
|
}
|
|
|
|
static void CmpDestroy(void* arg) { }
|
|
|
|
static int CmpCompare(void* arg, const char* a, size_t alen,
|
|
const char* b, size_t blen) {
|
|
int n = (alen < blen) ? alen : blen;
|
|
int r = memcmp(a, b, n);
|
|
if (r == 0) {
|
|
if (alen < blen) r = -1;
|
|
else if (alen > blen) r = +1;
|
|
}
|
|
return r;
|
|
}
|
|
|
|
static const char* CmpName(void* arg) {
|
|
return "foo";
|
|
}
|
|
|
|
// Custom filter policy
|
|
static unsigned char fake_filter_result = 1;
|
|
static void FilterDestroy(void* arg) { }
|
|
static const char* FilterName(void* arg) {
|
|
return "TestFilter";
|
|
}
|
|
static char* FilterCreate(
|
|
void* arg,
|
|
const char* const* key_array, const size_t* key_length_array,
|
|
int num_keys,
|
|
size_t* filter_length) {
|
|
*filter_length = 4;
|
|
char* result = malloc(4);
|
|
memcpy(result, "fake", 4);
|
|
return result;
|
|
}
|
|
unsigned char FilterKeyMatch(
|
|
void* arg,
|
|
const char* key, size_t length,
|
|
const char* filter, size_t filter_length) {
|
|
CheckCondition(filter_length == 4);
|
|
CheckCondition(memcmp(filter, "fake", 4) == 0);
|
|
return fake_filter_result;
|
|
}
|
|
|
|
int main(int argc, char** argv) {
|
|
leveldb_t* db;
|
|
leveldb_comparator_t* cmp;
|
|
leveldb_cache_t* cache;
|
|
leveldb_env_t* env;
|
|
leveldb_options_t* options;
|
|
leveldb_readoptions_t* roptions;
|
|
leveldb_writeoptions_t* woptions;
|
|
char* err = NULL;
|
|
int run = -1;
|
|
|
|
CheckCondition(leveldb_major_version() >= 1);
|
|
CheckCondition(leveldb_minor_version() >= 1);
|
|
|
|
snprintf(dbname, sizeof(dbname),
|
|
"%s/leveldb_c_test-%d",
|
|
GetTempDir(),
|
|
((int) geteuid()));
|
|
|
|
StartPhase("create_objects");
|
|
cmp = leveldb_comparator_create(NULL, CmpDestroy, CmpCompare, CmpName);
|
|
env = leveldb_create_default_env();
|
|
cache = leveldb_cache_create_lru(100000);
|
|
|
|
options = leveldb_options_create();
|
|
leveldb_options_set_comparator(options, cmp);
|
|
leveldb_options_set_error_if_exists(options, 1);
|
|
leveldb_options_set_cache(options, cache);
|
|
leveldb_options_set_env(options, env);
|
|
leveldb_options_set_info_log(options, NULL);
|
|
leveldb_options_set_write_buffer_size(options, 100000);
|
|
leveldb_options_set_paranoid_checks(options, 1);
|
|
leveldb_options_set_max_open_files(options, 10);
|
|
leveldb_options_set_block_size(options, 1024);
|
|
leveldb_options_set_block_restart_interval(options, 8);
|
|
leveldb_options_set_compression(options, leveldb_no_compression);
|
|
|
|
roptions = leveldb_readoptions_create();
|
|
leveldb_readoptions_set_verify_checksums(roptions, 1);
|
|
leveldb_readoptions_set_fill_cache(roptions, 0);
|
|
|
|
woptions = leveldb_writeoptions_create();
|
|
leveldb_writeoptions_set_sync(woptions, 1);
|
|
|
|
StartPhase("destroy");
|
|
leveldb_destroy_db(options, dbname, &err);
|
|
Free(&err);
|
|
|
|
StartPhase("open_error");
|
|
db = leveldb_open(options, dbname, &err);
|
|
CheckCondition(err != NULL);
|
|
Free(&err);
|
|
|
|
StartPhase("leveldb_free");
|
|
db = leveldb_open(options, dbname, &err);
|
|
CheckCondition(err != NULL);
|
|
leveldb_free(err);
|
|
err = NULL;
|
|
|
|
StartPhase("open");
|
|
leveldb_options_set_create_if_missing(options, 1);
|
|
db = leveldb_open(options, dbname, &err);
|
|
CheckNoError(err);
|
|
CheckGet(db, roptions, "foo", NULL);
|
|
|
|
StartPhase("put");
|
|
leveldb_put(db, woptions, "foo", 3, "hello", 5, &err);
|
|
CheckNoError(err);
|
|
CheckGet(db, roptions, "foo", "hello");
|
|
|
|
StartPhase("compactall");
|
|
leveldb_compact_range(db, NULL, 0, NULL, 0);
|
|
CheckGet(db, roptions, "foo", "hello");
|
|
|
|
StartPhase("compactrange");
|
|
leveldb_compact_range(db, "a", 1, "z", 1);
|
|
CheckGet(db, roptions, "foo", "hello");
|
|
|
|
StartPhase("writebatch");
|
|
{
|
|
leveldb_writebatch_t* wb = leveldb_writebatch_create();
|
|
leveldb_writebatch_put(wb, "foo", 3, "a", 1);
|
|
leveldb_writebatch_clear(wb);
|
|
leveldb_writebatch_put(wb, "bar", 3, "b", 1);
|
|
leveldb_writebatch_put(wb, "box", 3, "c", 1);
|
|
leveldb_writebatch_delete(wb, "bar", 3);
|
|
leveldb_write(db, woptions, wb, &err);
|
|
CheckNoError(err);
|
|
CheckGet(db, roptions, "foo", "hello");
|
|
CheckGet(db, roptions, "bar", NULL);
|
|
CheckGet(db, roptions, "box", "c");
|
|
int pos = 0;
|
|
leveldb_writebatch_iterate(wb, &pos, CheckPut, CheckDel);
|
|
CheckCondition(pos == 3);
|
|
leveldb_writebatch_destroy(wb);
|
|
}
|
|
|
|
StartPhase("iter");
|
|
{
|
|
leveldb_iterator_t* iter = leveldb_create_iterator(db, roptions);
|
|
CheckCondition(!leveldb_iter_valid(iter));
|
|
leveldb_iter_seek_to_first(iter);
|
|
CheckCondition(leveldb_iter_valid(iter));
|
|
CheckIter(iter, "box", "c");
|
|
leveldb_iter_next(iter);
|
|
CheckIter(iter, "foo", "hello");
|
|
leveldb_iter_prev(iter);
|
|
CheckIter(iter, "box", "c");
|
|
leveldb_iter_prev(iter);
|
|
CheckCondition(!leveldb_iter_valid(iter));
|
|
leveldb_iter_seek_to_last(iter);
|
|
CheckIter(iter, "foo", "hello");
|
|
leveldb_iter_seek(iter, "b", 1);
|
|
CheckIter(iter, "box", "c");
|
|
leveldb_iter_get_error(iter, &err);
|
|
CheckNoError(err);
|
|
leveldb_iter_destroy(iter);
|
|
}
|
|
|
|
StartPhase("approximate_sizes");
|
|
{
|
|
int i;
|
|
int n = 20000;
|
|
char keybuf[100];
|
|
char valbuf[100];
|
|
uint64_t sizes[2];
|
|
const char* start[2] = { "a", "k00000000000000010000" };
|
|
size_t start_len[2] = { 1, 21 };
|
|
const char* limit[2] = { "k00000000000000010000", "z" };
|
|
size_t limit_len[2] = { 21, 1 };
|
|
leveldb_writeoptions_set_sync(woptions, 0);
|
|
for (i = 0; i < n; i++) {
|
|
snprintf(keybuf, sizeof(keybuf), "k%020d", i);
|
|
snprintf(valbuf, sizeof(valbuf), "v%020d", i);
|
|
leveldb_put(db, woptions, keybuf, strlen(keybuf), valbuf, strlen(valbuf),
|
|
&err);
|
|
CheckNoError(err);
|
|
}
|
|
leveldb_approximate_sizes(db, 2, start, start_len, limit, limit_len, sizes);
|
|
CheckCondition(sizes[0] > 0);
|
|
CheckCondition(sizes[1] > 0);
|
|
}
|
|
|
|
StartPhase("property");
|
|
{
|
|
char* prop = leveldb_property_value(db, "nosuchprop");
|
|
CheckCondition(prop == NULL);
|
|
prop = leveldb_property_value(db, "leveldb.stats");
|
|
CheckCondition(prop != NULL);
|
|
Free(&prop);
|
|
}
|
|
|
|
StartPhase("snapshot");
|
|
{
|
|
const leveldb_snapshot_t* snap;
|
|
snap = leveldb_create_snapshot(db);
|
|
leveldb_delete(db, woptions, "foo", 3, &err);
|
|
CheckNoError(err);
|
|
leveldb_readoptions_set_snapshot(roptions, snap);
|
|
CheckGet(db, roptions, "foo", "hello");
|
|
leveldb_readoptions_set_snapshot(roptions, NULL);
|
|
CheckGet(db, roptions, "foo", NULL);
|
|
leveldb_release_snapshot(db, snap);
|
|
}
|
|
|
|
StartPhase("repair");
|
|
{
|
|
leveldb_close(db);
|
|
leveldb_options_set_create_if_missing(options, 0);
|
|
leveldb_options_set_error_if_exists(options, 0);
|
|
leveldb_repair_db(options, dbname, &err);
|
|
CheckNoError(err);
|
|
db = leveldb_open(options, dbname, &err);
|
|
CheckNoError(err);
|
|
CheckGet(db, roptions, "foo", NULL);
|
|
CheckGet(db, roptions, "bar", NULL);
|
|
CheckGet(db, roptions, "box", "c");
|
|
leveldb_options_set_create_if_missing(options, 1);
|
|
leveldb_options_set_error_if_exists(options, 1);
|
|
}
|
|
|
|
StartPhase("filter");
|
|
for (run = 0; run < 2; run++) {
|
|
// First run uses custom filter, second run uses bloom filter
|
|
CheckNoError(err);
|
|
leveldb_filterpolicy_t* policy;
|
|
if (run == 0) {
|
|
policy = leveldb_filterpolicy_create(
|
|
NULL, FilterDestroy, FilterCreate, FilterKeyMatch, FilterName);
|
|
} else {
|
|
policy = leveldb_filterpolicy_create_bloom(10);
|
|
}
|
|
|
|
// Create new database
|
|
leveldb_close(db);
|
|
leveldb_destroy_db(options, dbname, &err);
|
|
leveldb_options_set_filter_policy(options, policy);
|
|
db = leveldb_open(options, dbname, &err);
|
|
CheckNoError(err);
|
|
leveldb_put(db, woptions, "foo", 3, "foovalue", 8, &err);
|
|
CheckNoError(err);
|
|
leveldb_put(db, woptions, "bar", 3, "barvalue", 8, &err);
|
|
CheckNoError(err);
|
|
leveldb_compact_range(db, NULL, 0, NULL, 0);
|
|
|
|
fake_filter_result = 1;
|
|
CheckGet(db, roptions, "foo", "foovalue");
|
|
CheckGet(db, roptions, "bar", "barvalue");
|
|
if (phase == 0) {
|
|
// Must not find value when custom filter returns false
|
|
fake_filter_result = 0;
|
|
CheckGet(db, roptions, "foo", NULL);
|
|
CheckGet(db, roptions, "bar", NULL);
|
|
fake_filter_result = 1;
|
|
|
|
CheckGet(db, roptions, "foo", "foovalue");
|
|
CheckGet(db, roptions, "bar", "barvalue");
|
|
}
|
|
leveldb_options_set_filter_policy(options, NULL);
|
|
leveldb_filterpolicy_destroy(policy);
|
|
}
|
|
|
|
StartPhase("cleanup");
|
|
leveldb_close(db);
|
|
leveldb_options_destroy(options);
|
|
leveldb_readoptions_destroy(roptions);
|
|
leveldb_writeoptions_destroy(woptions);
|
|
leveldb_cache_destroy(cache);
|
|
leveldb_comparator_destroy(cmp);
|
|
leveldb_env_destroy(env);
|
|
|
|
fprintf(stderr, "PASS\n");
|
|
return 0;
|
|
}
|