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 "helpers/memenv/memenv.h"
6
7 #include "db/db_impl.h"
8 #include "leveldb/db.h"
9 #include "leveldb/env.h"
10 #include "util/testharness.h"
11 #include <string>
12 #include <vector>
13
14 namespace leveldb {
15
16 class MemEnvTest {
17 public:
18 Env* env_;
19
MemEnvTest()20 MemEnvTest()
21 : env_(NewMemEnv(Env::Default())) {
22 }
~MemEnvTest()23 ~MemEnvTest() {
24 delete env_;
25 }
26 };
27
TEST(MemEnvTest,Basics)28 TEST(MemEnvTest, Basics) {
29 uint64_t file_size;
30 WritableFile* writable_file;
31 std::vector<std::string> children;
32
33 ASSERT_OK(env_->CreateDir("/dir"));
34
35 // Check that the directory is empty.
36 ASSERT_TRUE(!env_->FileExists("/dir/non_existent"));
37 ASSERT_TRUE(!env_->GetFileSize("/dir/non_existent", &file_size).ok());
38 ASSERT_OK(env_->GetChildren("/dir", &children));
39 ASSERT_EQ(0, children.size());
40
41 // Create a file.
42 ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file));
43 ASSERT_OK(env_->GetFileSize("/dir/f", &file_size));
44 ASSERT_EQ(0, file_size);
45 delete writable_file;
46
47 // Check that the file exists.
48 ASSERT_TRUE(env_->FileExists("/dir/f"));
49 ASSERT_OK(env_->GetFileSize("/dir/f", &file_size));
50 ASSERT_EQ(0, file_size);
51 ASSERT_OK(env_->GetChildren("/dir", &children));
52 ASSERT_EQ(1, children.size());
53 ASSERT_EQ("f", children[0]);
54
55 // Write to the file.
56 ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file));
57 ASSERT_OK(writable_file->Append("abc"));
58 delete writable_file;
59
60 // Check that append works.
61 ASSERT_OK(env_->NewAppendableFile("/dir/f", &writable_file));
62 ASSERT_OK(env_->GetFileSize("/dir/f", &file_size));
63 ASSERT_EQ(3, file_size);
64 ASSERT_OK(writable_file->Append("hello"));
65 delete writable_file;
66
67 // Check for expected size.
68 ASSERT_OK(env_->GetFileSize("/dir/f", &file_size));
69 ASSERT_EQ(8, file_size);
70
71 // Check that renaming works.
72 ASSERT_TRUE(!env_->RenameFile("/dir/non_existent", "/dir/g").ok());
73 ASSERT_OK(env_->RenameFile("/dir/f", "/dir/g"));
74 ASSERT_TRUE(!env_->FileExists("/dir/f"));
75 ASSERT_TRUE(env_->FileExists("/dir/g"));
76 ASSERT_OK(env_->GetFileSize("/dir/g", &file_size));
77 ASSERT_EQ(8, file_size);
78
79 // Check that opening non-existent file fails.
80 SequentialFile* seq_file;
81 RandomAccessFile* rand_file;
82 ASSERT_TRUE(!env_->NewSequentialFile("/dir/non_existent", &seq_file).ok());
83 ASSERT_TRUE(!seq_file);
84 ASSERT_TRUE(!env_->NewRandomAccessFile("/dir/non_existent", &rand_file).ok());
85 ASSERT_TRUE(!rand_file);
86
87 // Check that deleting works.
88 ASSERT_TRUE(!env_->DeleteFile("/dir/non_existent").ok());
89 ASSERT_OK(env_->DeleteFile("/dir/g"));
90 ASSERT_TRUE(!env_->FileExists("/dir/g"));
91 ASSERT_OK(env_->GetChildren("/dir", &children));
92 ASSERT_EQ(0, children.size());
93 ASSERT_OK(env_->DeleteDir("/dir"));
94 }
95
TEST(MemEnvTest,ReadWrite)96 TEST(MemEnvTest, ReadWrite) {
97 WritableFile* writable_file;
98 SequentialFile* seq_file;
99 RandomAccessFile* rand_file;
100 Slice result;
101 char scratch[100];
102
103 ASSERT_OK(env_->CreateDir("/dir"));
104
105 ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file));
106 ASSERT_OK(writable_file->Append("hello "));
107 ASSERT_OK(writable_file->Append("world"));
108 delete writable_file;
109
110 // Read sequentially.
111 ASSERT_OK(env_->NewSequentialFile("/dir/f", &seq_file));
112 ASSERT_OK(seq_file->Read(5, &result, scratch)); // Read "hello".
113 ASSERT_EQ(0, result.compare("hello"));
114 ASSERT_OK(seq_file->Skip(1));
115 ASSERT_OK(seq_file->Read(1000, &result, scratch)); // Read "world".
116 ASSERT_EQ(0, result.compare("world"));
117 ASSERT_OK(seq_file->Read(1000, &result, scratch)); // Try reading past EOF.
118 ASSERT_EQ(0, result.size());
119 ASSERT_OK(seq_file->Skip(100)); // Try to skip past end of file.
120 ASSERT_OK(seq_file->Read(1000, &result, scratch));
121 ASSERT_EQ(0, result.size());
122 delete seq_file;
123
124 // Random reads.
125 ASSERT_OK(env_->NewRandomAccessFile("/dir/f", &rand_file));
126 ASSERT_OK(rand_file->Read(6, 5, &result, scratch)); // Read "world".
127 ASSERT_EQ(0, result.compare("world"));
128 ASSERT_OK(rand_file->Read(0, 5, &result, scratch)); // Read "hello".
129 ASSERT_EQ(0, result.compare("hello"));
130 ASSERT_OK(rand_file->Read(10, 100, &result, scratch)); // Read "d".
131 ASSERT_EQ(0, result.compare("d"));
132
133 // Too high offset.
134 ASSERT_TRUE(!rand_file->Read(1000, 5, &result, scratch).ok());
135 delete rand_file;
136 }
137
TEST(MemEnvTest,Locks)138 TEST(MemEnvTest, Locks) {
139 FileLock* lock;
140
141 // These are no-ops, but we test they return success.
142 ASSERT_OK(env_->LockFile("some file", &lock));
143 ASSERT_OK(env_->UnlockFile(lock));
144 }
145
TEST(MemEnvTest,Misc)146 TEST(MemEnvTest, Misc) {
147 std::string test_dir;
148 ASSERT_OK(env_->GetTestDirectory(&test_dir));
149 ASSERT_TRUE(!test_dir.empty());
150
151 WritableFile* writable_file;
152 ASSERT_OK(env_->NewWritableFile("/a/b", &writable_file));
153
154 // These are no-ops, but we test they return success.
155 ASSERT_OK(writable_file->Sync());
156 ASSERT_OK(writable_file->Flush());
157 ASSERT_OK(writable_file->Close());
158 delete writable_file;
159 }
160
TEST(MemEnvTest,LargeWrite)161 TEST(MemEnvTest, LargeWrite) {
162 const size_t kWriteSize = 300 * 1024;
163 char* scratch = new char[kWriteSize * 2];
164
165 std::string write_data;
166 for (size_t i = 0; i < kWriteSize; ++i) {
167 write_data.append(1, static_cast<char>(i));
168 }
169
170 WritableFile* writable_file;
171 ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file));
172 ASSERT_OK(writable_file->Append("foo"));
173 ASSERT_OK(writable_file->Append(write_data));
174 delete writable_file;
175
176 SequentialFile* seq_file;
177 Slice result;
178 ASSERT_OK(env_->NewSequentialFile("/dir/f", &seq_file));
179 ASSERT_OK(seq_file->Read(3, &result, scratch)); // Read "foo".
180 ASSERT_EQ(0, result.compare("foo"));
181
182 size_t read = 0;
183 std::string read_data;
184 while (read < kWriteSize) {
185 ASSERT_OK(seq_file->Read(kWriteSize - read, &result, scratch));
186 read_data.append(result.data(), result.size());
187 read += result.size();
188 }
189 ASSERT_TRUE(write_data == read_data);
190 delete seq_file;
191 delete [] scratch;
192 }
193
TEST(MemEnvTest,DBTest)194 TEST(MemEnvTest, DBTest) {
195 Options options;
196 options.create_if_missing = true;
197 options.env = env_;
198 DB* db;
199
200 const Slice keys[] = {Slice("aaa"), Slice("bbb"), Slice("ccc")};
201 const Slice vals[] = {Slice("foo"), Slice("bar"), Slice("baz")};
202
203 ASSERT_OK(DB::Open(options, "/dir/db", &db));
204 for (size_t i = 0; i < 3; ++i) {
205 ASSERT_OK(db->Put(WriteOptions(), keys[i], vals[i]));
206 }
207
208 for (size_t i = 0; i < 3; ++i) {
209 std::string res;
210 ASSERT_OK(db->Get(ReadOptions(), keys[i], &res));
211 ASSERT_TRUE(res == vals[i]);
212 }
213
214 Iterator* iterator = db->NewIterator(ReadOptions());
215 iterator->SeekToFirst();
216 for (size_t i = 0; i < 3; ++i) {
217 ASSERT_TRUE(iterator->Valid());
218 ASSERT_TRUE(keys[i] == iterator->key());
219 ASSERT_TRUE(vals[i] == iterator->value());
220 iterator->Next();
221 }
222 ASSERT_TRUE(!iterator->Valid());
223 delete iterator;
224
225 DBImpl* dbi = reinterpret_cast<DBImpl*>(db);
226 ASSERT_OK(dbi->TEST_CompactMemTable());
227
228 for (size_t i = 0; i < 3; ++i) {
229 std::string res;
230 ASSERT_OK(db->Get(ReadOptions(), keys[i], &res));
231 ASSERT_TRUE(res == vals[i]);
232 }
233
234 delete db;
235 }
236
237 } // namespace leveldb
238
main(int argc,char ** argv)239 int main(int argc, char** argv) {
240 return leveldb::test::RunAllTests();
241 }
242