PerfectIndexMapTest.cpp File Reference

#include <folly/portability/GTest.h>
#include <proxygen/lib/http/HTTPCommonHeaders.h>
#include <proxygen/lib/utils/PerfectIndexMap.h>
#include <string>

Go to the source code of this file.

Classes
struct	PerfectIndexMapTestsTemplateParams< Key, OtherKey, NoneKey, PerfectHashStrToKey, AllowDuplicates, CaseInsensitive, KeyCommonOffset, NumKeys >
class	PerfectIndexMapTests< T >

Typedefs
typedef testing::Types< PerfectIndexMapTestsTemplateParams< HTTPHeaderCode, HTTP_HEADER_OTHER, HTTP_HEADER_NONE, HTTPCommonHeaders::hash, false, true, HTTPHeaderCodeCommonOffset, HTTPCommonHeaders::num_header_codes >, PerfectIndexMapTestsTemplateParams< HTTPHeaderCode, HTTP_HEADER_OTHER, HTTP_HEADER_NONE, HTTPCommonHeaders::hash, true, true, HTTPHeaderCodeCommonOffset, HTTPCommonHeaders::num_header_codes >, PerfectIndexMapTestsTemplateParams< HTTPHeaderCode, HTTP_HEADER_OTHER, HTTP_HEADER_NONE, HTTPCommonHeaders::hash, true, false, HTTPHeaderCodeCommonOffset, HTTPCommonHeaders::num_header_codes >, PerfectIndexMapTestsTemplateParams< HTTPHeaderCode, HTTP_HEADER_OTHER, HTTP_HEADER_NONE, HTTPCommonHeaders::hash, false, false, HTTPHeaderCodeCommonOffset, HTTPCommonHeaders::num_header_codes > >	TestTypes

Functions
	TYPED_TEST_CASE (PerfectIndexMapTests, TestTypes)
	TYPED_TEST (PerfectIndexMapTests, BasicKeySetAddRemoveGetSingleOrNone)
	TYPED_TEST (PerfectIndexMapTests, BasicOtherKeySetAddRemoveGetSingleOrNone)
	TYPED_TEST (PerfectIndexMapTests, OtherStringCaseSensitivity)

Typedef Documentation

typedef testing::Types< PerfectIndexMapTestsTemplateParams< HTTPHeaderCode, HTTP_HEADER_OTHER, HTTP_HEADER_NONE, HTTPCommonHeaders::hash, false, true, HTTPHeaderCodeCommonOffset, HTTPCommonHeaders::num_header_codes>, PerfectIndexMapTestsTemplateParams< HTTPHeaderCode, HTTP_HEADER_OTHER, HTTP_HEADER_NONE, HTTPCommonHeaders::hash, true, true, HTTPHeaderCodeCommonOffset, HTTPCommonHeaders::num_header_codes>, PerfectIndexMapTestsTemplateParams< HTTPHeaderCode, HTTP_HEADER_OTHER, HTTP_HEADER_NONE, HTTPCommonHeaders::hash, true, false, HTTPHeaderCodeCommonOffset, HTTPCommonHeaders::num_header_codes>, PerfectIndexMapTestsTemplateParams< HTTPHeaderCode, HTTP_HEADER_OTHER, HTTP_HEADER_NONE, HTTPCommonHeaders::hash, false, false, HTTPHeaderCodeCommonOffset, HTTPCommonHeaders::num_header_codes> > TestTypes

Definition at line 102 of file PerfectIndexMapTest.cpp.

Function Documentation

TYPED_TEST	(	PerfectIndexMapTests	,
		BasicKeySetAddRemoveGetSingleOrNone
	)

Definition at line 105 of file PerfectIndexMapTest.cpp.

References ASSERT_EQ, ASSERT_TRUE, EXPECT_EQ, testing::Key(), and uint64_t.

                                                                      {
  typedef typename TypeParam::TKey Key;

  EXPECT_EQ(this->testMap_.size(), 0);

  // Insert numInserted distinct keys and duplicate values into the map.
  auto numInserted = TypeParam::TNumKeys - TypeParam::TKeyCommonOffset;
  for (uint64_t j = TypeParam::TKeyCommonOffset; j < TypeParam::TNumKeys; ++j) {
    this->testMap_.set(static_cast<Key>(j), std::to_string(j));
  }
  EXPECT_EQ(this->testMap_.size(), numInserted);

  // Setting a duplicate should not increase the size of the map, regardless
  // of whether duplicates are supported
  Key key = static_cast<Key>(TypeParam::TKeyCommonOffset);
  this->testMap_.set(key, std::to_string(TypeParam::TKeyCommonOffset));
  EXPECT_EQ(this->testMap_.size(), numInserted);

  // Adding is only allowed when duplicates are and so here we expect the size
  // of the map to change.
  if (TypeParam::TAllowDuplicates) {
    this->testMap_.add(key, std::to_string(TypeParam::TKeyCommonOffset));
    EXPECT_EQ(this->testMap_.size(), numInserted + 1);
  }

  // Remove the last added element in the map (and its duplicate if applicable)
  // Adjusts numInserted as appropriate
  this->testMap_.remove(key);
  EXPECT_EQ(this->testMap_.size(), --numInserted);

  // Verify the integrity of the map
  for (uint64_t j = TypeParam::TKeyCommonOffset + 1;
       j < TypeParam::TNumKeys; ++j) {
    key = static_cast<Key>(j);
    auto optional = this->testMap_.getSingleOrNone(key);
    ASSERT_TRUE(optional.hasValue());
    ASSERT_EQ(optional.value(), std::to_string(j));
  }
}

