Inside Bitcoin

1/* Copyright (c) 2011 The LevelDB Authors. All rights reserved.
2   Use of this source code is governed by a BSD-style license that can be
3   found in the LICENSE file. See the AUTHORS file for names of contributors. */
4
5#include "leveldb/c.h"
6
7#include <stddef.h>
8#include <stdio.h>
9#include <stdlib.h>
10#include <string.h>
11
12const char* phase = "";
13
14static void StartPhase(const char* name) {
15  fprintf(stderr, "=== Test %s\n", name);
16  phase = name;
17}
18
19#define CheckNoError(err)                                               \
20  if ((err) != NULL) {                                                  \
21    fprintf(stderr, "%s:%d: %s: %s\n", __FILE__, __LINE__, phase, (err)); \
22    abort();                                                            \
23  }
24
25#define CheckCondition(cond)                                            \
26  if (!(cond)) {                                                        \
27    fprintf(stderr, "%s:%d: %s: %s\n", __FILE__, __LINE__, phase, #cond); \
28    abort();                                                            \
29  }
30
31static void CheckEqual(const char* expected, const char* v, size_t n) {
32  if (expected == NULL && v == NULL) {
33    // ok
34  } else if (expected != NULL && v != NULL && n == strlen(expected) &&
35             memcmp(expected, v, n) == 0) {
36    // ok
37    return;
38  } else {
39    fprintf(stderr, "%s: expected '%s', got '%s'\n",
40            phase,
41            (expected ? expected : "(null)"),
42            (v ? v : "(null"));
43    abort();
44  }
45}
46
47static void Free(char** ptr) {
48  if (*ptr) {
49    free(*ptr);
50    *ptr = NULL;
51  }
52}
53
54static void CheckGet(
55    leveldb_t* db,
56    const leveldb_readoptions_t* options,
57    const char* key,
58    const char* expected) {
59  char* err = NULL;
60  size_t val_len;
61  char* val;
62  val = leveldb_get(db, options, key, strlen(key), &val_len, &err);
63  CheckNoError(err);
64  CheckEqual(expected, val, val_len);
65  Free(&val);
66}
67
68static void CheckIter(leveldb_iterator_t* iter,
69                      const char* key, const char* val) {
70  size_t len;
71  const char* str;
72  str = leveldb_iter_key(iter, &len);
73  CheckEqual(key, str, len);
74  str = leveldb_iter_value(iter, &len);
75  CheckEqual(val, str, len);
76}
77
78// Callback from leveldb_writebatch_iterate()
79static void CheckPut(void* ptr,
80                     const char* k, size_t klen,
81                     const char* v, size_t vlen) {
82  int* state = (int*) ptr;
83  CheckCondition(*state < 2);
84  switch (*state) {
85    case 0:
86      CheckEqual("bar", k, klen);
87      CheckEqual("b", v, vlen);
88      break;
89    case 1:
90      CheckEqual("box", k, klen);
91      CheckEqual("c", v, vlen);
92      break;
93  }
94  (*state)++;
95}
96
97// Callback from leveldb_writebatch_iterate()
98static void CheckDel(void* ptr, const char* k, size_t klen) {
99  int* state = (int*) ptr;
100  CheckCondition(*state == 2);
101  CheckEqual("bar", k, klen);
102  (*state)++;
103}
104
105static void CmpDestroy(void* arg) { }
106
107static int CmpCompare(void* arg, const char* a, size_t alen,
108                      const char* b, size_t blen) {
109  int n = (alen < blen) ? alen : blen;
110  int r = memcmp(a, b, n);
111  if (r == 0) {
112    if (alen < blen) r = -1;
113    else if (alen > blen) r = +1;
114  }
115  return r;
116}
117
118static const char* CmpName(void* arg) {
119  return "foo";
120}
121
122// Custom filter policy
123static uint8_t fake_filter_result = 1;
124static void FilterDestroy(void* arg) { }
125static const char* FilterName(void* arg) {
126  return "TestFilter";
127}
128static char* FilterCreate(
129    void* arg,
130    const char* const* key_array, const size_t* key_length_array,
131    int num_keys,
132    size_t* filter_length) {
133  *filter_length = 4;
134  char* result = malloc(4);
135  memcpy(result, "fake", 4);
136  return result;
137}
138uint8_t FilterKeyMatch(void* arg, const char* key, size_t length,
139                       const char* filter, size_t filter_length) {
140  CheckCondition(filter_length == 4);
141  CheckCondition(memcmp(filter, "fake", 4) == 0);
142  return fake_filter_result;
143}
144
145int main(int argc, char** argv) {
146  leveldb_t* db;
147  leveldb_comparator_t* cmp;
148  leveldb_cache_t* cache;
149  leveldb_env_t* env;
150  leveldb_options_t* options;
151  leveldb_readoptions_t* roptions;
152  leveldb_writeoptions_t* woptions;
153  char* dbname;
154  char* err = NULL;
155  int run = -1;
156
157  CheckCondition(leveldb_major_version() >= 1);
158  CheckCondition(leveldb_minor_version() >= 1);
159
160  StartPhase("create_objects");
161  cmp = leveldb_comparator_create(NULL, CmpDestroy, CmpCompare, CmpName);
162  env = leveldb_create_default_env();
163  cache = leveldb_cache_create_lru(100000);
164  dbname = leveldb_env_get_test_directory(env);
165  CheckCondition(dbname != NULL);
166
167  options = leveldb_options_create();
168  leveldb_options_set_comparator(options, cmp);
169  leveldb_options_set_error_if_exists(options, 1);
170  leveldb_options_set_cache(options, cache);
171  leveldb_options_set_env(options, env);
172  leveldb_options_set_info_log(options, NULL);
173  leveldb_options_set_write_buffer_size(options, 100000);
174  leveldb_options_set_paranoid_checks(options, 1);
175  leveldb_options_set_max_open_files(options, 10);
176  leveldb_options_set_block_size(options, 1024);
177  leveldb_options_set_block_restart_interval(options, 8);
178  leveldb_options_set_max_file_size(options, 3 << 20);
179  leveldb_options_set_compression(options, leveldb_no_compression);
180
181  roptions = leveldb_readoptions_create();
182  leveldb_readoptions_set_verify_checksums(roptions, 1);
183  leveldb_readoptions_set_fill_cache(roptions, 0);
184
185  woptions = leveldb_writeoptions_create();
186  leveldb_writeoptions_set_sync(woptions, 1);
187
188  StartPhase("destroy");
189  leveldb_destroy_db(options, dbname, &err);
190  Free(&err);
191
192  StartPhase("open_error");
193  db = leveldb_open(options, dbname, &err);
194  CheckCondition(err != NULL);
195  Free(&err);
196
197  StartPhase("leveldb_free");
198  db = leveldb_open(options, dbname, &err);
199  CheckCondition(err != NULL);
200  leveldb_free(err);
201  err = NULL;
202
203  StartPhase("open");
204  leveldb_options_set_create_if_missing(options, 1);
205  db = leveldb_open(options, dbname, &err);
206  CheckNoError(err);
207  CheckGet(db, roptions, "foo", NULL);
208
209  StartPhase("put");
210  leveldb_put(db, woptions, "foo", 3, "hello", 5, &err);
211  CheckNoError(err);
212  CheckGet(db, roptions, "foo", "hello");
213
214  StartPhase("compactall");
215  leveldb_compact_range(db, NULL, 0, NULL, 0);
216  CheckGet(db, roptions, "foo", "hello");
217
218  StartPhase("compactrange");
219  leveldb_compact_range(db, "a", 1, "z", 1);
220  CheckGet(db, roptions, "foo", "hello");
221
222  StartPhase("writebatch");
223  {
224    leveldb_writebatch_t* wb = leveldb_writebatch_create();
225    leveldb_writebatch_put(wb, "foo", 3, "a", 1);
226    leveldb_writebatch_clear(wb);
227    leveldb_writebatch_put(wb, "bar", 3, "b", 1);
228    leveldb_writebatch_put(wb, "box", 3, "c", 1);
229
230    leveldb_writebatch_t* wb2 = leveldb_writebatch_create();
231    leveldb_writebatch_delete(wb2, "bar", 3);
232    leveldb_writebatch_append(wb, wb2);
233    leveldb_writebatch_destroy(wb2);
234
235    leveldb_write(db, woptions, wb, &err);
236    CheckNoError(err);
237    CheckGet(db, roptions, "foo", "hello");
238    CheckGet(db, roptions, "bar", NULL);
239    CheckGet(db, roptions, "box", "c");
240
241    int pos = 0;
242    leveldb_writebatch_iterate(wb, &pos, CheckPut, CheckDel);
243    CheckCondition(pos == 3);
244    leveldb_writebatch_destroy(wb);
245  }
246
247  StartPhase("iter");
248  {
249    leveldb_iterator_t* iter = leveldb_create_iterator(db, roptions);
250    CheckCondition(!leveldb_iter_valid(iter));