FilePersistentCacheTest.cpp File Reference

#include <folly/futures/Barrier.h>
#include <wangle/client/persistence/FilePersistentCache.h>
#include <wangle/client/persistence/SharedMutexCacheLockGuard.h>
#include <wangle/client/persistence/test/TestUtil.h>

Go to the source code of this file.

Classes
class	FilePersistentCacheTest< MutexT >

Typedefs
using	MutexTypes = ::testing::Types< std::mutex, folly::SharedMutex >

Functions
	TYPED_TEST_CASE (FilePersistentCacheTest, MutexTypes)
	TYPED_TEST (FilePersistentCacheTest, stringTypesGetPutTest)
	TYPED_TEST (FilePersistentCacheTest, basicTypeGetPutTest)
	TYPED_TEST (FilePersistentCacheTest, stringCompositeGetPutTest)
	TYPED_TEST (FilePersistentCacheTest, stringNestedValGetPutTest)
	TYPED_TEST (FilePersistentCacheTest, stringNestedKeyValGetPutTest)
template<typename K , typename V , typename MutexT >
void	testEmptyFile ()
	TYPED_TEST (FilePersistentCacheTest, stringTypesEmptyFile)
	TYPED_TEST (FilePersistentCacheTest, stringNestedValEmptyFile)
template<typename K , typename V , typename MutexT >
void	testInvalidFile (const std::string &content)
	TYPED_TEST (FilePersistentCacheTest, stringTypesInvalidFile)
	TYPED_TEST (FilePersistentCacheTest, stringNestedValInvalidFile)
template<typename K , typename V , typename MutexT >
void	testValidFile (const std::string &content, const vector< K > &keys, const vector< V > &values)
	TYPED_TEST (FilePersistentCacheTest, stringTypesValidFileTest)
	TYPED_TEST (FilePersistentCacheTest, basicEvictionTest)
	TYPED_TEST (FilePersistentCacheTest, backwardCompatiblityTest)
	TYPED_TEST (FilePersistentCacheTest, destroy)
	TYPED_TEST (FilePersistentCacheTest, threadstress)

Typedef Documentation

using MutexTypes = ::testing::Types<std::mutex, folly::SharedMutex>

Definition at line 30 of file FilePersistentCacheTest.cpp.

Function Documentation

template<typename K , typename V , typename MutexT >

void testEmptyFile

(

)

Definition at line 96 of file FilePersistentCacheTest.cpp.

References folly::closeNoInt(), EXPECT_EQ, EXPECT_TRUE, wangle::getPersistentCacheFilename(), and folly::openNoInt().

                     {
  string filename = getPersistentCacheFilename();
  size_t cacheCapacity = 10;
  int fd = folly::openNoInt(
              filename.c_str(),
              O_WRONLY | O_CREAT | O_TRUNC,
              S_IRUSR | S_IWUSR
          );
  EXPECT_TRUE(fd != -1);
  using CacheType = FilePersistentCache<K, V, MutexT>;
  CacheType cache(filename, cacheCapacity, chrono::seconds(1));
  EXPECT_EQ(cache.size(), 0);
  EXPECT_TRUE(folly::closeNoInt(fd) != -1);
  EXPECT_TRUE(unlink(filename.c_str()) != -1);
}

template<typename K , typename V , typename MutexT >

void testInvalidFile

(

const std::string &

content

)

Definition at line 126 of file FilePersistentCacheTest.cpp.

References folly::closeNoInt(), EXPECT_EQ, EXPECT_TRUE, wangle::getPersistentCacheFilename(), folly::openNoInt(), and folly::writeFull().

                                               {
  string filename = getPersistentCacheFilename();
  size_t cacheCapacity = 10;
  int fd = folly::openNoInt(
              filename.c_str(),
              O_WRONLY | O_CREAT | O_TRUNC,
              S_IRUSR | S_IWUSR
          );
  EXPECT_TRUE(fd != -1);
  EXPECT_EQ(
    folly::writeFull(fd, content.data(), content.size()),
    content.size()
  );
  using CacheType = FilePersistentCache<K, V, MutexT>;
  CacheType cache(filename, cacheCapacity, chrono::seconds(1));
  EXPECT_EQ(cache.size(), 0);
  EXPECT_TRUE(folly::closeNoInt(fd) != -1);
  EXPECT_TRUE(unlink(filename.c_str()) != -1);
}

