StringKeyedTest.cpp File Reference

#include <folly/experimental/StringKeyedMap.h>
#include <folly/experimental/StringKeyedSet.h>
#include <folly/experimental/StringKeyedUnorderedMap.h>
#include <folly/experimental/StringKeyedUnorderedSet.h>
#include <list>
#include <string>
#include <glog/logging.h>
#include <folly/Range.h>
#include <folly/hash/Hash.h>
#include <folly/portability/GFlags.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Classes
struct	MemoryLeakCheckerAllocator< Alloc >
struct	MemoryLeakCheckerAllocator< Alloc >::rebind< U >

Typedefs
using	KeyValuePairLeakChecker = MemoryLeakCheckerAllocator< std::allocator< std::pair< const StringPiece, int >>>
using	ValueLeakChecker = MemoryLeakCheckerAllocator< std::allocator< StringPiece >>
using	LeakCheckedUnorderedMap = StringKeyedUnorderedMap< int, folly::transparent< folly::hasher< StringPiece >>, folly::transparent< std::equal_to< StringPiece >>, MemoryLeakCheckerAllocator< std::allocator< std::pair< const std::string, int >>>>
typedef StringKeyedSetBase< std::less< StringPiece >, ValueLeakChecker >	LeakCheckedSet
typedef StringKeyedMap< int, std::less< StringPiece >, KeyValuePairLeakChecker >	LeakCheckedMap
using	LeakCheckedUnorderedSet = BasicStringKeyedUnorderedSet< folly::transparent< folly::hasher< StringPiece >>, folly::transparent< std::equal_to< folly::StringPiece >>, MemoryLeakCheckerAllocator< std::allocator< std::string >>>

Functions
	TEST (StringKeyedUnorderedMapTest, sanity)
	TEST (StringKeyedUnorderedMapTest, constructors)
	TEST (StringKeyedSetTest, sanity)
	TEST (StringKeyedSetTest, constructors)
	TEST (StringKeyedUnorderedSetTest, sanity)
	TEST (StringKeyedUnorderedSetTest, constructors)
	TEST (StringKeyedMapTest, sanity)
	TEST (StringKeyedMapTest, constructors)
int	main (int argc, char **argv)
	TEST (StringKeyed, memory_balance)

Variables
static unsigned long long	allocated = 0
static unsigned long long	freed = 0

Typedef Documentation

using KeyValuePairLeakChecker = MemoryLeakCheckerAllocator< std::allocator<std::pair<const StringPiece, int>>>

Definition at line 110 of file StringKeyedTest.cpp.

typedef StringKeyedMap<int, std::less<StringPiece>, KeyValuePairLeakChecker> LeakCheckedMap

Definition at line 125 of file StringKeyedTest.cpp.

typedef StringKeyedSetBase<std::less<StringPiece>, ValueLeakChecker> LeakCheckedSet

Definition at line 122 of file StringKeyedTest.cpp.

using LeakCheckedUnorderedMap = StringKeyedUnorderedMap< int, folly::transparent<folly::hasher<StringPiece>>, folly::transparent<std::equal_to<StringPiece>>, MemoryLeakCheckerAllocator< std::allocator<std::pair<const std::string, int>>>>

Definition at line 119 of file StringKeyedTest.cpp.

using LeakCheckedUnorderedSet = BasicStringKeyedUnorderedSet< folly::transparent<folly::hasher<StringPiece>>, folly::transparent<std::equal_to<folly::StringPiece>>, MemoryLeakCheckerAllocator<std::allocator<std::string>>>

Definition at line 130 of file StringKeyedTest.cpp.

using ValueLeakChecker = MemoryLeakCheckerAllocator<std::allocator<StringPiece>>

Definition at line 112 of file StringKeyedTest.cpp.

Function Documentation

int main	(	int	argc,
		char **	argv
	)

Definition at line 508 of file StringKeyedTest.cpp.

References testing::InitGoogleTest(), and RUN_ALL_TESTS().

                                {
  FLAGS_logtostderr = true;
  google::InitGoogleLogging(argv[0]);
  testing::InitGoogleTest(&argc, argv);
  gflags::ParseCommandLineFlags(&argc, &argv, true);

  return RUN_ALL_TESTS();
}

TEST	(	StringKeyedUnorderedMapTest	,
		sanity
	)