TYPED_TEST	(	PerfectIndexMapTests	,
		BasicOtherKeySetAddRemoveGetSingleOrNone
	)

Definition at line 145 of file PerfectIndexMapTest.cpp.

References ASSERT_EQ, ASSERT_TRUE, EXPECT_EQ, string, and val.

                                                                           {
  EXPECT_EQ(this->testMap_.size(), 0);

  // Insert numInserted distinct keys and values in to the map
  int numInserted = 10;
  std::string val;
  for (int num = 0; num < numInserted; ++num) {
    val = std::to_string(num);
    this->testMap_.set(val, val);
  }
  EXPECT_EQ(this->testMap_.size(), numInserted);

  // Setting a duplicate should not increase the size of the map, regardless
  // of whether duplicates are supported
  this->testMap_.set(val, val);
  EXPECT_EQ(this->testMap_.size(), numInserted);

  // Adding is only allowed when duplicates are and so here we expect the size
  // of the map to change.
  if (TypeParam::TAllowDuplicates) {
    this->testMap_.add(val, val);
    EXPECT_EQ(this->testMap_.size(), numInserted + 1);
  }

  // Remove the last added element in the map (and its duplicate if applicable)
  // Adjusts numInserted as appropriate
  this->testMap_.remove(val);
  EXPECT_EQ(this->testMap_.size(), --numInserted);

  // Verify the integrity of the map
  for (int num = 0; num < numInserted; ++num) {
    val = std::to_string(num);
    auto optional = this->testMap_.getSingleOrNone(val);
    ASSERT_TRUE(optional.hasValue());
    ASSERT_EQ(optional.value(), val);
  }
}

TYPED_TEST	(	PerfectIndexMapTests	,
		OtherStringCaseSensitivity
	)

Definition at line 188 of file PerfectIndexMapTest.cpp.

References ASSERT_EQ, ASSERT_TRUE, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::Optional< Value >::has_value(), folly::Optional< Value >::hasValue(), string, and folly::Optional< Value >::value().

                                                             {
  std::string testString = "test";
  std::string modTestString = "tEsT";
  std::string addModTestString = "TeSt";
  this->testMap_.set(testString, testString);

  auto currentCount = this->testMap_.size();
  folly::Optional<std::string> optional;
  if (TypeParam::TCaseInsensitive) {
    optional = this->testMap_.getSingleOrNone(modTestString);
    ASSERT_TRUE(optional.hasValue());
    ASSERT_EQ(optional.value(), testString);

    this->testMap_.set(modTestString, modTestString);
    EXPECT_EQ(this->testMap_.size(), currentCount);

    optional = this->testMap_.getSingleOrNone(testString);
    ASSERT_TRUE(optional.hasValue());
    ASSERT_EQ(optional.value(), modTestString);
  } else {
    this->testMap_.set(modTestString, modTestString);
    EXPECT_EQ(this->testMap_.size(), ++currentCount);

    this->testMap_.set(testString, testString);
    EXPECT_EQ(this->testMap_.size(), currentCount);

    optional = this->testMap_.getSingleOrNone(testString);
    ASSERT_TRUE(optional.hasValue());
    ASSERT_EQ(optional.value(), testString);

    optional = this->testMap_.getSingleOrNone(modTestString);
    ASSERT_TRUE(optional.hasValue());
    ASSERT_EQ(optional.value(), modTestString);
  }

  if (TypeParam::TAllowDuplicates) {
    // Finally verify that two exact same keys are treated as duplicates.
    this->testMap_.add(addModTestString, addModTestString);
    optional = this->testMap_.getSingleOrNone(testString);
    if (TypeParam::TCaseInsensitive) {
      EXPECT_FALSE(optional.hasValue());
    } else {
      EXPECT_TRUE(optional.has_value());
    }
  }
}

TYPED_TEST_CASE	(	PerfectIndexMapTests	,
		TestTypes
	)