env_test.cc raw
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/env.h"
6
7 #include <algorithm>
8
9 #include "port/port.h"
10 #include "port/thread_annotations.h"
11 #include "util/mutexlock.h"
12 #include "util/testharness.h"
13 #include "util/testutil.h"
14
15 namespace leveldb {
16
17 static const int kDelayMicros = 100000;
18
19 class EnvTest {
20 public:
21 EnvTest() : env_(Env::Default()) {}
22
23 Env* env_;
24 };
25
26 TEST(EnvTest, ReadWrite) {
27 Random rnd(test::RandomSeed());
28
29 // Get file to use for testing.
30 std::string test_dir;
31 ASSERT_OK(env_->GetTestDirectory(&test_dir));
32 std::string test_file_name = test_dir + "/open_on_read.txt";
33 WritableFile* writable_file;
34 ASSERT_OK(env_->NewWritableFile(test_file_name, &writable_file));
35
36 // Fill a file with data generated via a sequence of randomly sized writes.
37 static const size_t kDataSize = 10 * 1048576;
38 std::string data;
39 while (data.size() < kDataSize) {
40 int len = rnd.Skewed(18); // Up to 2^18 - 1, but typically much smaller
41 std::string r;
42 test::RandomString(&rnd, len, &r);
43 ASSERT_OK(writable_file->Append(r));
44 data += r;
45 if (rnd.OneIn(10)) {
46 ASSERT_OK(writable_file->Flush());
47 }
48 }
49 ASSERT_OK(writable_file->Sync());
50 ASSERT_OK(writable_file->Close());
51 delete writable_file;
52
53 // Read all data using a sequence of randomly sized reads.
54 SequentialFile* sequential_file;
55 ASSERT_OK(env_->NewSequentialFile(test_file_name, &sequential_file));
56 std::string read_result;
57 std::string scratch;
58 while (read_result.size() < data.size()) {
59 int len = std::min<int>(rnd.Skewed(18), data.size() - read_result.size());
60 scratch.resize(std::max(len, 1)); // at least 1 so &scratch[0] is legal
61 Slice read;
62 ASSERT_OK(sequential_file->Read(len, &read, &scratch[0]));
63 if (len > 0) {
64 ASSERT_GT(read.size(), 0);
65 }
66 ASSERT_LE(read.size(), len);
67 read_result.append(read.data(), read.size());
68 }
69 ASSERT_EQ(read_result, data);
70 delete sequential_file;
71 }
72
73 TEST(EnvTest, RunImmediately) {
74 struct RunState {
75 port::Mutex mu;
76 port::CondVar cvar{&mu};
77 bool called = false;
78
79 static void Run(void* arg) {
80 RunState* state = reinterpret_cast<RunState*>(arg);
81 MutexLock l(&state->mu);
82 ASSERT_EQ(state->called, false);
83 state->called = true;
84 state->cvar.Signal();
85 }
86 };
87
88 RunState state;
89 env_->Schedule(&RunState::Run, &state);
90
91 MutexLock l(&state.mu);
92 while (!state.called) {
93 state.cvar.Wait();
94 }
95 }
96
97 TEST(EnvTest, RunMany) {
98 struct RunState {
99 port::Mutex mu;
100 port::CondVar cvar{&mu};
101 int last_id = 0;
102 };
103
104 struct Callback {
105 RunState* state_; // Pointer to shared state.
106 const int id_; // Order# for the execution of this callback.
107
108 Callback(RunState* s, int id) : state_(s), id_(id) {}
109
110 static void Run(void* arg) {
111 Callback* callback = reinterpret_cast<Callback*>(arg);
112 RunState* state = callback->state_;
113
114 MutexLock l(&state->mu);
115 ASSERT_EQ(state->last_id, callback->id_ - 1);
116 state->last_id = callback->id_;
117 state->cvar.Signal();
118 }
119 };
120
121 RunState state;
122 Callback callback1(&state, 1);
123 Callback callback2(&state, 2);
124 Callback callback3(&state, 3);
125 Callback callback4(&state, 4);
126 env_->Schedule(&Callback::Run, &callback1);
127 env_->Schedule(&Callback::Run, &callback2);
128 env_->Schedule(&Callback::Run, &callback3);
129 env_->Schedule(&Callback::Run, &callback4);
130
131 MutexLock l(&state.mu);
132 while (state.last_id != 4) {
133 state.cvar.Wait();
134 }
135 }
136
137 struct State {
138 port::Mutex mu;
139 port::CondVar cvar{&mu};
140
141 int val GUARDED_BY(mu);
142 int num_running GUARDED_BY(mu);
143
144 State(int val, int num_running) : val(val), num_running(num_running) {}
145 };
146
147 static void ThreadBody(void* arg) {
148 State* s = reinterpret_cast<State*>(arg);
149 s->mu.Lock();
150 s->val += 1;
151 s->num_running -= 1;
152 s->cvar.Signal();
153 s->mu.Unlock();
154 }
155
156 TEST(EnvTest, StartThread) {
157 State state(0, 3);
158 for (int i = 0; i < 3; i++) {
159 env_->StartThread(&ThreadBody, &state);
160 }
161
162 MutexLock l(&state.mu);
163 while (state.num_running != 0) {
164 state.cvar.Wait();
165 }
166 ASSERT_EQ(state.val, 3);
167 }
168
169 TEST(EnvTest, TestOpenNonExistentFile) {
170 // Write some test data to a single file that will be opened |n| times.
171 std::string test_dir;
172 ASSERT_OK(env_->GetTestDirectory(&test_dir));
173
174 std::string non_existent_file = test_dir + "/non_existent_file";
175 ASSERT_TRUE(!env_->FileExists(non_existent_file));
176
177 RandomAccessFile* random_access_file;
178 Status status =
179 env_->NewRandomAccessFile(non_existent_file, &random_access_file);
180 ASSERT_TRUE(status.IsNotFound());
181
182 SequentialFile* sequential_file;
183 status = env_->NewSequentialFile(non_existent_file, &sequential_file);
184 ASSERT_TRUE(status.IsNotFound());
185 }
186
187 TEST(EnvTest, ReopenWritableFile) {
188 std::string test_dir;
189 ASSERT_OK(env_->GetTestDirectory(&test_dir));
190 std::string test_file_name = test_dir + "/reopen_writable_file.txt";
191 env_->DeleteFile(test_file_name);
192
193 WritableFile* writable_file;
194 ASSERT_OK(env_->NewWritableFile(test_file_name, &writable_file));
195 std::string data("hello world!");
196 ASSERT_OK(writable_file->Append(data));
197 ASSERT_OK(writable_file->Close());
198 delete writable_file;
199
200 ASSERT_OK(env_->NewWritableFile(test_file_name, &writable_file));
201 data = "42";
202 ASSERT_OK(writable_file->Append(data));
203 ASSERT_OK(writable_file->Close());
204 delete writable_file;
205
206 ASSERT_OK(ReadFileToString(env_, test_file_name, &data));
207 ASSERT_EQ(std::string("42"), data);
208 env_->DeleteFile(test_file_name);
209 }
210
211 TEST(EnvTest, ReopenAppendableFile) {
212 std::string test_dir;
213 ASSERT_OK(env_->GetTestDirectory(&test_dir));
214 std::string test_file_name = test_dir + "/reopen_appendable_file.txt";
215 env_->DeleteFile(test_file_name);
216
217 WritableFile* appendable_file;
218 ASSERT_OK(env_->NewAppendableFile(test_file_name, &appendable_file));
219 std::string data("hello world!");
220 ASSERT_OK(appendable_file->Append(data));
221 ASSERT_OK(appendable_file->Close());
222 delete appendable_file;
223
224 ASSERT_OK(env_->NewAppendableFile(test_file_name, &appendable_file));
225 data = "42";
226 ASSERT_OK(appendable_file->Append(data));
227 ASSERT_OK(appendable_file->Close());
228 delete appendable_file;
229
230 ASSERT_OK(ReadFileToString(env_, test_file_name, &data));
231 ASSERT_EQ(std::string("hello world!42"), data);
232 env_->DeleteFile(test_file_name);
233 }
234
235 } // namespace leveldb
236
237 int main(int argc, char** argv) { return leveldb::test::RunAllTests(); }
238