Definition at line 132 of file StringKeyedTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::StringKeyedUnorderedMap< Mapped, Hash, Eq, Alloc >::insert(), map(), and s.

                                          {
  LeakCheckedUnorderedMap map;
  EXPECT_TRUE(map.empty());
  EXPECT_EQ(map.size(), 0);

  {
    string s("hello");
    StringPiece piece(s, 3);
    map.insert({s, 1});
    EXPECT_FALSE(map.emplace(s, 2).second);
    EXPECT_TRUE(map.emplace(piece, 3).second);
  }

  EXPECT_EQ(map.size(), 2);

  map = static_cast<decltype(map)&>(map); // suppress self-assign warning

  EXPECT_EQ(map.find("hello")->second, 1);
  EXPECT_EQ(map.find("lo")->second, 3);

  map.erase(map.find("hello"));

  EXPECT_EQ(map.size(), 1);

  for (auto& it : map) {
    EXPECT_EQ(it.first, "lo");
  }
}

TEST	(	StringKeyedUnorderedMapTest	,
		constructors
	)

Definition at line 161 of file StringKeyedTest.cpp.

References EXPECT_EQ, EXPECT_TRUE, and folly::gen::move.

                                                {
  LeakCheckedUnorderedMap map{
      {"hello", 1},
      {"lo", 3},
  };

  LeakCheckedUnorderedMap map2(map);
  EXPECT_EQ(map2.size(), 2);
  EXPECT_TRUE(map2 == map);

  map2.erase("lo");
  for (auto& it : map2) {
    EXPECT_EQ(it.first, "hello");
  }

  map2.clear();

  EXPECT_TRUE(map2.empty());

  map2.emplace("key1", 1);

  LeakCheckedUnorderedMap map3(std::move(map2));

  EXPECT_EQ(map3.size(), 1);
  EXPECT_EQ(map3["key1"], 1);

  EXPECT_EQ(map3["key0"], 0);
  EXPECT_EQ(map3.size(), 2);

  map3.reserve(1000);

  EXPECT_EQ(map3.size(), 2);

  LeakCheckedUnorderedMap map4{
      {"key0", 0},
      {"key1", 1},
  };

  EXPECT_EQ(map4.erase("key0"), 1);
  EXPECT_EQ(map4.size(), 1);
  EXPECT_EQ(map4.find("key0"), map4.end());

  map3 = map4;

  EXPECT_EQ(map3.size(), 1);
  EXPECT_EQ(map4.size(), 1);
  EXPECT_EQ(map4.max_size(), map3.max_size());

  map4 = std::move(map3);

  EXPECT_EQ(map4.size(), 1);
  EXPECT_EQ(map4.at("key1"), 1);
}

TEST	(	StringKeyedSetTest	,
		sanity
	)

Definition at line 215 of file StringKeyedTest.cpp.

References folly::empty(), folly::test::end(), EXPECT_EQ, EXPECT_FALSE, EXPECT_NE, EXPECT_TRUE, s, and folly::size().

                                 {
  LeakCheckedSet set;
  EXPECT_TRUE(set.empty());
  EXPECT_EQ(set.size(), 0);

  {
    string s("hello");
    StringPiece piece(s, 3);
    set.insert(s);
    EXPECT_FALSE(set.emplace(s).second);
    EXPECT_TRUE(set.emplace(piece).second);
  }

  EXPECT_EQ(set.size(), 2);

  set = static_cast<decltype(set)&>(set); // suppress self-assign warning

  EXPECT_NE(set.find(StringPiece("hello")), set.end());
  EXPECT_NE(set.find("lo"), set.end());

  auto it = set.begin();
  EXPECT_EQ(*it, "hello");
  EXPECT_EQ(*(++it), "lo");
  EXPECT_EQ(++it, set.end());

  set.erase(set.find("hello"));

  EXPECT_EQ(set.size(), 1);

  for (auto entry : set) {
    EXPECT_EQ(entry, "lo");
  }
}

TEST	(	StringKeyedSetTest	,
		constructors
	)

Definition at line 249 of file StringKeyedTest.cpp.

References folly::StringKeyedSetBase< Compare, Alloc >::emplace(), folly::StringKeyedSetBase< Compare, Alloc >::erase(), EXPECT_EQ, EXPECT_NE, EXPECT_TRUE, folly::StringKeyedSetBase< Compare, Alloc >::insert(), and folly::gen::move.

                                       {
  LeakCheckedSet set{
      "hello",
      "lo",
  };
  LeakCheckedSet set2(set);

  EXPECT_EQ(set2.size(), 2);

  set2.erase("lo");
  for (auto it : set2) {
    EXPECT_EQ(it, "hello");
  }

  set2.clear();

  EXPECT_TRUE(set2.empty());

  set2.emplace("key1");

  LeakCheckedSet set3(std::move(set2));

  EXPECT_EQ(set3.size(), 1);
  EXPECT_EQ(set3.insert("key1").second, false);

  EXPECT_EQ(set3.emplace("key0").second, true);
  EXPECT_EQ(set3.size(), 2);

  EXPECT_EQ(set3.size(), 2);

  LeakCheckedSet set4{
      "key0",
      "key1",
  };

  EXPECT_EQ(set4.erase("key0"), 1);
  EXPECT_EQ(set4.size(), 1);
  EXPECT_EQ(set4.find("key0"), set4.end());

  set3 = set4;

  EXPECT_EQ(set3.size(), 1);
  EXPECT_EQ(set4.size(), 1);
  EXPECT_EQ(set4.max_size(), set3.max_size());

  set4 = std::move(set3);

  EXPECT_EQ(set4.size(), 1);
  EXPECT_NE(set4.find("key1"), set4.end());
}

