NextGraph
/
rocksdb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Create env_basic_test [pluggable Env part 2]

Browse Source 
Summary:
Extracted basic Env-related tests from mock_env_test and memenv_test into a
parameterized test for Envs: env_basic_test.

Depends on D58449. (The dependency is here only so I can keep this series of
diffs in a chain -- there is no dependency on that diff's code.)

Test Plan: ran tests

Reviewers: IslamAbdelRahman, sdong

Reviewed By: sdong

Subscribers: andrewkr, dhruba, leveldb

Differential Revision: https://reviews.facebook.net/D58635
main
Andrew Kryczka 9 years ago
parent e532877940
commit 6e6622abb9
5 changed files with 39 additions and 200 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 2
      CMakeLists.txt
  2. 8
      Makefile
  3. 2
      src.mk
  4. 49
      util/env_basic_test.cc
  5. 162
      util/mock_env_test.cc

2
CMakeLists.txt
Unescape View File

@ -403,6 +403,7 @@ set(TESTS
util/crc32c_test.cc util/crc32c_test.cc
util/delete_scheduler_test.cc util/delete_scheduler_test.cc
util/dynamic_bloom_test.cc util/dynamic_bloom_test.cc
util/env_basic_test.cc
util/env_test.cc util/env_test.cc
util/event_logger_test.cc util/event_logger_test.cc
util/filelock_test.cc util/filelock_test.cc
@ -410,7 +411,6 @@ set(TESTS
util/heap_test.cc util/heap_test.cc
util/histogram_test.cc util/histogram_test.cc
util/iostats_context_test.cc util/iostats_context_test.cc
util/memenv_test.cc
util/mock_env_test.cc util/mock_env_test.cc
util/options_settable_test.cc util/options_settable_test.cc
util/options_test.cc util/options_test.cc

8
Makefile
Unescape View File

@ -290,6 +290,7 @@ TESTS = \
crc32c_test \ crc32c_test \
slice_transform_test \ slice_transform_test \
dbformat_test \ dbformat_test \
env_basic_test \
env_test \ env_test \
fault_injection_test \ fault_injection_test \
filelock_test \ filelock_test \
@ -302,7 +303,6 @@ TESTS = \
inlineskiplist_test \ inlineskiplist_test \
log_test \ log_test \
manual_compaction_test \ manual_compaction_test \
memenv_test \
mock_env_test \ mock_env_test \
memtable_list_test \ memtable_list_test \
merge_helper_test \ merge_helper_test \
@ -1000,6 +1000,9 @@ wal_manager_test: db/wal_manager_test.o $(LIBOBJECTS) $(TESTHARNESS)
dbformat_test: db/dbformat_test.o $(LIBOBJECTS) $(TESTHARNESS) dbformat_test: db/dbformat_test.o $(LIBOBJECTS) $(TESTHARNESS)
$(AM_LINK) $(AM_LINK)
env_basic_test: util/env_basic_test.o $(LIBOBJECTS) $(TESTHARNESS)
$(AM_LINK)
env_test: util/env_test.o $(LIBOBJECTS) $(TESTHARNESS) env_test: util/env_test.o $(LIBOBJECTS) $(TESTHARNESS)
$(AM_LINK) $(AM_LINK)
@ -1129,9 +1132,6 @@ event_logger_test: util/event_logger_test.o $(LIBOBJECTS) $(TESTHARNESS)
sst_dump_test: tools/sst_dump_test.o $(LIBOBJECTS) $(TESTHARNESS) sst_dump_test: tools/sst_dump_test.o $(LIBOBJECTS) $(TESTHARNESS)
$(AM_LINK) $(AM_LINK)
memenv_test : util/memenv_test.o $(LIBOBJECTS) $(TESTHARNESS)
$(AM_LINK)
optimistic_transaction_test: utilities/transactions/optimistic_transaction_test.o $(LIBOBJECTS) $(TESTHARNESS) optimistic_transaction_test: utilities/transactions/optimistic_transaction_test.o $(LIBOBJECTS) $(TESTHARNESS)
$(AM_LINK) $(AM_LINK)

2
src.mk
Unescape View File

@ -263,6 +263,7 @@ TEST_BENCH_SOURCES = \
util/coding_test.cc \ util/coding_test.cc \
util/crc32c_test.cc \ util/crc32c_test.cc \
util/dynamic_bloom_test.cc \ util/dynamic_bloom_test.cc \
util/env_basic_test.cc \
util/env_test.cc \ util/env_test.cc \
util/filelock_test.cc \ util/filelock_test.cc \
util/histogram_test.cc \ util/histogram_test.cc \
@ -285,7 +286,6 @@ TEST_BENCH_SOURCES = \
utilities/write_batch_with_index/write_batch_with_index_test.cc \ utilities/write_batch_with_index/write_batch_with_index_test.cc \
util/iostats_context_test.cc \ util/iostats_context_test.cc \
util/log_write_bench.cc \ util/log_write_bench.cc \
util/memenv_test.cc \
util/mock_env_test.cc \ util/mock_env_test.cc \
util/options_test.cc \ util/options_test.cc \
util/event_logger_test.cc \ util/event_logger_test.cc \

49
util/memenv_test.cc → util/env_basic_test.cc
Unescape View File

@ -2,31 +2,36 @@
// Use of this source code is governed by a BSD-style license that can be // 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. // found in the LICENSE file. See the AUTHORS file for names of contributors.
#ifndef ROCKSDB_LITE
#include "rocksdb/db.h"
#include "rocksdb/env.h"
#include "util/testharness.h"
#include <memory> #include <memory>
#include <string> #include <string>
#include <vector> #include <vector>
#include "rocksdb/env.h"
#include "util/mock_env.h"
#include "util/testharness.h"
namespace rocksdb { namespace rocksdb {
class MemEnvTest : public testing::Test { class EnvBasicTestWithParam : public testing::Test,
public ::testing::WithParamInterface<Env*> {
public: public:
Env* env_; Env* env_;
const EnvOptions soptions_; const EnvOptions soptions_;
MemEnvTest() EnvBasicTestWithParam() { env_ = GetParam(); }
: env_(NewMemEnv(Env::Default())) {
}
~MemEnvTest() {
delete env_;
}
}; };
TEST_F(MemEnvTest, Basics) { static std::unique_ptr<Env> mock_env(new MockEnv(Env::Default()));
INSTANTIATE_TEST_CASE_P(
MockEnv, EnvBasicTestWithParam,
::testing::Values(mock_env.get()));
#ifndef ROCKSDB_LITE
static std::unique_ptr<Env> mem_env(NewMemEnv(Env::Default()));
INSTANTIATE_TEST_CASE_P(MemEnv, EnvBasicTestWithParam,
::testing::Values(mem_env.get()));
#endif // ROCKSDB_LITE
TEST_P(EnvBasicTestWithParam, Basics) {
uint64_t file_size; uint64_t file_size;
unique_ptr<WritableFile> writable_file; unique_ptr<WritableFile> writable_file;
std::vector<std::string> children; std::vector<std::string> children;
@ -87,7 +92,7 @@ TEST_F(MemEnvTest, Basics) {
ASSERT_OK(env_->DeleteDir("/dir")); ASSERT_OK(env_->DeleteDir("/dir"));
} }
TEST_F(MemEnvTest, ReadWrite) { TEST_P(EnvBasicTestWithParam, ReadWrite) {
unique_ptr<WritableFile> writable_file; unique_ptr<WritableFile> writable_file;
unique_ptr<SequentialFile> seq_file; unique_ptr<SequentialFile> seq_file;
unique_ptr<RandomAccessFile> rand_file; unique_ptr<RandomAccessFile> rand_file;
@ -127,7 +132,7 @@ TEST_F(MemEnvTest, ReadWrite) {
ASSERT_TRUE(rand_file->Read(1000, 5, &result, scratch).ok()); ASSERT_TRUE(rand_file->Read(1000, 5, &result, scratch).ok());
} }
TEST_F(MemEnvTest, Locks) { TEST_P(EnvBasicTestWithParam, Locks) {
FileLock* lock; FileLock* lock;
// These are no-ops, but we test they return success. // These are no-ops, but we test they return success.
@ -135,7 +140,7 @@ TEST_F(MemEnvTest, Locks) {
ASSERT_OK(env_->UnlockFile(lock)); ASSERT_OK(env_->UnlockFile(lock));
} }
TEST_F(MemEnvTest, Misc) { TEST_P(EnvBasicTestWithParam, Misc) {
std::string test_dir; std::string test_dir;
ASSERT_OK(env_->GetTestDirectory(&test_dir)); ASSERT_OK(env_->GetTestDirectory(&test_dir));
ASSERT_TRUE(!test_dir.empty()); ASSERT_TRUE(!test_dir.empty());
@ -150,7 +155,7 @@ TEST_F(MemEnvTest, Misc) {
writable_file.reset(); writable_file.reset();
} }
TEST_F(MemEnvTest, LargeWrite) { TEST_P(EnvBasicTestWithParam, LargeWrite) {
const size_t kWriteSize = 300 * 1024; const size_t kWriteSize = 300 * 1024;
char* scratch = new char[kWriteSize * 2]; char* scratch = new char[kWriteSize * 2];
@ -188,13 +193,3 @@ int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv); ::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS(); return RUN_ALL_TESTS();
} }
#else
#include <stdio.h>
int main(int argc, char** argv) {
fprintf(stderr, "SKIPPED as MemEnv is not supported in ROCKSDB_LITE\n");
return 0;
}
#endif // !ROCKSDB_LITE

162
util/mock_env_test.cc
Unescape View File

@ -2,11 +2,11 @@
// Use of this source code is governed by a BSD-style license that can be // 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. // found in the LICENSE file. See the AUTHORS file for names of contributors.
#include "util/mock_env.h"
#include <memory> #include <memory>
#include <string> #include <string>
#include <vector>
#include "util/mock_env.h"
#include "rocksdb/db.h"
#include "rocksdb/env.h" #include "rocksdb/env.h"
#include "util/testharness.h" #include "util/testharness.h"
@ -25,162 +25,6 @@ class MockEnvTest : public testing::Test {
} }
}; };
TEST_F(MockEnvTest, Basics) {
uint64_t file_size;
unique_ptr<WritableFile> writable_file;
std::vector<std::string> children;
ASSERT_OK(env_->CreateDir("/dir"));
// Check that the directory is empty.
ASSERT_EQ(Status::NotFound(), env_->FileExists("/dir/non_existent"));
ASSERT_TRUE(!env_->GetFileSize("/dir/non_existent", &file_size).ok());
ASSERT_OK(env_->GetChildren("/dir", &children));
ASSERT_EQ(0U, children.size());
// Create a file.
ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file, soptions_));
writable_file.reset();
// Check that the file exists.
ASSERT_OK(env_->FileExists("/dir/f"));
ASSERT_OK(env_->GetFileSize("/dir/f", &file_size));
ASSERT_EQ(0U, file_size);
ASSERT_OK(env_->GetChildren("/dir", &children));
ASSERT_EQ(1U, children.size());
ASSERT_EQ("f", children[0]);
// Write to the file.
ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file, soptions_));
ASSERT_OK(writable_file->Append("abc"));
writable_file.reset();
// Check for expected size.
ASSERT_OK(env_->GetFileSize("/dir/f", &file_size));
ASSERT_EQ(3U, file_size);
// Check that renaming works.
ASSERT_TRUE(!env_->RenameFile("/dir/non_existent", "/dir/g").ok());
ASSERT_OK(env_->RenameFile("/dir/f", "/dir/g"));
ASSERT_EQ(Status::NotFound(), env_->FileExists("/dir/f"));
ASSERT_OK(env_->FileExists("/dir/g"));
ASSERT_OK(env_->GetFileSize("/dir/g", &file_size));
ASSERT_EQ(3U, file_size);
// Check that opening non-existent file fails.
unique_ptr<SequentialFile> seq_file;
unique_ptr<RandomAccessFile> rand_file;
ASSERT_TRUE(!env_->NewSequentialFile("/dir/non_existent", &seq_file,
soptions_).ok());
ASSERT_TRUE(!seq_file);
ASSERT_TRUE(!env_->NewRandomAccessFile("/dir/non_existent", &rand_file,
soptions_).ok());
ASSERT_TRUE(!rand_file);
// Check that deleting works.
ASSERT_TRUE(!env_->DeleteFile("/dir/non_existent").ok());
ASSERT_OK(env_->DeleteFile("/dir/g"));
ASSERT_EQ(Status::NotFound(), env_->FileExists("/dir/g"));
ASSERT_OK(env_->GetChildren("/dir", &children));
ASSERT_EQ(0U, children.size());
ASSERT_OK(env_->DeleteDir("/dir"));
}
TEST_F(MockEnvTest, ReadWrite) {
unique_ptr<WritableFile> writable_file;
unique_ptr<SequentialFile> seq_file;
unique_ptr<RandomAccessFile> rand_file;
Slice result;
char scratch[100];
ASSERT_OK(env_->CreateDir("/dir"));
ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file, soptions_));
ASSERT_OK(writable_file->Append("hello "));
ASSERT_OK(writable_file->Append("world"));
writable_file.reset();
// Read sequentially.
ASSERT_OK(env_->NewSequentialFile("/dir/f", &seq_file, soptions_));
ASSERT_OK(seq_file->Read(5, &result, scratch)); // Read "hello".
ASSERT_EQ(0, result.compare("hello"));
ASSERT_OK(seq_file->Skip(1));
ASSERT_OK(seq_file->Read(1000, &result, scratch)); // Read "world".
ASSERT_EQ(0, result.compare("world"));
ASSERT_OK(seq_file->Read(1000, &result, scratch)); // Try reading past EOF.
ASSERT_EQ(0U, result.size());
ASSERT_OK(seq_file->Skip(100)); // Try to skip past end of file.
ASSERT_OK(seq_file->Read(1000, &result, scratch));
ASSERT_EQ(0U, result.size());
// Random reads.
ASSERT_OK(env_->NewRandomAccessFile("/dir/f", &rand_file, soptions_));
ASSERT_OK(rand_file->Read(6, 5, &result, scratch)); // Read "world".
ASSERT_EQ(0, result.compare("world"));
ASSERT_OK(rand_file->Read(0, 5, &result, scratch)); // Read "hello".
ASSERT_EQ(0, result.compare("hello"));
ASSERT_OK(rand_file->Read(10, 100, &result, scratch)); // Read "d".
ASSERT_EQ(0, result.compare("d"));
// Too high offset.
ASSERT_TRUE(rand_file->Read(1000, 5, &result, scratch).ok());
}
TEST_F(MockEnvTest, Locks) {
FileLock* lock;
// These are no-ops, but we test they return success.
ASSERT_OK(env_->LockFile("some file", &lock));
ASSERT_OK(env_->UnlockFile(lock));
}
TEST_F(MockEnvTest, Misc) {
std::string test_dir;
ASSERT_OK(env_->GetTestDirectory(&test_dir));
ASSERT_TRUE(!test_dir.empty());
unique_ptr<WritableFile> writable_file;
ASSERT_OK(env_->NewWritableFile("/a/b", &writable_file, soptions_));
// These are no-ops, but we test they return success.
ASSERT_OK(writable_file->Sync());
ASSERT_OK(writable_file->Flush());
ASSERT_OK(writable_file->Close());
writable_file.reset();
}
TEST_F(MockEnvTest, LargeWrite) {
const size_t kWriteSize = 300 * 1024;
char* scratch = new char[kWriteSize * 2];
std::string write_data;
for (size_t i = 0; i < kWriteSize; ++i) {
write_data.append(1, static_cast<char>(i));
}
unique_ptr<WritableFile> writable_file;
ASSERT_OK(env_->NewWritableFile("/dir/f", &writable_file, soptions_));
ASSERT_OK(writable_file->Append("foo"));
ASSERT_OK(writable_file->Append(write_data));
writable_file.reset();
unique_ptr<SequentialFile> seq_file;
Slice result;
ASSERT_OK(env_->NewSequentialFile("/dir/f", &seq_file, soptions_));
ASSERT_OK(seq_file->Read(3, &result, scratch)); // Read "foo".
ASSERT_EQ(0, result.compare("foo"));
size_t read = 0;
std::string read_data;
while (read < kWriteSize) {
ASSERT_OK(seq_file->Read(kWriteSize - read, &result, scratch));
read_data.append(result.data(), result.size());
read += result.size();
}
ASSERT_TRUE(write_data == read_data);
delete [] scratch;
}
TEST_F(MockEnvTest, Corrupt) { TEST_F(MockEnvTest, Corrupt) {
const std::string kGood = "this is a good string, synced to disk"; const std::string kGood = "this is a good string, synced to disk";
const std::string kCorrupted = "this part may be corrupted"; const std::string kCorrupted = "this part may be corrupted";

Write Preview
Loading…
Cancel
Save