�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2F'>storage</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2F'>rocksdb</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2Frocksdb%2F'>rocksdb</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2Frocksdb%2Fcache%2F'>cache</a>/</p><hr><h3>✏️ Editing: cache_test.cc</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
//  This source code is licensed under both the GPLv2 (found in the
//  COPYING file in the root directory) and Apache 2.0 License
//  (found in the LICENSE.Apache file in the root directory).
//
// 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.

#include &quot;rocksdb/cache.h&quot;

#include &lt;forward_list&gt;
#include &lt;functional&gt;
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;vector&gt;
#include &quot;cache/clock_cache.h&quot;
#include &quot;cache/lru_cache.h&quot;
#include &quot;test_util/testharness.h&quot;
#include &quot;util/coding.h&quot;
#include &quot;util/string_util.h&quot;

namespace ROCKSDB_NAMESPACE {

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

const std::string kLRU = &quot;lru&quot;;
const std::string kClock = &quot;clock&quot;;

void dumbDeleter(const Slice&amp; /*key*/, void* /*value*/) {}

void eraseDeleter(const Slice&amp; /*key*/, void* value) {
  Cache* cache = reinterpret_cast&lt;Cache*&gt;(value);
  cache-&gt;Erase(&quot;foo&quot;);
}

class CacheTest : public testing::TestWithParam&lt;std::string&gt; {
 public:
  static CacheTest* current_;

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

  static const int kCacheSize = 1000;
  static const int kNumShardBits = 4;

  static const int kCacheSize2 = 100;
  static const int kNumShardBits2 = 2;

  std::vector&lt;int&gt; deleted_keys_;
  std::vector&lt;int&gt; deleted_values_;
  std::shared_ptr&lt;Cache&gt; cache_;
  std::shared_ptr&lt;Cache&gt; cache2_;

  CacheTest()
      : cache_(NewCache(kCacheSize, kNumShardBits, false)),
        cache2_(NewCache(kCacheSize2, kNumShardBits2, false)) {
    current_ = this;
  }

  ~CacheTest() override {}

  std::shared_ptr&lt;Cache&gt; NewCache(size_t capacity) {
    auto type = GetParam();
    if (type == kLRU) {
      return NewLRUCache(capacity);
    }
    if (type == kClock) {
      return NewClockCache(capacity);
    }
    return nullptr;
  }

  std::shared_ptr&lt;Cache&gt; NewCache(
      size_t capacity, int num_shard_bits, bool strict_capacity_limit,
      CacheMetadataChargePolicy charge_policy = kDontChargeCacheMetadata) {
    auto type = GetParam();
    if (type == kLRU) {
      LRUCacheOptions co;
      co.capacity = capacity;
      co.num_shard_bits = num_shard_bits;
      co.strict_capacity_limit = strict_capacity_limit;
      co.high_pri_pool_ratio = 0;
      co.metadata_charge_policy = charge_policy;
      return NewLRUCache(co);
    }
    if (type == kClock) {
      return NewClockCache(capacity, num_shard_bits, strict_capacity_limit,
                           charge_policy);
    }
    return nullptr;
  }

  int Lookup(std::shared_ptr&lt;Cache&gt; cache, int key) {
    Cache::Handle* handle = cache-&gt;Lookup(EncodeKey(key));
    const int r = (handle == nullptr) ? -1 : DecodeValue(cache-&gt;Value(handle));
    if (handle != nullptr) {
      cache-&gt;Release(handle);
    }
    return r;
  }

  void Insert(std::shared_ptr&lt;Cache&gt; cache, int key, int value,
              int charge = 1) {
    cache-&gt;Insert(EncodeKey(key), EncodeValue(value), charge,
                  &amp;CacheTest::Deleter);
  }

  void Erase(std::shared_ptr&lt;Cache&gt; cache, int key) {
    cache-&gt;Erase(EncodeKey(key));
  }

  int Lookup(int key) {
    return Lookup(cache_, key);
  }

  void Insert(int key, int value, int charge = 1) {
    Insert(cache_, key, value, charge);
  }

  void Erase(int key) {
    Erase(cache_, key);
  }

  int Lookup2(int key) {
    return Lookup(cache2_, key);
  }

  void Insert2(int key, int value, int charge = 1) {
    Insert(cache2_, key, value, charge);
  }