TEST	(	StringKeyedUnorderedSetTest	,
		sanity
	)

Definition at line 300 of file StringKeyedTest.cpp.

References folly::empty(), folly::test::end(), EXPECT_EQ, EXPECT_FALSE, EXPECT_NE, EXPECT_TRUE, s, and folly::size().

                                          {
  LeakCheckedUnorderedSet set;
  EXPECT_TRUE(set.empty());
  EXPECT_EQ(set.size(), 0);

  {
    string s("hello");
    StringPiece piece(s, 3);
    set.insert(s);
    EXPECT_FALSE(set.emplace(s).second);
    EXPECT_TRUE(set.emplace(piece).second);
  }

  EXPECT_EQ(set.size(), 2);

  set = static_cast<decltype(set)&>(set); // suppress self-assign warning

  EXPECT_NE(set.find("hello"), set.end());
  EXPECT_NE(set.find("lo"), set.end());

  set.erase(set.find("hello"));

  EXPECT_EQ(set.size(), 1);

  for (auto entry : set) {
    EXPECT_EQ(entry, "lo");
  }
}

TEST	(	StringKeyedUnorderedSetTest	,
		constructors
	)

Definition at line 329 of file StringKeyedTest.cpp.

References EXPECT_EQ, EXPECT_GE, EXPECT_NE, EXPECT_TRUE, and folly::gen::move.

                                                {
  LeakCheckedUnorderedSet s1;
  EXPECT_TRUE(s1.empty());

  LeakCheckedUnorderedSet s2(10);
  EXPECT_TRUE(s2.empty());
  EXPECT_GE(s2.bucket_count(), 10);

  std::list<StringPiece> lst{"abc", "def"};
  LeakCheckedUnorderedSet s3(lst.begin(), lst.end());
  EXPECT_EQ(s3.size(), 2);
  EXPECT_NE(s3.find("abc"), s3.end());
  EXPECT_NE(s3.find("def"), s3.end());
  EXPECT_TRUE(s3 == (LeakCheckedUnorderedSet{"abc", "def"}));

  LeakCheckedUnorderedSet s4(const_cast<LeakCheckedUnorderedSet&>(s3));
  EXPECT_TRUE(s4 == s3);

  LeakCheckedUnorderedSet s5(
      const_cast<LeakCheckedUnorderedSet&>(s3), ValueLeakChecker());
  EXPECT_TRUE(s5 == s3);

  LeakCheckedUnorderedSet s6(std::move(s3));
  EXPECT_TRUE(s3.empty());
  EXPECT_TRUE(s6 == s5);

  auto s6_allocator = s6.get_allocator();
  LeakCheckedUnorderedSet s7(std::move(s6), s6_allocator);
  EXPECT_TRUE(s6.empty());
  EXPECT_TRUE(s7 == s5);

  LeakCheckedUnorderedSet s8{
      "hello",
      "lo",
  };
  EXPECT_EQ(s8.size(), 2);
  EXPECT_NE(s8.find("hello"), s8.end());
  EXPECT_NE(s8.find("lo"), s8.end());

  LeakCheckedUnorderedSet s9(
      {
          "hello",
          "lo",
      },
      10);
  EXPECT_EQ(s9.size(), 2);
  EXPECT_NE(s9.find("hello"), s9.end());
  EXPECT_NE(s9.find("lo"), s9.end());

  LeakCheckedUnorderedSet set2(s8);
  EXPECT_EQ(set2.size(), 2);

  set2.erase("lo");
  for (auto entry : set2) {
    EXPECT_EQ(entry, "hello");
  }

  set2.clear();

  EXPECT_TRUE(set2.empty());

  set2.emplace("key1");

  LeakCheckedUnorderedSet set3(std::move(set2));

  EXPECT_EQ(set3.size(), 1);
  EXPECT_EQ(set3.insert("key1").second, false);

  EXPECT_EQ(set3.emplace("key0").second, true);
  EXPECT_EQ(set3.size(), 2);

  set3.reserve(1000);

  EXPECT_EQ(set3.size(), 2);

  LeakCheckedUnorderedSet set4{
      "key0",
      "key1",
  };

  EXPECT_EQ(set4.erase("key0"), 1);
  EXPECT_EQ(set4.size(), 1);
  EXPECT_EQ(set4.find("key0"), set4.end());

  set3 = set4;

  EXPECT_EQ(set3.size(), 1);
  EXPECT_EQ(set4.size(), 1);
  EXPECT_EQ(set4.max_size(), set3.max_size());

  set4 = std::move(set3);

  EXPECT_EQ(set4.size(), 1);
  EXPECT_NE(set4.find("key1"), set4.end());
}

