// Copyright (c) 2011 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.

//
// Google's cache_test.cc modified to support Riak DoubleCache
//

#include <vector>

#include "util/cache2.h"
#include "util/coding.h"
#include "util/testharness.h"

namespace leveldb {

// Conversions between numeric keys/values and the types expected by Cache.
static std::string EncodeKey(int k) {
  std::string result;
  PutFixed32(&result, k);
  return result;
}
static int DecodeKey(const Slice& k) {
  assert(k.size() == 4);
  return DecodeFixed32(k.data());
}
static void* EncodeValue(uintptr_t v) { return reinterpret_cast<void*>(v); }
static int DecodeValue(void* v) { return reinterpret_cast<uintptr_t>(v); }

class CacheTest {
 public:
  static CacheTest* current_;

  static void Deleter(const Slice& key, void* v) {
    current_->deleted_keys_.push_back(DecodeKey(key));
    current_->deleted_values_.push_back(DecodeValue(v));
  }

  static const int kOneMeg = 1024*1024L;
  static const int kCacheSize = 180;    // 180Mbytes is default
  std::vector<int> deleted_keys_;
  std::vector<int> deleted_values_;
  Options options_;

  DoubleCache double_cache_;

  Cache* cache_;
  Cache* file_;

  CacheTest()
     : double_cache_(options_)
  {
    current_ = this;
    gFlexCache.SetTotalMemory((120+kCacheSize)*kOneMeg);
    double_cache_.ResizeCaches();
    cache_=double_cache_.GetBlockCache();
    file_=double_cache_.GetFileCache();
  }

  ~CacheTest() {
  }

  void ResetCaches()
  {
    double_cache_.Flush();
    cache_=double_cache_.GetBlockCache();
    file_=double_cache_.GetFileCache();
  }

  int Lookup(int key) {
    Cache::Handle* handle = cache_->Lookup(EncodeKey(key));
    const int r = (handle == NULL) ? -1 : DecodeValue(cache_->Value(handle));
    if (handle != NULL) {
      cache_->Release(handle);
    }
    return r;
  }

  void Insert(int key, int value, int charge = 1) {
    cache_->Release(cache_->Insert(EncodeKey(key), EncodeValue(value), charge,
                                   &CacheTest::Deleter));
  }

  void InsertFile(int key, int value, int charge = 1) {
    file_->Release(file_->Insert(EncodeKey(key), EncodeValue(value), charge,
                                   &CacheTest::Deleter));
  }

