@nxtedition/rocksdb 5.2.21 → 5.2.26

package/deps/rocksdb/rocksdb/env/mock_env.cc

@@ -12,20 +12,83 @@
 #include <algorithm>
 #include <chrono>
 
+#include "env/emulated_clock.h"
 #include "file/filename.h"
 #include "port/sys_time.h"
 #include "rocksdb/file_system.h"
+#include "rocksdb/utilities/options_type.h"
+#include "test_util/sync_point.h"
 #include "util/cast_util.h"
 #include "util/hash.h"
 #include "util/random.h"
 #include "util/rate_limiter.h"
+#include "util/string_util.h"
 
 namespace ROCKSDB_NAMESPACE {
+namespace {
+int64_t MaybeCurrentTime(const std::shared_ptr<SystemClock>& clock) {
+  int64_t time = 1337346000;  // arbitrary fallback default
+  clock->GetCurrentTime(&time).PermitUncheckedError();
+  return time;
+}
+
+static std::unordered_map<std::string, OptionTypeInfo> time_elapse_type_info = {
+#ifndef ROCKSDB_LITE
+    {"time_elapse_only_sleep",
+     {0, OptionType::kBoolean, OptionVerificationType::kNormal,
+      OptionTypeFlags::kCompareNever,
+      [](const ConfigOptions& /*opts*/, const std::string& /*name*/,
+         const std::string& value, void* addr) {
+        auto clock = static_cast<EmulatedSystemClock*>(addr);
+        clock->SetTimeElapseOnlySleep(ParseBoolean("", value));
+        return Status::OK();
+      },
+      [](const ConfigOptions& /*opts*/, const std::string& /*name*/,
+         const void* addr, std::string* value) {
+        const auto clock = static_cast<const EmulatedSystemClock*>(addr);
+        *value = clock->IsTimeElapseOnlySleep() ? "true" : "false";
+        return Status::OK();
+      },
+      nullptr}},
+#endif  // ROCKSDB_LITE
+};
+static std::unordered_map<std::string, OptionTypeInfo> mock_sleep_type_info = {
+#ifndef ROCKSDB_LITE
+    {"mock_sleep",
+     {0, OptionType::kBoolean, OptionVerificationType::kNormal,
+      OptionTypeFlags::kCompareNever,
+      [](const ConfigOptions& /*opts*/, const std::string& /*name*/,
+         const std::string& value, void* addr) {
+        auto clock = static_cast<EmulatedSystemClock*>(addr);
+        clock->SetMockSleep(ParseBoolean("", value));
+        return Status::OK();
+      },
+      [](const ConfigOptions& /*opts*/, const std::string& /*name*/,
+         const void* addr, std::string* value) {
+        const auto clock = static_cast<const EmulatedSystemClock*>(addr);
+        *value = clock->IsMockSleepEnabled() ? "true" : "false";
+        return Status::OK();
+      },
+      nullptr}},
+#endif  // ROCKSDB_LITE
+};
+}  // namespace
+
+EmulatedSystemClock::EmulatedSystemClock(
+    const std::shared_ptr<SystemClock>& base, bool time_elapse_only_sleep)
+    : SystemClockWrapper(base),
+      maybe_starting_time_(MaybeCurrentTime(base)),
+      time_elapse_only_sleep_(time_elapse_only_sleep),
+      no_slowdown_(time_elapse_only_sleep) {
+  RegisterOptions("", this, &time_elapse_type_info);
+  RegisterOptions("", this, &mock_sleep_type_info);
+}
 
 class MemFile {
  public:
-  explicit MemFile(Env* env, const std::string& fn, bool _is_lock_file = false)
-      : env_(env),
+  explicit MemFile(SystemClock* clock, const std::string& fn,
+                   bool _is_lock_file = false)
+      : clock_(clock),
         fn_(fn),
         refs_(0),
         is_lock_file_(_is_lock_file),
@@ -105,6 +168,15 @@ class MemFile {
 
   IOStatus Read(uint64_t offset, size_t n, const IOOptions& /*options*/,
                 Slice* result, char* scratch, IODebugContext* /*dbg*/) const {
+    {
+      IOStatus s;
+      TEST_SYNC_POINT_CALLBACK("MemFile::Read:IOStatus", &s);
+      if (!s.ok()) {
+        // with sync point only
+        *result = Slice();
+        return s;
+      }
+    }
     MutexLock lock(&mutex_);
     const uint64_t available = Size() - std::min(Size(), offset);
     size_t offset_ = static_cast<size_t>(offset);
@@ -156,7 +228,7 @@ class MemFile {
  private:
   uint64_t Now() {
     int64_t unix_time = 0;
-    auto s = env_->GetCurrentTime(&unix_time);
+    auto s = clock_->GetCurrentTime(&unix_time);
     assert(s.ok());
     return static_cast<uint64_t>(unix_time);
   }
@@ -164,7 +236,7 @@ class MemFile {
   // Private since only Unref() should be used to delete it.
   ~MemFile() { assert(refs_ == 0); }
 
-  Env* env_;
+  SystemClock* clock_;
   const std::string fn_;
   mutable port::Mutex mutex_;
   int refs_;
@@ -393,20 +465,20 @@ class TestMemLogger : public Logger {
   std::atomic_size_t log_size_;
   static const uint64_t flush_every_seconds_ = 5;
   std::atomic_uint_fast64_t last_flush_micros_;
-  Env* env_;
+  SystemClock* clock_;
   IOOptions options_;
   IODebugContext* dbg_;
   std::atomic<bool> flush_pending_;
 
  public:
-  TestMemLogger(std::unique_ptr<FSWritableFile> f, Env* env,
+  TestMemLogger(std::unique_ptr<FSWritableFile> f, SystemClock* clock,
                 const IOOptions& options, IODebugContext* dbg,
                 const InfoLogLevel log_level = InfoLogLevel::ERROR_LEVEL)
       : Logger(log_level),
         file_(std::move(f)),
         log_size_(0),
         last_flush_micros_(0),
-        env_(env),
+        clock_(clock),
         options_(options),
         dbg_(dbg),
         flush_pending_(false) {}
@@ -416,7 +488,7 @@ class TestMemLogger : public Logger {
     if (flush_pending_) {
       flush_pending_ = false;
     }
-    last_flush_micros_ = env_->NowMicros();
+    last_flush_micros_ = clock_->NowMicros();
   }
 
   using Logger::Logv;
@@ -494,128 +566,58 @@ class TestMemLogger : public Logger {
   size_t GetLogFileSize() const override { return log_size_; }
 };
 
-class MockFileSystem : public FileSystem {
- public:
-  explicit MockFileSystem(Env* env, bool supports_direct_io = true)
-      : env_(env), supports_direct_io_(supports_direct_io) {}
+static std::unordered_map<std::string, OptionTypeInfo> mock_fs_type_info = {
+#ifndef ROCKSDB_LITE
+    {"supports_direct_io",
+     {0, OptionType::kBoolean, OptionVerificationType::kNormal,
+      OptionTypeFlags::kNone}},
+#endif  // ROCKSDB_LITE
+};
+}  // namespace
 
-  ~MockFileSystem() override {
-    for (auto i = file_map_.begin(); i != file_map_.end(); ++i) {
-      i->second->Unref();
-    }
-  }
+MockFileSystem::MockFileSystem(const std::shared_ptr<SystemClock>& clock,
+                               bool supports_direct_io)
+    : system_clock_(clock), supports_direct_io_(supports_direct_io) {
+  clock_ = system_clock_.get();
+  RegisterOptions("", &supports_direct_io_, &mock_fs_type_info);
+}
 
-  const char* Name() const override { return "Memory"; }
-  IOStatus NewSequentialFile(const std::string& f, const FileOptions& file_opts,
-                             std::unique_ptr<FSSequentialFile>* r,
-                             IODebugContext* dbg) override;
-  IOStatus NewRandomAccessFile(const std::string& f,
-                               const FileOptions& file_opts,
-                               std::unique_ptr<FSRandomAccessFile>* r,
-                               IODebugContext* dbg) override;
-
-  IOStatus NewRandomRWFile(const std::string& fname,
-                           const FileOptions& file_opts,
-                           std::unique_ptr<FSRandomRWFile>* result,
-                           IODebugContext* dbg) override;
-  IOStatus ReuseWritableFile(const std::string& fname,
-                             const std::string& old_fname,
-                             const FileOptions& file_opts,
-                             std::unique_ptr<FSWritableFile>* result,
-                             IODebugContext* dbg) override;
-  IOStatus NewWritableFile(const std::string& fname,
-                           const FileOptions& file_opts,
-                           std::unique_ptr<FSWritableFile>* result,
-                           IODebugContext* dbg) override;
-  IOStatus ReopenWritableFile(const std::string& fname,
-                              const FileOptions& options,
-                              std::unique_ptr<FSWritableFile>* result,
-                              IODebugContext* dbg) override;
-  IOStatus NewDirectory(const std::string& /*name*/, const IOOptions& io_opts,
-                        std::unique_ptr<FSDirectory>* result,
-                        IODebugContext* dbg) override;
-  IOStatus FileExists(const std::string& fname, const IOOptions& /*io_opts*/,
-                      IODebugContext* /*dbg*/) override;
-  IOStatus GetChildren(const std::string& dir, const IOOptions& options,
-                       std::vector<std::string>* result,
-                       IODebugContext* dbg) override;
-  IOStatus DeleteFile(const std::string& fname, const IOOptions& options,
-                      IODebugContext* dbg) override;
-  IOStatus Truncate(const std::string& fname, size_t size,
-                    const IOOptions& options, IODebugContext* dbg) override;
-  IOStatus CreateDir(const std::string& dirname, const IOOptions& options,
-                     IODebugContext* dbg) override;
-  IOStatus CreateDirIfMissing(const std::string& dirname,
-                              const IOOptions& options,
-                              IODebugContext* dbg) override;
-  IOStatus DeleteDir(const std::string& dirname, const IOOptions& options,
-                     IODebugContext* dbg) override;
-
-  IOStatus GetFileSize(const std::string& fname, const IOOptions& options,
-                       uint64_t* file_size, IODebugContext* dbg) override;
-
-  IOStatus GetFileModificationTime(const std::string& fname,
-                                   const IOOptions& options,
-                                   uint64_t* file_mtime,
-                                   IODebugContext* dbg) override;
-  IOStatus RenameFile(const std::string& src, const std::string& target,
-                      const IOOptions& options, IODebugContext* dbg) override;
-  IOStatus LinkFile(const std::string& /*src*/, const std::string& /*target*/,
-                    const IOOptions& /*options*/,
-                    IODebugContext* /*dbg*/) override;
-  IOStatus LockFile(const std::string& fname, const IOOptions& options,
-                    FileLock** lock, IODebugContext* dbg) override;
-  IOStatus UnlockFile(FileLock* lock, const IOOptions& options,
-                      IODebugContext* dbg) override;
-  IOStatus GetTestDirectory(const IOOptions& options, std::string* path,
-                            IODebugContext* dbg) override;
-  IOStatus NewLogger(const std::string& fname, const IOOptions& io_opts,
-                     std::shared_ptr<Logger>* result,
-                     IODebugContext* dbg) override;
-  // Get full directory name for this db.
-  IOStatus GetAbsolutePath(const std::string& db_path,
-                           const IOOptions& /*options*/,
-                           std::string* output_path,
-                           IODebugContext* /*dbg*/) override {
-    *output_path = NormalizeMockPath(db_path);
-    if (output_path->at(0) != '/') {
-      return IOStatus::NotSupported("GetAbsolutePath");
-    } else {
-      return IOStatus::OK();
-    }
-  }
-  IOStatus IsDirectory(const std::string& /*path*/,
-                       const IOOptions& /*options*/, bool* /*is_dir*/,
-                       IODebugContext* /*dgb*/) override {
-    return IOStatus::NotSupported("IsDirectory");
+MockFileSystem::~MockFileSystem() {
+  for (auto i = file_map_.begin(); i != file_map_.end(); ++i) {
+    i->second->Unref();
   }
+}
 
-  Status CorruptBuffer(const std::string& fname);
+Status MockFileSystem::PrepareOptions(const ConfigOptions& options) {
+  Status s = FileSystem::PrepareOptions(options);
+  if (s.ok() && system_clock_ == SystemClock::Default()) {
+    system_clock_ = options.env->GetSystemClock();
+    clock_ = system_clock_.get();
+  }
+  return s;
+}
 
- private:
-  bool RenameFileInternal(const std::string& src, const std::string& dest);
-  void DeleteFileInternal(const std::string& fname);
-  bool GetChildrenInternal(const std::string& fname,
-                           std::vector<std::string>* results);
-
-  std::string NormalizeMockPath(const std::string& path) {
-    std::string p = NormalizePath(path);
-    if (p.back() == kFilePathSeparator && p.size() > 1) {
-      p.pop_back();
-    }
-    return p;
+IOStatus MockFileSystem::GetAbsolutePath(const std::string& db_path,
+                                         const IOOptions& /*options*/,
+                                         std::string* output_path,
+                                         IODebugContext* /*dbg*/) {
+  *output_path = NormalizeMockPath(db_path);
+  if (output_path->at(0) != '/') {
+    return IOStatus::NotSupported("GetAbsolutePath");
+  } else {
+    return IOStatus::OK();
   }
+}
 
- private:
-  // Map from filenames to MemFile objects, representing a simple file system.
-  port::Mutex mutex_;
-  std::map<std::string, MemFile*> file_map_;  // Protected by mutex_.
-  Env* env_;
-  bool supports_direct_io_;
-};
+std::string MockFileSystem::NormalizeMockPath(const std::string& path) {
+  std::string p = NormalizePath(path);
+  if (p.back() == kFilePathSeparator && p.size() > 1) {
+    p.pop_back();
+  }
+  return p;
+}
 
-}  // Anonymous namespace
-// Partial implementation of the Env interface.
+// Partial implementation of the FileSystem interface.
 IOStatus MockFileSystem::NewSequentialFile(
     const std::string& fname, const FileOptions& file_opts,
     std::unique_ptr<FSSequentialFile>* result, IODebugContext* /*dbg*/) {
@@ -695,7 +697,7 @@ IOStatus MockFileSystem::NewWritableFile(
   if (file_map_.find(fn) != file_map_.end()) {
     DeleteFileInternal(fn);
   }
-  MemFile* file = new MemFile(env_, fn, false);
+  MemFile* file = new MemFile(clock_, fn, false);
   file->Ref();
   file_map_[fn] = file;
   if (file_opts.use_direct_writes && !supports_direct_io_) {
@@ -713,12 +715,13 @@ IOStatus MockFileSystem::ReopenWritableFile(
   MutexLock lock(&mutex_);
   MemFile* file = nullptr;
   if (file_map_.find(fn) == file_map_.end()) {
-    file = new MemFile(env_, fn, false);
+    file = new MemFile(clock_, fn, false);
+    // Only take a reference when we create the file objectt
+    file->Ref();
     file_map_[fn] = file;
   } else {
     file = file_map_[fn];
   }
-  file->Ref();
   if (file_opts.use_direct_writes && !supports_direct_io_) {
     return IOStatus::NotSupported("Direct I/O Not Supported");
   } else {
@@ -787,7 +790,11 @@ IOStatus MockFileSystem::GetChildren(const std::string& dir,
                                      IODebugContext* /*dbg*/) {
   MutexLock lock(&mutex_);
   bool found_dir = GetChildrenInternal(dir, result);
+#ifndef __clang_analyzer__
   return found_dir ? IOStatus::OK() : IOStatus::NotFound(dir);
+#else
+  return found_dir ? IOStatus::OK() : IOStatus::NotFound();
+#endif
 }
 
 void MockFileSystem::DeleteFileInternal(const std::string& fname) {
@@ -831,7 +838,7 @@ IOStatus MockFileSystem::CreateDir(const std::string& dirname,
   auto dn = NormalizeMockPath(dirname);
   MutexLock lock(&mutex_);
   if (file_map_.find(dn) == file_map_.end()) {
-    MemFile* file = new MemFile(env_, dn, false);
+    MemFile* file = new MemFile(clock_, dn, false);
     file->Ref();
     file_map_[dn] = file;
   } else {
@@ -954,14 +961,14 @@ IOStatus MockFileSystem::NewLogger(const std::string& fname,
   auto iter = file_map_.find(fn);
   MemFile* file = nullptr;
   if (iter == file_map_.end()) {
-    file = new MemFile(env_, fn, false);
+    file = new MemFile(clock_, fn, false);
     file->Ref();
     file_map_[fn] = file;
   } else {
     file = iter->second;
   }
   std::unique_ptr<FSWritableFile> f(new MockWritableFile(file, FileOptions()));
-  result->reset(new TestMemLogger(std::move(f), env_, io_opts, dbg));
+  result->reset(new TestMemLogger(std::move(f), clock_, io_opts, dbg));
   return IOStatus::OK();
 }
 
@@ -979,7 +986,7 @@ IOStatus MockFileSystem::LockFile(const std::string& fname,
         return IOStatus::IOError(fn, "lock is already held.");
       }
     } else {
-      auto* file = new MemFile(env_, fn, true);
+      auto* file = new MemFile(clock_, fn, true);
       file->Ref();
       file->Lock();
       file_map_[fn] = file;
@@ -1024,24 +1031,19 @@ Status MockFileSystem::CorruptBuffer(const std::string& fname) {
   return Status::OK();
 }
 
-MockEnv::MockEnv(Env* base_env)
-    : CompositeEnvWrapper(base_env, std::make_shared<MockFileSystem>(this)),
-      fake_sleep_micros_(0) {}
+MockEnv::MockEnv(Env* env, const std::shared_ptr<FileSystem>& fs,
+                 const std::shared_ptr<SystemClock>& clock)
+    : CompositeEnvWrapper(env, fs, clock) {}
 
-Status MockEnv::GetCurrentTime(int64_t* unix_time) {
-  auto s = CompositeEnvWrapper::GetCurrentTime(unix_time);
-  if (s.ok()) {
-    *unix_time += fake_sleep_micros_.load() / (1000 * 1000);
-  }
-  return s;
-}
-
-uint64_t MockEnv::NowMicros() {
-  return CompositeEnvWrapper::NowMicros() + fake_sleep_micros_.load();
+MockEnv* MockEnv::Create(Env* env) {
+  auto clock =
+      std::make_shared<EmulatedSystemClock>(env->GetSystemClock(), true);
+  return MockEnv::Create(env, clock);
 }
 
-uint64_t MockEnv::NowNanos() {
-  return CompositeEnvWrapper::NowNanos() + fake_sleep_micros_.load() * 1000;
+MockEnv* MockEnv::Create(Env* env, const std::shared_ptr<SystemClock>& clock) {
+  auto fs = std::make_shared<MockFileSystem>(clock);
+  return new MockEnv(env, fs, clock);
 }
 
 Status MockEnv::CorruptBuffer(const std::string& fname) {
@@ -1049,13 +1051,9 @@ Status MockEnv::CorruptBuffer(const std::string& fname) {
   return mock->CorruptBuffer(fname);
 }
 
-void MockEnv::FakeSleepForMicroseconds(int64_t micros) {
-  fake_sleep_micros_.fetch_add(micros);
-}
-
 #ifndef ROCKSDB_LITE
 // This is to maintain the behavior before swithcing from InMemoryEnv to MockEnv
-Env* NewMemEnv(Env* base_env) { return new MockEnv(base_env); }
+Env* NewMemEnv(Env* base_env) { return MockEnv::Create(base_env); }
 
 #else  // ROCKSDB_LITE
 

package/deps/rocksdb/rocksdb/env/mock_env.h

@@ -14,28 +14,130 @@
 #include <vector>
 
 #include "env/composite_env_wrapper.h"
+#include "port/port.h"
 #include "rocksdb/env.h"
 #include "rocksdb/status.h"
+#include "rocksdb/system_clock.h"
 
 namespace ROCKSDB_NAMESPACE {
-
-class MockEnv : public CompositeEnvWrapper {
+class MemFile;
+class MockFileSystem : public FileSystem {
  public:
-  explicit MockEnv(Env* base_env);
+  explicit MockFileSystem(const std::shared_ptr<SystemClock>& clock,
+                          bool supports_direct_io = true);
+  ~MockFileSystem() override;
+
+  static const char* kClassName() { return "MemoryFileSystem"; }
+  const char* Name() const override { return kClassName(); }
+  IOStatus NewSequentialFile(const std::string& f, const FileOptions& file_opts,
+                             std::unique_ptr<FSSequentialFile>* r,
+                             IODebugContext* dbg) override;
+  IOStatus NewRandomAccessFile(const std::string& f,
+                               const FileOptions& file_opts,
+                               std::unique_ptr<FSRandomAccessFile>* r,
+                               IODebugContext* dbg) override;
+
+  IOStatus NewRandomRWFile(const std::string& fname,
+                           const FileOptions& file_opts,
+                           std::unique_ptr<FSRandomRWFile>* result,
+                           IODebugContext* dbg) override;
+  IOStatus ReuseWritableFile(const std::string& fname,
+                             const std::string& old_fname,
+                             const FileOptions& file_opts,
+                             std::unique_ptr<FSWritableFile>* result,
+                             IODebugContext* dbg) override;
+  IOStatus NewWritableFile(const std::string& fname,
+                           const FileOptions& file_opts,
+                           std::unique_ptr<FSWritableFile>* result,
+                           IODebugContext* dbg) override;
+  IOStatus ReopenWritableFile(const std::string& fname,
+                              const FileOptions& options,
+                              std::unique_ptr<FSWritableFile>* result,
+                              IODebugContext* dbg) override;
+  IOStatus NewDirectory(const std::string& /*name*/, const IOOptions& io_opts,
+                        std::unique_ptr<FSDirectory>* result,
+                        IODebugContext* dbg) override;
+  IOStatus FileExists(const std::string& fname, const IOOptions& /*io_opts*/,
+                      IODebugContext* /*dbg*/) override;
+  IOStatus GetChildren(const std::string& dir, const IOOptions& options,
+                       std::vector<std::string>* result,
+                       IODebugContext* dbg) override;
+  IOStatus DeleteFile(const std::string& fname, const IOOptions& options,
+                      IODebugContext* dbg) override;
+  IOStatus Truncate(const std::string& fname, size_t size,
+                    const IOOptions& options, IODebugContext* dbg) override;
+  IOStatus CreateDir(const std::string& dirname, const IOOptions& options,
+                     IODebugContext* dbg) override;
+  IOStatus CreateDirIfMissing(const std::string& dirname,
+                              const IOOptions& options,
+                              IODebugContext* dbg) override;
+  IOStatus DeleteDir(const std::string& dirname, const IOOptions& options,
+                     IODebugContext* dbg) override;
 
-  // Results of these can be affected by FakeSleepForMicroseconds()
-  Status GetCurrentTime(int64_t* unix_time) override;
-  uint64_t NowMicros() override;
-  uint64_t NowNanos() override;
+  IOStatus GetFileSize(const std::string& fname, const IOOptions& options,
+                       uint64_t* file_size, IODebugContext* dbg) override;
+
+  IOStatus GetFileModificationTime(const std::string& fname,
+                                   const IOOptions& options,
+                                   uint64_t* file_mtime,
+                                   IODebugContext* dbg) override;
+  IOStatus RenameFile(const std::string& src, const std::string& target,
+                      const IOOptions& options, IODebugContext* dbg) override;
+  IOStatus LinkFile(const std::string& /*src*/, const std::string& /*target*/,
+                    const IOOptions& /*options*/,
+                    IODebugContext* /*dbg*/) override;
+  IOStatus LockFile(const std::string& fname, const IOOptions& options,
+                    FileLock** lock, IODebugContext* dbg) override;
+  IOStatus UnlockFile(FileLock* lock, const IOOptions& options,
+                      IODebugContext* dbg) override;
+  IOStatus GetTestDirectory(const IOOptions& options, std::string* path,
+                            IODebugContext* dbg) override;
+  IOStatus NewLogger(const std::string& fname, const IOOptions& io_opts,
+                     std::shared_ptr<Logger>* result,
+                     IODebugContext* dbg) override;
+  // Get full directory name for this db.
+  IOStatus GetAbsolutePath(const std::string& db_path,
+                           const IOOptions& /*options*/,
+                           std::string* output_path,
+                           IODebugContext* /*dbg*/) override;
+  IOStatus IsDirectory(const std::string& /*path*/,
+                       const IOOptions& /*options*/, bool* /*is_dir*/,
+                       IODebugContext* /*dgb*/) override {
+    return IOStatus::NotSupported("IsDirectory");
+  }
 
   Status CorruptBuffer(const std::string& fname);
+  Status PrepareOptions(const ConfigOptions& options) override;
+
+ private:
+  bool RenameFileInternal(const std::string& src, const std::string& dest);
+  void DeleteFileInternal(const std::string& fname);
+  bool GetChildrenInternal(const std::string& fname,
+                           std::vector<std::string>* results);
 
-  // Doesn't really sleep, just affects output of GetCurrentTime(), NowMicros()
-  // and NowNanos()
-  void FakeSleepForMicroseconds(int64_t micros);
+  std::string NormalizeMockPath(const std::string& path);
 
  private:
-  std::atomic<int64_t> fake_sleep_micros_;
+  // Map from filenames to MemFile objects, representing a simple file system.
+  port::Mutex mutex_;
+  std::map<std::string, MemFile*> file_map_;  // Protected by mutex_.
+  std::shared_ptr<SystemClock> system_clock_;
+  SystemClock* clock_;
+  bool supports_direct_io_;
+};
+
+class MockEnv : public CompositeEnvWrapper {
+ public:
+  static MockEnv* Create(Env* base);
+  static MockEnv* Create(Env* base, const std::shared_ptr<SystemClock>& clock);
+
+  static const char* kClassName() { return "MockEnv"; }
+  const char* Name() const override { return kClassName(); }
+
+  Status CorruptBuffer(const std::string& fname);
+ private:
+  MockEnv(Env* env, const std::shared_ptr<FileSystem>& fs,
+          const std::shared_ptr<SystemClock>& clock);
 };
 
 }  // namespace ROCKSDB_NAMESPACE

package/deps/rocksdb/rocksdb/env/mock_env_test.cc

@@ -19,9 +19,7 @@ class MockEnvTest : public testing::Test {
   MockEnv* env_;
   const EnvOptions soptions_;
 
-  MockEnvTest()
-      : env_(new MockEnv(Env::Default())) {
-  }
+  MockEnvTest() : env_(MockEnv::Create(Env::Default())) {}
   ~MockEnvTest() override { delete env_; }
 };
 
@@ -68,7 +66,7 @@ TEST_F(MockEnvTest, FakeSleeping) {
   int64_t now = 0;
   auto s = env_->GetCurrentTime(&now);
   ASSERT_OK(s);
-  env_->FakeSleepForMicroseconds(3 * 1000 * 1000);
+  env_->SleepForMicroseconds(3 * 1000 * 1000);
   int64_t after_sleep = 0;
   s = env_->GetCurrentTime(&after_sleep);
   ASSERT_OK(s);