TEST	(	StringKeyedMapTest	,
		sanity
	)

Definition at line 425 of file StringKeyedTest.cpp.

References folly::StringKeyedMap< Value, Compare, Alloc >::emplace(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::gen::first, folly::StringKeyedMap< Value, Compare, Alloc >::insert(), map(), and s.

                                 {
  LeakCheckedMap map;
  EXPECT_TRUE(map.empty());
  EXPECT_EQ(map.size(), 0);

  {
    string s("hello");
    StringPiece piece(s, 3);
    map.insert({s, 1});
    EXPECT_FALSE(map.emplace(s, 2).second);
    EXPECT_TRUE(map.emplace(piece, 3).second);
  }

  EXPECT_EQ(map.size(), 2);

  map = static_cast<decltype(map)&>(map); // suppress self-assign warning

  EXPECT_EQ(map.find("hello")->second, 1);
  EXPECT_EQ(map.find("lo")->second, 3);

  auto it = map.begin();
  EXPECT_EQ(it->first, "hello");
  EXPECT_EQ((++it)->first, "lo");
  EXPECT_EQ(++it, map.end());

  map.erase(map.find("hello"));

  EXPECT_EQ(map.size(), 1);

  for (auto& entry : map) {
    EXPECT_EQ(entry.first, "lo");
  }
}

TEST	(	StringKeyedMapTest	,
		constructors
	)

Definition at line 459 of file StringKeyedTest.cpp.

References folly::StringKeyedMap< Value, Compare, Alloc >::erase(), EXPECT_EQ, EXPECT_TRUE, and folly::gen::move.

                                       {
  LeakCheckedMap map{
      {"hello", 1},
      {"lo", 3},
  };
  LeakCheckedMap map2(map);

  EXPECT_EQ(map2.size(), 2);

  map2.erase("lo");
  for (auto& entry : map2) {
    EXPECT_EQ(entry.first, "hello");
  }

  map2.clear();

  EXPECT_TRUE(map2.empty());

  map2.emplace("key1", 1);

  LeakCheckedMap map3(std::move(map2));

  EXPECT_EQ(map3.size(), 1);
  EXPECT_EQ(map3["key1"], 1);

  EXPECT_EQ(map3["key0"], 0);
  EXPECT_EQ(map3.size(), 2);

  LeakCheckedMap map4{
      {"key0", 0},
      {"key1", 1},
  };

  EXPECT_EQ(map4.erase("key0"), 1);
  EXPECT_EQ(map4.size(), 1);
  EXPECT_EQ(map4.find("key0"), map4.end());

  map3 = map4;

  EXPECT_EQ(map3.size(), 1);
  EXPECT_EQ(map4.size(), 1);
  EXPECT_EQ(map4.max_size(), map3.max_size());

  map4 = std::move(map3);

  EXPECT_EQ(map4.size(), 1);
  EXPECT_EQ(map4.at("key1"), 1);
}

TEST	(	StringKeyed	,
		memory_balance
	)

Definition at line 518 of file StringKeyedTest.cpp.

References allocated, EXPECT_EQ, and freed.

                                  {
  auto balance = allocated < freed ? freed - allocated : allocated - freed;

  LOG(INFO) << "allocated: " << allocated << " freed: " << freed
            << " balance: " << balance
            << (allocated < freed
                    ? " negative (huh?)"
                    : freed < allocated ? " positive (leak)" : "");

  EXPECT_EQ(allocated, freed);
}

Variable Documentation

unsigned long long allocated = 0

static

Definition at line 40 of file StringKeyedTest.cpp.

Referenced by MemoryLeakCheckerAllocator< Alloc >::allocate(), producerConsumerBench(), and TEST().

unsigned long long freed = 0

static

Definition at line 41 of file StringKeyedTest.cpp.

Referenced by MemoryLeakCheckerAllocator< Alloc >::deallocate(), TEST(), and wangle::SSLStats::~SSLStats().