  void Erase(int key) {
    cache_->Erase(EncodeKey(key));
  }
};
CacheTest* CacheTest::current_;

TEST(CacheTest, HitAndMiss) {
  ASSERT_EQ(-1, Lookup(100));

  Insert(100, 101);
  ASSERT_EQ(101, Lookup(100));
  ASSERT_EQ(-1,  Lookup(200));
  ASSERT_EQ(-1,  Lookup(300));

  Insert(200, 201);
  ASSERT_EQ(101, Lookup(100));
  ASSERT_EQ(201, Lookup(200));
  ASSERT_EQ(-1,  Lookup(300));

  Insert(100, 102);
  ASSERT_EQ(102, Lookup(100));
  ASSERT_EQ(201, Lookup(200));
  ASSERT_EQ(-1,  Lookup(300));

  ASSERT_EQ(1, deleted_keys_.size());
  ASSERT_EQ(100, deleted_keys_[0]);
  ASSERT_EQ(101, deleted_values_[0]);
}

TEST(CacheTest, Erase) {
  Erase(200);
  ASSERT_EQ(0, deleted_keys_.size());

  Insert(100, 101);
  Insert(200, 201);
  Erase(100);
  ASSERT_EQ(-1,  Lookup(100));
  ASSERT_EQ(201, Lookup(200));
  ASSERT_EQ(1, deleted_keys_.size());
  ASSERT_EQ(100, deleted_keys_[0]);
  ASSERT_EQ(101, deleted_values_[0]);

  Erase(100);
  ASSERT_EQ(-1,  Lookup(100));
  ASSERT_EQ(201, Lookup(200));
  ASSERT_EQ(1, deleted_keys_.size());
}

TEST(CacheTest, EntriesArePinned) {
  Insert(100, 101);
  Cache::Handle* h1 = cache_->Lookup(EncodeKey(100));
  ASSERT_EQ(101, DecodeValue(cache_->Value(h1)));

  Insert(100, 102);
  Cache::Handle* h2 = cache_->Lookup(EncodeKey(100));
  ASSERT_EQ(102, DecodeValue(cache_->Value(h2)));
  ASSERT_EQ(0, deleted_keys_.size());

  cache_->Release(h1);
  ASSERT_EQ(1, deleted_keys_.size());
  ASSERT_EQ(100, deleted_keys_[0]);
  ASSERT_EQ(101, deleted_values_[0]);

  Erase(100);
  ASSERT_EQ(-1, Lookup(100));
  ASSERT_EQ(1, deleted_keys_.size());

  cache_->Release(h2);
  ASSERT_EQ(2, deleted_keys_.size());
  ASSERT_EQ(100, deleted_keys_[1]);
  ASSERT_EQ(102, deleted_values_[1]);
}

TEST(CacheTest, EvictionPolicy) {
  Insert(100, 101, kOneMeg);
  Insert(200, 201, kOneMeg);
  // Frequently used entry must be kept around
  for (int i = 0; i < kCacheSize + 100; i++) {
    Insert(1000+i, 2000+i, kOneMeg);
    ASSERT_EQ(2000+i, Lookup(1000+i));
    ASSERT_EQ(101, Lookup(100));
  }
  ASSERT_EQ(101, Lookup(100));
  ASSERT_EQ(-1, Lookup(200));
}

TEST(CacheTest, HeavyEntries) {
  // Add a bunch of light and heavy entries and then count the combined
  // size of items still in the cache, which must be approximately the
  // same as the total capacity.
  const int kLight = 1;
  const int kHeavy = 10;
  int added = 0;
  int index = 0;
  while (added < 2*kCacheSize) {
    const int weight = (index & 1) ? kLight : kHeavy;
    Insert(index, 1000+index, weight*kOneMeg);
    added += weight;
    index++;
  }

  int cached_weight = 0;
  for (int i = 0; i < index; i++) {
    const int weight = (i & 1 ? kLight : kHeavy);
    int r = Lookup(i);
    if (r >= 0) {
      cached_weight += weight*kOneMeg;
      ASSERT_EQ(1000+i, r);
    }
  }
  ASSERT_LE(cached_weight, (kCacheSize + kCacheSize/10)*kOneMeg);
}

TEST(CacheTest, FlushedEntries) {
  int added = 0;
  int index = 0;
  while (added < 2*kCacheSize) {
    Insert(index, 1000+index, kOneMeg);
    added += 1;
    index++;
  }

  added=0;
  while (added < kCacheSize/2) {
    InsertFile(index, 1000+index, kOneMeg);
    added += 1;
    index++;
  }

  // one insert to block cache should rebalance both
  Insert(index, 1000+index, kOneMeg);

  int cached_weight = 0;
  for (int i = 0; i < index; i++) {
    int r = Lookup(i);
    if (r >= 0) {
      cached_weight += 1;
      ASSERT_EQ(1000+i, r);
    }
  }
  ASSERT_LE(cached_weight, (kCacheSize/2 + kCacheSize/10));
}

TEST(CacheTest, FileCacheExpire) {
    time_t expire_default;
    size_t beginning_size;

    ResetCaches();
    expire_default=double_cache_.GetFileTimeout();

    // quick two second timeout
    double_cache_.SetFileTimeout(2);

    // what is block cache's starting size
    beginning_size=double_cache_.GetCapacity(false);

    // add bunch of stuff to file cache
    int added = 0;
    int index = 0;
    while (added < kCacheSize/2) {
        InsertFile(index, 1000+index, kOneMeg);
        added += 1;
        index++;
    }   // while

    // did file cache take away?
    ASSERT_GT(beginning_size-(kCacheSize/2)*kOneMeg, double_cache_.GetCapacity(false));

    // sleep two seconds
    Env::Default()->SleepForMicroseconds(2000000);

    // force time purge
    double_cache_.PurgeExpiredFiles();

    ASSERT_EQ(beginning_size, double_cache_.GetCapacity(false));

    // add bunch of stuff to file cache with 2 second timeout
    added = 0;
    index = 0;
    while (added < kCacheSize/4) {
        InsertFile(index, 1000+index, kOneMeg);
        added += 1;
        index++;
    }   // while

    // add bunch of stuff to file cache with 5 second timeout
    double_cache_.SetFileTimeout(5);
    while (added < kCacheSize/2) {
        InsertFile(index, 1000+index, kOneMeg);
        added += 1;
        index++;
    }   // while

    // did file cache take away?
    ASSERT_GT(beginning_size-(kCacheSize/2)*kOneMeg, double_cache_.GetCapacity(false));

    // sleep two seconds
    Env::Default()->SleepForMicroseconds(2000000);

    // force time purge
    double_cache_.PurgeExpiredFiles();

    // did only half get purged
    ASSERT_GT(beginning_size-(kCacheSize/4)*kOneMeg, double_cache_.GetCapacity(false));

    // reset timeout to default
    double_cache_.SetFileTimeout(expire_default);

    return;

}   // CacheTest::FileCacheExpire


TEST(CacheTest, NewId) {
  uint64_t a = cache_->NewId();
  uint64_t b = cache_->NewId();
  ASSERT_NE(a, b);
}

}  // namespace leveldb

int main(int argc, char** argv) {
  return leveldb::test::RunAllTests();
}