template<typename K , typename V , typename MutexT >

void testValidFile	(	const std::string &	content,
		const vector< K > &	keys,
		const vector< V > &	values
	)

Definition at line 160 of file FilePersistentCacheTest.cpp.

References folly::closeNoInt(), EXPECT_EQ, EXPECT_TRUE, wangle::getPersistentCacheFilename(), i, folly::openNoInt(), and folly::writeFull().

    {
  string filename = getPersistentCacheFilename();
  size_t cacheCapacity = 10;
  int fd = folly::openNoInt(
              filename.c_str(),
              O_WRONLY | O_CREAT | O_TRUNC,
              S_IRUSR | S_IWUSR
          );
  EXPECT_TRUE(fd != -1);
  EXPECT_EQ(
    folly::writeFull(fd, content.data(), content.size()),
    content.size()
  );
  using CacheType = FilePersistentCache<K, V, MutexT>;
  CacheType cache(filename, cacheCapacity, chrono::seconds(1));
  EXPECT_EQ(cache.size(), keys.size());
  for (size_t i = 0; i < keys.size(); ++i) {
    EXPECT_EQ(cache.get(keys[i]).value(), values[i]);
  }
  EXPECT_TRUE(folly::closeNoInt(fd) != -1);
  EXPECT_TRUE(unlink(filename.c_str()) != -1);
}

TYPED_TEST	(	FilePersistentCacheTest	,
		stringTypesGetPutTest
	)

Definition at line 33 of file FilePersistentCacheTest.cpp.

References string, and values().

                                                           {
  using KeyType = string;
  using ValType = string;
  vector<KeyType> keys = {"key1", "key2"};
  vector<ValType> values = {"value1", "value2"};
  testSimplePutGet<KeyType, ValType, TypeParam>(keys, values);
}

TYPED_TEST	(	FilePersistentCacheTest	,
		basicTypeGetPutTest
	)

Definition at line 41 of file FilePersistentCacheTest.cpp.

References values().

                                                         {
  using KeyType = int;
  using ValType = double;
  vector<KeyType> keys = {1, 2};
  vector<ValType> values = {3.0, 4.0};
  testSimplePutGet<KeyType, ValType, TypeParam>(keys, values);
}

TYPED_TEST	(	FilePersistentCacheTest	,
		stringCompositeGetPutTest
	)

Definition at line 49 of file FilePersistentCacheTest.cpp.

References string, and values().

                                                               {
  using KeyType = string;
  using ValType = list<string>;
  vector<KeyType> keys = {"key1", "key2"};
  vector<ValType> values =
    {ValType({"fma", "shijin"}), ValType({"foo", "bar"})};
  testSimplePutGet<KeyType, ValType, TypeParam>(keys, values);
}

TYPED_TEST	(	FilePersistentCacheTest	,
		stringNestedValGetPutTest
	)

Definition at line 58 of file FilePersistentCacheTest.cpp.

References string, and values().

                                                               {
  using KeyType = string;
  using ValType = map<string, list<string>>;
  vector<KeyType> keys = {"cool", "not cool"};
  vector<ValType> values = {
    ValType({
        {"NYC", {"fma", "shijin"}},
        {"MPK", {"ranjeeth", "dsp"}}
        }),
    ValType({
        {"MPK", {"subodh", "blake"}},
        {"STL", {"pgriess"}}
        }),
  };
  testSimplePutGet<KeyType, ValType, TypeParam>(keys, values);
}

TYPED_TEST	(	FilePersistentCacheTest	,
		stringNestedKeyValGetPutTest
	)

Definition at line 75 of file FilePersistentCacheTest.cpp.

References values().

                                                                  {
  using KeyType = pair<string, string>;
  using ValType = map<string, list<string>>;
  vector<KeyType> keys = {
    make_pair("cool", "what the=?"),
    make_pair("not_cool", "how on *& earth?")
  };
  vector<ValType> values = {
    ValType({
        {"NYC", {"fma", "shijin kong$"}},
        {"MPK", {"ranjeeth", "dsp"}}
        }),
    ValType({
        {"MPK", {"subodh", "blake"}},
        {"STL", {"pgriess"}}
        }),
  };
  testSimplePutGet<KeyType, ValType, TypeParam>(keys, values);
}