  void Erase2(int key) {
    Erase(cache2_, key);
  }
};
CacheTest* CacheTest::current_;

class LRUCacheTest : public CacheTest {};

TEST_P(CacheTest, UsageTest) {
  // cache is std::shared_ptr and will be automatically cleaned up.
  const uint64_t kCapacity = 100000;
  auto cache = NewCache(kCapacity, 8, false, kDontChargeCacheMetadata);
  auto precise_cache = NewCache(kCapacity, 0, false, kFullChargeCacheMetadata);
  ASSERT_EQ(0, cache-&gt;GetUsage());
  ASSERT_EQ(0, precise_cache-&gt;GetUsage());

  size_t usage = 0;
  char value[10] = &quot;abcdef&quot;;
  // make sure everything will be cached
  for (int i = 1; i &lt; 100; ++i) {
    std::string key(i, &#039;a&#039;);
    auto kv_size = key.size() + 5;
    cache-&gt;Insert(key, reinterpret_cast&lt;void*&gt;(value), kv_size, dumbDeleter);
    precise_cache-&gt;Insert(key, reinterpret_cast&lt;void*&gt;(value), kv_size,
                          dumbDeleter);
    usage += kv_size;
    ASSERT_EQ(usage, cache-&gt;GetUsage());
    ASSERT_LT(usage, precise_cache-&gt;GetUsage());
  }

  cache-&gt;EraseUnRefEntries();
  precise_cache-&gt;EraseUnRefEntries();
  ASSERT_EQ(0, cache-&gt;GetUsage());
  ASSERT_EQ(0, precise_cache-&gt;GetUsage());

  // make sure the cache will be overloaded
  for (uint64_t i = 1; i &lt; kCapacity; ++i) {
    auto key = ToString(i);
    cache-&gt;Insert(key, reinterpret_cast&lt;void*&gt;(value), key.size() + 5,
                  dumbDeleter);
    precise_cache-&gt;Insert(key, reinterpret_cast&lt;void*&gt;(value), key.size() + 5,
                          dumbDeleter);
  }

  // the usage should be close to the capacity
  ASSERT_GT(kCapacity, cache-&gt;GetUsage());
  ASSERT_GT(kCapacity, precise_cache-&gt;GetUsage());
  ASSERT_LT(kCapacity * 0.95, cache-&gt;GetUsage());
  ASSERT_LT(kCapacity * 0.95, precise_cache-&gt;GetUsage());
}

TEST_P(CacheTest, PinnedUsageTest) {
  // cache is std::shared_ptr and will be automatically cleaned up.
  const uint64_t kCapacity = 200000;
  auto cache = NewCache(kCapacity, 8, false, kDontChargeCacheMetadata);
  auto precise_cache = NewCache(kCapacity, 8, false, kFullChargeCacheMetadata);

  size_t pinned_usage = 0;
  char value[10] = &quot;abcdef&quot;;

  std::forward_list&lt;Cache::Handle*&gt; unreleased_handles;
  std::forward_list&lt;Cache::Handle*&gt; unreleased_handles_in_precise_cache;

  // Add entries. Unpin some of them after insertion. Then, pin some of them
  // again. Check GetPinnedUsage().
  for (int i = 1; i &lt; 100; ++i) {
    std::string key(i, &#039;a&#039;);
    auto kv_size = key.size() + 5;
    Cache::Handle* handle;
    Cache::Handle* handle_in_precise_cache;
    cache-&gt;Insert(key, reinterpret_cast&lt;void*&gt;(value), kv_size, dumbDeleter,
                  &amp;handle);
    assert(handle);
    precise_cache-&gt;Insert(key, reinterpret_cast&lt;void*&gt;(value), kv_size,
                          dumbDeleter, &amp;handle_in_precise_cache);
    assert(handle_in_precise_cache);
    pinned_usage += kv_size;
    ASSERT_EQ(pinned_usage, cache-&gt;GetPinnedUsage());
    ASSERT_LT(pinned_usage, precise_cache-&gt;GetPinnedUsage());
    if (i % 2 == 0) {
      cache-&gt;Release(handle);
      precise_cache-&gt;Release(handle_in_precise_cache);
      pinned_usage -= kv_size;
      ASSERT_EQ(pinned_usage, cache-&gt;GetPinnedUsage());
      ASSERT_LT(pinned_usage, precise_cache-&gt;GetPinnedUsage());
    } else {
      unreleased_handles.push_front(handle);
      unreleased_handles_in_precise_cache.push_front(handle_in_precise_cache);
    }
    if (i % 3 == 0) {
      unreleased_handles.push_front(cache-&gt;Lookup(key));
      auto x = precise_cache-&gt;Lookup(key);
      assert(x);
      unreleased_handles_in_precise_cache.push_front(x);
      // If i % 2 == 0, then the entry was unpinned before Lookup, so pinned
      // usage increased
      if (i % 2 == 0) {
        pinned_usage += kv_size;
      }
      ASSERT_EQ(pinned_usage, cache-&gt;GetPinnedUsage());
      ASSERT_LT(pinned_usage, precise_cache-&gt;GetPinnedUsage());
    }
  }
  auto precise_cache_pinned_usage = precise_cache-&gt;GetPinnedUsage();
  ASSERT_LT(pinned_usage, precise_cache_pinned_usage);

  // check that overloading the cache does not change the pinned usage
  for (uint64_t i = 1; i &lt; 2 * kCapacity; ++i) {
    auto key = ToString(i);
    cache-&gt;Insert(key, reinterpret_cast&lt;void*&gt;(value), key.size() + 5,
                  dumbDeleter);
    precise_cache-&gt;Insert(key, reinterpret_cast&lt;void*&gt;(value), key.size() + 5,
                          dumbDeleter);
  }
  ASSERT_EQ(pinned_usage, cache-&gt;GetPinnedUsage());
  ASSERT_EQ(precise_cache_pinned_usage, precise_cache-&gt;GetPinnedUsage());

  cache-&gt;EraseUnRefEntries();
  precise_cache-&gt;EraseUnRefEntries();
  ASSERT_EQ(pinned_usage, cache-&gt;GetPinnedUsage());
  ASSERT_EQ(precise_cache_pinned_usage, precise_cache-&gt;GetPinnedUsage());

  // release handles for pinned entries to prevent memory leaks
  for (auto handle : unreleased_handles) {
    cache-&gt;Release(handle);
  }
  for (auto handle : unreleased_handles_in_precise_cache) {
    precise_cache-&gt;Release(handle);
  }
  ASSERT_EQ(0, cache-&gt;GetPinnedUsage());
  ASSERT_EQ(0, precise_cache-&gt;GetPinnedUsage());
  cache-&gt;EraseUnRefEntries();
  precise_cache-&gt;EraseUnRefEntries();
  ASSERT_EQ(0, cache-&gt;GetUsage());
  ASSERT_EQ(0, precise_cache-&gt;GetUsage());
}

TEST_P(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(1U, deleted_keys_.size());
  ASSERT_EQ(100, deleted_keys_[0]);
  ASSERT_EQ(101, deleted_values_[0]);
}

TEST_P(CacheTest, InsertSameKey) {
  Insert(1, 1);
  Insert(1, 2);
  ASSERT_EQ(2, Lookup(1));
}

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

  Insert(100, 101);
  Insert(200, 201);
  Erase(100);
  ASSERT_EQ(-1,  Lookup(100));
  ASSERT_EQ(201, Lookup(200));
  ASSERT_EQ(1U, 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(1U, deleted_keys_.size());
}

TEST_P(CacheTest, EntriesArePinned) {
  Insert(100, 101);
  Cache::Handle* h1 = cache_-&gt;Lookup(EncodeKey(100));
  ASSERT_EQ(101, DecodeValue(cache_-&gt;Value(h1)));
  ASSERT_EQ(1U, cache_-&gt;GetUsage());

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

  cache_-&gt;Release(h1);
  ASSERT_EQ(1U, deleted_keys_.size());
  ASSERT_EQ(100, deleted_keys_[0]);
  ASSERT_EQ(101, deleted_values_[0]);
  ASSERT_EQ(1U, cache_-&gt;GetUsage());

  Erase(100);
  ASSERT_EQ(-1, Lookup(100));
  ASSERT_EQ(1U, deleted_keys_.size());
  ASSERT_EQ(1U, cache_-&gt;GetUsage());

  cache_-&gt;Release(h2);
  ASSERT_EQ(2U, deleted_keys_.size());
  ASSERT_EQ(100, deleted_keys_[1]);
  ASSERT_EQ(102, deleted_values_[1]);
  ASSERT_EQ(0U, cache_-&gt;GetUsage());
}

TEST_P(CacheTest, EvictionPolicy) {
  Insert(100, 101);
  Insert(200, 201);

  // Frequently used entry must be kept around
  for (int i = 0; i &lt; kCacheSize * 2; i++) {
    Insert(1000+i, 2000+i);
    ASSERT_EQ(101, Lookup(100));
  }
  ASSERT_EQ(101, Lookup(100));
  ASSERT_EQ(-1, Lookup(200));
}

TEST_P(CacheTest, ExternalRefPinsEntries) {
  Insert(100, 101);
  Cache::Handle* h = cache_-&gt;Lookup(EncodeKey(100));
  ASSERT_TRUE(cache_-&gt;Ref(h));
  ASSERT_EQ(101, DecodeValue(cache_-&gt;Value(h)));
  ASSERT_EQ(1U, cache_-&gt;GetUsage());

  for (int i = 0; i &lt; 3; ++i) {
    if (i &gt; 0) {
      // First release (i == 1) corresponds to Ref(), second release (i == 2)
      // corresponds to Lookup(). Then, since all external refs are released,
      // the below insertions should push out the cache entry.
      cache_-&gt;Release(h);
    }
    // double cache size because the usage bit in block cache prevents 100 from
    // being evicted in the first kCacheSize iterations
    for (int j = 0; j &lt; 2 * kCacheSize + 100; j++) {
      Insert(1000 + j, 2000 + j);
    }
    if (i &lt; 2) {
      ASSERT_EQ(101, Lookup(100));
    }
  }
  ASSERT_EQ(-1, Lookup(100));
}

TEST_P(CacheTest, EvictionPolicyRef) {
  Insert(100, 101);
  Insert(101, 102);
  Insert(102, 103);
  Insert(103, 104);
  Insert(200, 101);
  Insert(201, 102);
  Insert(202, 103);
  Insert(203, 104);
  Cache::Handle* h201 = cache_-&gt;Lookup(EncodeKey(200));
  Cache::Handle* h202 = cache_-&gt;Lookup(EncodeKey(201));
  Cache::Handle* h203 = cache_-&gt;Lookup(EncodeKey(202));
  Cache::Handle* h204 = cache_-&gt;Lookup(EncodeKey(203));
  Insert(300, 101);
  Insert(301, 102);
  Insert(302, 103);
  Insert(303, 104);

  // Insert entries much more than Cache capacity
  for (int i = 0; i &lt; kCacheSize * 2; i++) {
    Insert(1000 + i, 2000 + i);
  }

  // Check whether the entries inserted in the beginning
  // are evicted. Ones without extra ref are evicted and
  // those with are not.
  ASSERT_EQ(-1, Lookup(100));
  ASSERT_EQ(-1, Lookup(101));
  ASSERT_EQ(-1, Lookup(102));
  ASSERT_EQ(-1, Lookup(103));

  ASSERT_EQ(-1, Lookup(300));
  ASSERT_EQ(-1, Lookup(301));
  ASSERT_EQ(-1, Lookup(302));
  ASSERT_EQ(-1, Lookup(303));

  ASSERT_EQ(101, Lookup(200));
  ASSERT_EQ(102, Lookup(201));
  ASSERT_EQ(103, Lookup(202));
  ASSERT_EQ(104, Lookup(203));

  // Cleaning up all the handles
  cache_-&gt;Release(h201);
  cache_-&gt;Release(h202);
  cache_-&gt;Release(h203);
  cache_-&gt;Release(h204);
}

TEST_P(CacheTest, EvictEmptyCache) {
  // Insert item large than capacity to trigger eviction on empty cache.
  auto cache = NewCache(1, 0, false);
  ASSERT_OK(cache-&gt;Insert(&quot;foo&quot;, nullptr, 10, dumbDeleter));
}

TEST_P(CacheTest, EraseFromDeleter) {
  // Have deleter which will erase item from cache, which will re-enter
  // the cache at that point.
  std::shared_ptr&lt;Cache&gt; cache = NewCache(10, 0, false);
  ASSERT_OK(cache-&gt;Insert(&quot;foo&quot;, nullptr, 1, dumbDeleter));
  ASSERT_OK(cache-&gt;Insert(&quot;bar&quot;, cache.get(), 1, eraseDeleter));
  cache-&gt;Erase(&quot;bar&quot;);
  ASSERT_EQ(nullptr, cache-&gt;Lookup(&quot;foo&quot;));
  ASSERT_EQ(nullptr, cache-&gt;Lookup(&quot;bar&quot;));
}

TEST_P(CacheTest, ErasedHandleState) {
  // insert a key and get two handles
  Insert(100, 1000);
  Cache::Handle* h1 = cache_-&gt;Lookup(EncodeKey(100));
  Cache::Handle* h2 = cache_-&gt;Lookup(EncodeKey(100));
  ASSERT_EQ(h1, h2);
  ASSERT_EQ(DecodeValue(cache_-&gt;Value(h1)), 1000);
  ASSERT_EQ(DecodeValue(cache_-&gt;Value(h2)), 1000);

  // delete the key from the cache
  Erase(100);
  // can no longer find in the cache
  ASSERT_EQ(-1, Lookup(100));

  // release one handle
  cache_-&gt;Release(h1);
  // still can&#039;t find in cache
  ASSERT_EQ(-1, Lookup(100));

  cache_-&gt;Release(h2);
}

TEST_P(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 &lt; 2*kCacheSize) {
    const int weight = (index &amp; 1) ? kLight : kHeavy;
    Insert(index, 1000+index, weight);
    added += weight;
    index++;
  }

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

TEST_P(CacheTest, NewId) {
  uint64_t a = cache_-&gt;NewId();
  uint64_t b = cache_-&gt;NewId();
  ASSERT_NE(a, b);
}


class Value {
 public:
  explicit Value(size_t v) : v_(v) { }

  size_t v_;
};

namespace {
void deleter(const Slice&amp; /*key*/, void* value) {
  delete static_cast&lt;Value *&gt;(value);
}
}  // namespace

TEST_P(CacheTest, ReleaseAndErase) {
  std::shared_ptr&lt;Cache&gt; cache = NewCache(5, 0, false);
  Cache::Handle* handle;
  Status s = cache-&gt;Insert(EncodeKey(100), EncodeValue(100), 1,
                           &amp;CacheTest::Deleter, &amp;handle);
  ASSERT_TRUE(s.ok());
  ASSERT_EQ(5U, cache-&gt;GetCapacity());
  ASSERT_EQ(1U, cache-&gt;GetUsage());
  ASSERT_EQ(0U, deleted_keys_.size());
  auto erased = cache-&gt;Release(handle, true);
  ASSERT_TRUE(erased);
  // This tests that deleter has been called
  ASSERT_EQ(1U, deleted_keys_.size());
}

TEST_P(CacheTest, ReleaseWithoutErase) {
  std::shared_ptr&lt;Cache&gt; cache = NewCache(5, 0, false);
  Cache::Handle* handle;
  Status s = cache-&gt;Insert(EncodeKey(100), EncodeValue(100), 1,
                           &amp;CacheTest::Deleter, &amp;handle);
  ASSERT_TRUE(s.ok());
  ASSERT_EQ(5U, cache-&gt;GetCapacity());
  ASSERT_EQ(1U, cache-&gt;GetUsage());
  ASSERT_EQ(0U, deleted_keys_.size());
  auto erased = cache-&gt;Release(handle);
  ASSERT_FALSE(erased);
  // This tests that deleter is not called. When cache has free capacity it is
  // not expected to immediately erase the released items.
  ASSERT_EQ(0U, deleted_keys_.size());
}

TEST_P(CacheTest, SetCapacity) {
  // test1: increase capacity
  // lets create a cache with capacity 5,
  // then, insert 5 elements, then increase capacity
  // to 10, returned capacity should be 10, usage=5
  std::shared_ptr&lt;Cache&gt; cache = NewCache(5, 0, false);
  std::vector&lt;Cache::Handle*&gt; handles(10);
  // Insert 5 entries, but not releasing.
  for (size_t i = 0; i &lt; 5; i++) {
    std::string key = ToString(i+1);
    Status s = cache-&gt;Insert(key, new Value(i + 1), 1, &amp;deleter, &amp;handles[i]);
    ASSERT_TRUE(s.ok());
  }
  ASSERT_EQ(5U, cache-&gt;GetCapacity());
  ASSERT_EQ(5U, cache-&gt;GetUsage());
  cache-&gt;SetCapacity(10);
  ASSERT_EQ(10U, cache-&gt;GetCapacity());
  ASSERT_EQ(5U, cache-&gt;GetUsage());

  // test2: decrease capacity
  // insert 5 more elements to cache, then release 5,
  // then decrease capacity to 7, final capacity should be 7
  // and usage should be 7
  for (size_t i = 5; i &lt; 10; i++) {
    std::string key = ToString(i+1);
    Status s = cache-&gt;Insert(key, new Value(i + 1), 1, &amp;deleter, &amp;handles[i]);
    ASSERT_TRUE(s.ok());
  }
  ASSERT_EQ(10U, cache-&gt;GetCapacity());
  ASSERT_EQ(10U, cache-&gt;GetUsage());
  for (size_t i = 0; i &lt; 5; i++) {
    cache-&gt;Release(handles[i]);
  }
  ASSERT_EQ(10U, cache-&gt;GetCapacity());
  ASSERT_EQ(10U, cache-&gt;GetUsage());
  cache-&gt;SetCapacity(7);
  ASSERT_EQ(7, cache-&gt;GetCapacity());
  ASSERT_EQ(7, cache-&gt;GetUsage());

  // release remaining 5 to keep valgrind happy
  for (size_t i = 5; i &lt; 10; i++) {
    cache-&gt;Release(handles[i]);
  }
}

TEST_P(LRUCacheTest, SetStrictCapacityLimit) {
  // test1: set the flag to false. Insert more keys than capacity. See if they
  // all go through.
  std::shared_ptr&lt;Cache&gt; cache = NewCache(5, 0, false);
  std::vector&lt;Cache::Handle*&gt; handles(10);
  Status s;
  for (size_t i = 0; i &lt; 10; i++) {
    std::string key = ToString(i + 1);
    s = cache-&gt;Insert(key, new Value(i + 1), 1, &amp;deleter, &amp;handles[i]);
    ASSERT_OK(s);
    ASSERT_NE(nullptr, handles[i]);
  }
  ASSERT_EQ(10, cache-&gt;GetUsage());

  // test2: set the flag to true. Insert and check if it fails.
  std::string extra_key = &quot;extra&quot;;
  Value* extra_value = new Value(0);
  cache-&gt;SetStrictCapacityLimit(true);
  Cache::Handle* handle;
  s = cache-&gt;Insert(extra_key, extra_value, 1, &amp;deleter, &amp;handle);
  ASSERT_TRUE(s.IsIncomplete());
  ASSERT_EQ(nullptr, handle);
  ASSERT_EQ(10, cache-&gt;GetUsage());

  for (size_t i = 0; i &lt; 10; i++) {
    cache-&gt;Release(handles[i]);
  }

  // test3: init with flag being true.
  std::shared_ptr&lt;Cache&gt; cache2 = NewCache(5, 0, true);
  for (size_t i = 0; i &lt; 5; i++) {
    std::string key = ToString(i + 1);
    s = cache2-&gt;Insert(key, new Value(i + 1), 1, &amp;deleter, &amp;handles[i]);
    ASSERT_OK(s);
    ASSERT_NE(nullptr, handles[i]);
  }
  s = cache2-&gt;Insert(extra_key, extra_value, 1, &amp;deleter, &amp;handle);
  ASSERT_TRUE(s.IsIncomplete());
  ASSERT_EQ(nullptr, handle);
  // test insert without handle
  s = cache2-&gt;Insert(extra_key, extra_value, 1, &amp;deleter);
  // AS if the key have been inserted into cache but get evicted immediately.
  ASSERT_OK(s);
  ASSERT_EQ(5, cache2-&gt;GetUsage());
  ASSERT_EQ(nullptr, cache2-&gt;Lookup(extra_key));

  for (size_t i = 0; i &lt; 5; i++) {
    cache2-&gt;Release(handles[i]);
  }
}

TEST_P(CacheTest, OverCapacity) {
  size_t n = 10;

  // a LRUCache with n entries and one shard only
  std::shared_ptr&lt;Cache&gt; cache = NewCache(n, 0, false);

  std::vector&lt;Cache::Handle*&gt; handles(n+1);

  // Insert n+1 entries, but not releasing.
  for (size_t i = 0; i &lt; n + 1; i++) {
    std::string key = ToString(i+1);
    Status s = cache-&gt;Insert(key, new Value(i + 1), 1, &amp;deleter, &amp;handles[i]);
    ASSERT_TRUE(s.ok());
  }

  // Guess what&#039;s in the cache now?
  for (size_t i = 0; i &lt; n + 1; i++) {
    std::string key = ToString(i+1);
    auto h = cache-&gt;Lookup(key);
    ASSERT_TRUE(h != nullptr);
    if (h) cache-&gt;Release(h);
  }

  // the cache is over capacity since nothing could be evicted
  ASSERT_EQ(n + 1U, cache-&gt;GetUsage());
  for (size_t i = 0; i &lt; n + 1; i++) {
    cache-&gt;Release(handles[i]);
  }
  // Make sure eviction is triggered.
  cache-&gt;SetCapacity(n);

  // cache is under capacity now since elements were released
  ASSERT_EQ(n, cache-&gt;GetUsage());

  // element 0 is evicted and the rest is there
  // This is consistent with the LRU policy since the element 0
  // was released first
  for (size_t i = 0; i &lt; n + 1; i++) {
    std::string key = ToString(i+1);
    auto h = cache-&gt;Lookup(key);
    if (h) {
      ASSERT_NE(i, 0U);
      cache-&gt;Release(h);
    } else {
      ASSERT_EQ(i, 0U);
    }
  }
}

namespace {
std::vector&lt;std::pair&lt;int, int&gt;&gt; callback_state;
void callback(void* entry, size_t charge) {
  callback_state.push_back({DecodeValue(entry), static_cast&lt;int&gt;(charge)});
}
};

TEST_P(CacheTest, ApplyToAllCacheEntiresTest) {
  std::vector&lt;std::pair&lt;int, int&gt;&gt; inserted;
  callback_state.clear();

  for (int i = 0; i &lt; 10; ++i) {
    Insert(i, i * 2, i + 1);
    inserted.push_back({i * 2, i + 1});
  }
  cache_-&gt;ApplyToAllCacheEntries(callback, true);

  std::sort(inserted.begin(), inserted.end());
  std::sort(callback_state.begin(), callback_state.end());
  ASSERT_TRUE(inserted == callback_state);
}

TEST_P(CacheTest, DefaultShardBits) {
  // test1: set the flag to false. Insert more keys than capacity. See if they
  // all go through.
  std::shared_ptr&lt;Cache&gt; cache = NewCache(16 * 1024L * 1024L);
  ShardedCache* sc = dynamic_cast&lt;ShardedCache*&gt;(cache.get());
  ASSERT_EQ(5, sc-&gt;GetNumShardBits());

  cache = NewLRUCache(511 * 1024L, -1, true);
  sc = dynamic_cast&lt;ShardedCache*&gt;(cache.get());
  ASSERT_EQ(0, sc-&gt;GetNumShardBits());

  cache = NewLRUCache(1024L * 1024L * 1024L, -1, true);
  sc = dynamic_cast&lt;ShardedCache*&gt;(cache.get());
  ASSERT_EQ(6, sc-&gt;GetNumShardBits());
}

TEST_P(CacheTest, GetCharge) {
  Insert(1, 2);
  Cache::Handle* h1 = cache_-&gt;Lookup(EncodeKey(1));
  ASSERT_EQ(2, DecodeValue(cache_-&gt;Value(h1)));
  ASSERT_EQ(1, cache_-&gt;GetCharge(h1));
  cache_-&gt;Release(h1);
}

#ifdef SUPPORT_CLOCK_CACHE
std::shared_ptr&lt;Cache&gt; (*new_clock_cache_func)(
    size_t, int, bool, CacheMetadataChargePolicy) = NewClockCache;
INSTANTIATE_TEST_CASE_P(CacheTestInstance, CacheTest,
                        testing::Values(kLRU, kClock));
#else
INSTANTIATE_TEST_CASE_P(CacheTestInstance, CacheTest, testing::Values(kLRU));
#endif  // SUPPORT_CLOCK_CACHE
INSTANTIATE_TEST_CASE_P(CacheTestInstance, LRUCacheTest, testing::Values(kLRU));

}  // namespace ROCKSDB_NAMESPACE

int main(int argc, char** argv) {
  ::testing::InitGoogleTest(&amp;argc, argv);
  return RUN_ALL_TESTS();
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2Frocksdb%2Fcache'>🔙 Back</a></p>