text: // Copyright (c) 2013 The Merit Foundation developers
  // Copyright (c) 2013 The LevelDB Authors. All rights reserved.
  // 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.
  
  #include "leveldb/db.h"
  #include "db/db_impl.h"
  #include "leveldb/cache.h"
  #include "util/testharness.h"
  #include "util/testutil.h"
  
  namespace leveldb {
  
  class AutoCompactTest {
   public:
    std::string dbname_;
    Cache* tiny_cache_;
    Options options_;
    DB* db_;
  
    AutoCompactTest() {
      dbname_ = test::TmpDir() + "/autocompact_test";
      tiny_cache_ = NewLRUCache(100);
      options_.block_cache = tiny_cache_;
      DestroyDB(dbname_, options_);
      options_.create_if_missing = true;
      options_.compression = kNoCompression;
      ASSERT_OK(DB::Open(options_, dbname_, &db_));
    }
  
    ~AutoCompactTest() {
      delete db_;
      DestroyDB(dbname_, Options());
      delete tiny_cache_;
    }
  
    std::string Key(int i) {
      char buf[100];
      snprintf(buf, sizeof(buf), "key%06d", i);
      return std::string(buf);
    }
  
    uint64_t Size(const Slice& start, const Slice& limit) {
      Range r(start, limit);
      uint64_t size;
      db_->GetApproximateSizes(&r, 1, &size);
      return size;
    }
  
    void DoReads(int n);
  };
  
  static const int kValueSize = 200 * 1024;
  static const int kTotalSize = 100 * 1024 * 1024;
  static const int kCount = kTotalSize / kValueSize;
  
  // Read through the first n keys repeatedly and check that they get
  // compacted (verified by checking the size of the key space).
  void AutoCompactTest::DoReads(int n) {
    std::string value(kValueSize, 'x');
    DBImpl* dbi = reinterpret_cast<DBImpl*>(db_);
  
    // Fill database
    for (int i = 0; i < kCount; i++) {
      ASSERT_OK(db_->Put(WriteOptions(), Key(i), value));
    }
    ASSERT_OK(dbi->TEST_CompactMemTable());
  
    // Delete everything
    for (int i = 0; i < kCount; i++) {
      ASSERT_OK(db_->Delete(WriteOptions(), Key(i)));
    }
    ASSERT_OK(dbi->TEST_CompactMemTable());
  
    // Get initial measurement of the space we will be reading.
    const int64_t initial_size = Size(Key(0), Key(n));
    const int64_t initial_other_size = Size(Key(n), Key(kCount));
  
    // Read until size drops significantly.
    std::string limit_key = Key(n);
    for (int read = 0; true; read++) {
      ASSERT_LT(read, 100) << "Taking too long to compact";
      Iterator* iter = db_->NewIterator(ReadOptions());
      for (iter->SeekToFirst();
           iter->Valid() && iter->key().ToString() < limit_key;
           iter->Next()) {
        // Drop data
      }
      delete iter;
      // Wait a little bit to allow any triggered compactions to complete.
      Env::Default()->SleepForMicroseconds(1000000);
      uint64_t size = Size(Key(0), Key(n));
      fprintf(stderr, "iter %3d => %7.3f MB [other %7.3f MB]\n",
              read+1, size/1048576.0, Size(Key(n), Key(kCount))/1048576.0);
      if (size <= initial_size/10) {
        break;
      }
    }
  
    // Verify that the size of the key space not touched by the reads
    // is pretty much unchanged.
    const int64_t final_other_size = Size(Key(n), Key(kCount));
    ASSERT_LE(final_other_size, initial_other_size + 1048576);
    ASSERT_GE(final_other_size, initial_other_size/5 - 1048576);
  }
  
  TEST(AutoCompactTest, ReadAll) {
    DoReads(kCount);
  }
  
  TEST(AutoCompactTest, ReadHalf) {
    DoReads(kCount/2);
  }
  
  }  // namespace leveldb
  
  int main(int argc, char** argv) {
    return leveldb::test::RunAllTests();
  }
  