TYPED_TEST	(	FilePersistentCacheTest	,
		stringTypesEmptyFile
	)

Definition at line 112 of file FilePersistentCacheTest.cpp.

References string.

                                                          {
  using KeyType = string;
  using ValType = string;
  testEmptyFile<KeyType, ValType, TypeParam>();
}

TYPED_TEST	(	FilePersistentCacheTest	,
		stringNestedValEmptyFile
	)

Definition at line 118 of file FilePersistentCacheTest.cpp.

References string.

                                                              {
  using KeyType = string;
  using ValType = map<string, list<string>>;
  testEmptyFile<KeyType, ValType, TypeParam>();
}

TYPED_TEST	(	FilePersistentCacheTest	,
		stringTypesInvalidFile
	)

Definition at line 146 of file FilePersistentCacheTest.cpp.

References string.

                                                            {
  using KeyType = string;
  using ValType = string;
  testInvalidFile<KeyType, ValType, TypeParam>(string("{\"k1\":\"v1\",1}"));
}

TYPED_TEST	(	FilePersistentCacheTest	,
		stringNestedValInvalidFile
	)

Definition at line 152 of file FilePersistentCacheTest.cpp.

References string.

                                                                {
  using KeyType = string;
  using ValType = map<string, list<string>>;
  testInvalidFile<KeyType, ValType, TypeParam>(string("{\"k1\":\"v1\"}"));
}

TYPED_TEST	(	FilePersistentCacheTest	,
		stringTypesValidFileTest
	)

Definition at line 187 of file FilePersistentCacheTest.cpp.

References string, and values().

                                                              {
  using KeyType = string;
  using ValType = string;
  vector<KeyType> keys = {"key1", "key2"};
  vector<ValType> values = {"value1", "value2"};
  std::string content = "[[\"key1\",\"value1\"], [\"key2\",\"value2\"]]";
  testValidFile<KeyType, ValType, TypeParam>(content, keys, values);
}

TYPED_TEST	(	FilePersistentCacheTest	,
		basicEvictionTest
	)

Definition at line 196 of file FilePersistentCacheTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, wangle::FilePersistentCache< K, V, M >::get(), wangle::getPersistentCacheFilename(), folly::Optional< Value >::hasValue(), i, wangle::FilePersistentCache< K, V, M >::put(), wangle::FilePersistentCache< K, V, M >::size(), and folly::Optional< Value >::value().

                                                       {
  string filename = getPersistentCacheFilename();
  {
    size_t cacheCapacity = 10;
    FilePersistentCache<int, int, TypeParam> cache(filename,
        cacheCapacity, chrono::seconds(1));
    for (int i = 0; i < 10; ++i) {
        cache.put(i, i);
    }
    EXPECT_EQ(cache.size(), 10); // MRU to LRU : 9, 8, ...1, 0

    cache.put(10, 10); // evicts 0
    EXPECT_EQ(cache.size(), 10);
    EXPECT_FALSE(cache.get(0).hasValue());
    EXPECT_EQ(cache.get(10).value(), 10); // MRU to LRU : 10, 9, ... 2, 1

    EXPECT_EQ(cache.get(1).value(), 1); // MRU to LRU : 1, 10, 9, ..., 3, 2
    cache.put(11, 11); // evicts 2
    EXPECT_EQ(cache.size(), 10);
    EXPECT_FALSE(cache.get(2).hasValue());
    EXPECT_EQ(cache.get(11).value(), 11);
  }

  EXPECT_TRUE(unlink(filename.c_str()) != -1);
}

TYPED_TEST	(	FilePersistentCacheTest	,
		backwardCompatiblityTest
	)

Definition at line 223 of file FilePersistentCacheTest.cpp.

