helpers/memenv/memenv_test.cc

   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
  20   MemEnvTest()
  21       : env_(NewMemEnv(Env::Default())) {
  22   }
  23   ~MemEnvTest() {
  24     delete env_;
  25   }
  26 };
  27
  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
  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
 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
 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
 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
 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
 239 int main(int argc, char** argv) {
 240   return leveldb::test::RunAllTests();
 241 }