References folly::closeNoInt(), EXPECT_EQ, EXPECT_TRUE, wangle::getPersistentCacheFilename(), folly::openNoInt(), string, values(), and folly::writeFull().

                                                              {
  using KeyType = string;
  using ValType = string;

  // write an old style file
  vector<KeyType> keys = {"key1", "key2"};
  vector<ValType> values = {"value1", "value2"};
  std::string content = "{\"key1\":\"value1\", \"key2\":\"value2\"}";
  using CacheType = FilePersistentCache<KeyType, ValType, TypeParam>;
  string filename = getPersistentCacheFilename();
  size_t cacheCapacity = 10;
  int fd = folly::openNoInt(
              filename.c_str(),
              O_WRONLY | O_CREAT | O_TRUNC,
              S_IRUSR | S_IWUSR
          );
  EXPECT_TRUE(fd != -1);
  EXPECT_EQ(
    folly::writeFull(fd, content.data(), content.size()),
    content.size()
  );
  EXPECT_TRUE(folly::closeNoInt(fd) != -1);

  {
    // it should fail to load
    CacheType cache(filename, cacheCapacity, chrono::seconds(1));
    EXPECT_EQ(cache.size(), 0);

    // .. but new entries should work
    cache.put("key1", "value1");
    cache.put("key2", "value2");
    EXPECT_EQ(cache.size(), 2);
    EXPECT_EQ(cache.get("key1").value(), "value1");
    EXPECT_EQ(cache.get("key2").value(), "value2");
  }
  {
    // new format persists
    CacheType cache(filename, cacheCapacity, chrono::seconds(1));
    EXPECT_EQ(cache.size(), 2);
    EXPECT_EQ(cache.get("key1").value(), "value1");
    EXPECT_EQ(cache.get("key2").value(), "value2");
  }
  EXPECT_TRUE(unlink(filename.c_str()) != -1);
}

TYPED_TEST	(	FilePersistentCacheTest	,
		destroy
	)

Definition at line 268 of file FilePersistentCacheTest.cpp.

References wangle::getPersistentCacheFilename(), and string.

                                             {
  using CacheType = FilePersistentCache<int, int, TypeParam>;
  std::string cacheFile = getPersistentCacheFilename();

  auto cache1 = std::make_unique<CacheType>(
    cacheFile, 10, std::chrono::seconds(3));
  cache1.reset();
  auto cache2 = std::make_unique<CacheType>(
    cacheFile, 10, std::chrono::seconds(3));
  cache2.reset();
}

TYPED_TEST	(	FilePersistentCacheTest	,
		threadstress
	)

Definition at line 280 of file FilePersistentCacheTest.cpp.

References b, EXPECT_EQ, EXPECT_TRUE, wangle::getPersistentCacheFilename(), i, threads, val, and folly::futures::Barrier::wait().

                                                  {
  // make sure no errors crop up when hitting the same cache
  // with multiple threads

  // spin up a few of threads that add and remove
  // their own set of values on the same cache
  using CacheType = FilePersistentCache<string, int, TypeParam>;
  auto cacheFile = getPersistentCacheFilename();
  auto sharedCache = std::make_unique<CacheType>(
    cacheFile, 10, std::chrono::seconds(10));

  int numThreads = 3;
  Barrier b(numThreads);
  auto threadFunc = [&b, numThreads](CacheType* cache, int tNum) {
    auto key1 = folly::to<string>("key", tNum);
    auto nextNum = (tNum + 1) % numThreads;
    auto key2 = folly::to<string>("key", nextNum);
    b.wait().get();
    for (int i = 0; i < 100; ++i) {
      cache->put(key1, i);
      cache->put(key2, i);
      cache->remove(key1);
      cache->remove(key2);
    }
    // wait til everyone is done
    b.wait().get();
    cache->put(key1, tNum);
  };

  std::vector<std::thread> threads;
  for (int i = 0; i < numThreads; ++i) {
    threads.push_back(std::thread(threadFunc, sharedCache.get(), i));
  }
  for (int i = 0; i < numThreads; ++i) {
    threads[i].join();
  }
  EXPECT_EQ(sharedCache->size(), numThreads);
  for (auto i = 0; i < numThreads; ++i) {
    auto key = folly::to<string>("key", i);
    auto val = sharedCache->get(key);
    EXPECT_TRUE(val.hasValue());
    EXPECT_EQ(*val, i);
  }
}

TYPED_TEST_CASE	(	FilePersistentCacheTest	,
		MutexTypes
	)