HashTest.cpp File Reference

#include <folly/hash/Hash.h>
#include <stdint.h>
#include <random>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <folly/MapUtil.h>
#include <folly/Range.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Classes
struct	std::hash< TestEnum >
struct	std::hash< TestStruct >
class	TestHasher
struct	FNVTestParam
class	FNVTest

Enumerations
enum	TestEnum
enum	TestBigEnum : uint64_t

Functions
	TEST (Hash, Fnv32)
	TEST (Hash, Fnv64)
	TEST (Hash, Hsieh32)
	TEST (Hash, TWang_Mix64)
	TEST (Hash, TWang_Unmix64)
	TEST (Hash, TWang_32From64)
	TEST (Hash, Jenkins_Rev_Mix32)
	TEST (Hash, Jenkins_Rev_Unmix32)
	TEST (Hash, hasher)
	TEST (Hash, integral_types)
	TEST (Hash, noCachedHashCode)
	TEST (Hash, integer_conversion)
	TEST (Hash, float_types)
template<typename T , typename... Ts>
size_t	hash_combine_test (const T &t, const Ts &...ts)
	TEST (Hash, pair)
	TEST (Hash, hash_combine)
	TEST (Hash, hash_bool)
	TEST (Hash, hash_bool10)
	TEST (Hash, std_tuple)
	TEST (Hash, enum_type)
	TEST (Hash, pair_folly_hash)
	TEST (Hash, tuple_folly_hash)
	TEST (Hash, hash_range)
	TEST (Hash, commutative_hash_combine)
	TEST (Hash, std_tuple_different_hash)
	TEST (Hash, Strings)
	TEST_P (FNVTest, Fnva64Buf)
	TEST_P (FNVTest, Fnva64)
	TEST_P (FNVTest, Fnva64Partial)
	INSTANTIATE_TEST_CASE_P (FNVTesting, FNVTest,::testing::Values(FNVTestParam{"foobar", 0x85944171f73967e8}, FNVTestParam{"chongo was here!\n", 0x46810940eff5f915}, FNVTestParam{"127.0.0.3", 0xaabafc7104d91158}, FNVTestParam{"http://en.wikipedia.org/wiki/Fowler_Noll_Vo_hash", 0xd9b957fb7fe794c5}, FNVTestParam{"http://norvig.com/21-days.html", 0x07aaa640476e0b9a}))
	TEST (Traits, stdHashPairAvalances)
	TEST (Traits, stdHashTuple2Avalances)
	TEST (Traits, stdHashStringAvalances)
	TEST (Traits, follyHashUint64Avalances)
	TEST (Traits, follyHasherInt64Avalances)
	TEST (Traits, follyHasherFloatAvalanches)
	TEST (Traits, follyHasherDoubleAvalanches)

Variables
static constexpr bool	k32Bit = sizeof(std::size_t) == 4

Enumeration Type Documentation

enum TestBigEnum : uint64_t

strong

Definition at line 234 of file HashTest.cpp.

                       : uint64_t {
  ITEM = 1,
};

enum TestEnum

strong

Definition at line 228 of file HashTest.cpp.

                    {
  MIN = 0,
  ITEM = 1,
  MAX = 2,
};

Function Documentation

template<typename T , typename... Ts>

size_t hash_combine_test	(	const T &	t,
		const Ts &...	ts
	)

Definition at line 419 of file HashTest.cpp.

References folly::hash::hash_combine_generic(), and folly::pushmi::detail::t.

Referenced by TEST().

                                                      {
  return hash_combine_generic(TestHasher{}, t, ts...);
}

INSTANTIATE_TEST_CASE_P	(	FNVTesting	,
		FNVTest	,
		::testing::Values(FNVTestParam{"foobar", 0x85944171f73967e8}, FNVTestParam{"chongo was here!\n", 0x46810940eff5f915}, FNVTestParam{"127.0.0.3", 0xaabafc7104d91158}, FNVTestParam{"http://en.wikipedia.org/wiki/Fowler_Noll_Vo_hash", 0xd9b957fb7fe794c5}, FNVTestParam{"http://norvig.com/21-days.html", 0x07aaa640476e0b9a})
	)

Referenced by TEST_P().

TEST	(	Hash	,
		Fnv32
	)

Definition at line 32 of file HashTest.cpp.

References EXPECT_EQ, folly::hash::fnv32(), folly::hash::fnv32_buf(), uint32_t, and uint8_t.

                  {
  const char* s1 = "hello, world!";
  const uint32_t s1_res = 3605494790UL;
  EXPECT_EQ(fnv32(s1), s1_res);
  EXPECT_EQ(fnv32(s1), fnv32_buf(s1, strlen(s1)));

  const char* s2 = "monkeys! m0nk3yz! ev3ry \\/\\/here~~~~";
  const uint32_t s2_res = 1270448334UL;
  EXPECT_EQ(fnv32(s2), s2_res);
  EXPECT_EQ(fnv32(s2), fnv32_buf(s2, strlen(s2)));

  const char* s3 = "";
  const uint32_t s3_res = 2166136261UL;
  EXPECT_EQ(fnv32(s3), s3_res);
  EXPECT_EQ(fnv32(s3), fnv32_buf(s3, strlen(s3)));

  const uint8_t s4_data[] = {0xFF, 0xFF, 0xFF, 0x00};
  const char* s4 = reinterpret_cast<const char*>(s4_data);
  const uint32_t s4_res = 2420936562UL;
  EXPECT_EQ(fnv32(s4), s4_res);
  EXPECT_EQ(fnv32(s4), fnv32_buf(s4, strlen(s4)));
}

TEST	(	Hash	,
		Fnv64
	)

Definition at line 55 of file HashTest.cpp.

References EXPECT_EQ, EXPECT_NE, folly::hash::fnv64(), folly::hash::fnv64_buf(), int32_t, int64_t, uint64_t, and uint8_t.

                  {
  const char* s1 = "hello, world!";
  const uint64_t s1_res = 13991426986746681734ULL;
  EXPECT_EQ(fnv64(s1), s1_res);
  EXPECT_EQ(fnv64(s1), fnv64_buf(s1, strlen(s1)));

  const char* s2 = "monkeys! m0nk3yz! ev3ry \\/\\/here~~~~";
  const uint64_t s2_res = 6091394665637302478ULL;
  EXPECT_EQ(fnv64(s2), s2_res);
  EXPECT_EQ(fnv64(s2), fnv64_buf(s2, strlen(s2)));

  const char* s3 = "";
  const uint64_t s3_res = 14695981039346656037ULL;
  EXPECT_EQ(fnv64(s3), s3_res);
  EXPECT_EQ(fnv64(s3), fnv64_buf(s3, strlen(s3)));

  const uint8_t s4_data[] = {0xFF, 0xFF, 0xFF, 0x00};
  const char* s4 = reinterpret_cast<const char*>(s4_data);
  const uint64_t s4_res = 2787597222566293202ULL;
  EXPECT_EQ(fnv64(s4), s4_res);
  EXPECT_EQ(fnv64(s4), fnv64_buf(s4, strlen(s4)));

  // note: Use fnv64_buf to make a single hash value from multiple
  // fields/datatypes.
  const char* t4_a = "E Pluribus";
  int64_t t4_b = 0xF1E2D3C4B5A69788;
  int32_t t4_c = 0xAB12CD34;
  const char* t4_d = "Unum";
  uint64_t t4_res = 15571330457339273965ULL;
  uint64_t t4_hash1 = fnv64_buf(t4_a, strlen(t4_a));
  uint64_t t4_hash2 =
      fnv64_buf(reinterpret_cast<void*>(&t4_b), sizeof(int64_t), t4_hash1);
  uint64_t t4_hash3 =
      fnv64_buf(reinterpret_cast<void*>(&t4_c), sizeof(int32_t), t4_hash2);
  uint64_t t4_hash4 = fnv64_buf(t4_d, strlen(t4_d), t4_hash3);
  EXPECT_EQ(t4_hash4, t4_res);
  // note: These are probabalistic, not determinate, but c'mon.
  // These hash values should be different, or something's not
  // working.
  EXPECT_NE(t4_hash1, t4_hash4);
  EXPECT_NE(t4_hash2, t4_hash4);
  EXPECT_NE(t4_hash3, t4_hash4);
}

TEST	(	Hash	,
		Hsieh32
	)

Definition at line 99 of file HashTest.cpp.

References EXPECT_EQ, folly::hash::hsieh_hash32(), folly::hash::hsieh_hash32_buf(), and uint32_t.

                    {
  const char* s1 = "hello, world!";
  const uint32_t s1_res = 2918802987ul;
  EXPECT_EQ(hsieh_hash32(s1), s1_res);
  EXPECT_EQ(hsieh_hash32(s1), hsieh_hash32_buf(s1, strlen(s1)));

  const char* s2 = "monkeys! m0nk3yz! ev3ry \\/\\/here~~~~";
  const uint32_t s2_res = 47373213ul;
  EXPECT_EQ(hsieh_hash32(s2), s2_res);
  EXPECT_EQ(hsieh_hash32(s2), hsieh_hash32_buf(s2, strlen(s2)));

  const char* s3 = "";
  const uint32_t s3_res = 0;
  EXPECT_EQ(hsieh_hash32(s3), s3_res);
  EXPECT_EQ(hsieh_hash32(s3), hsieh_hash32_buf(s3, strlen(s3)));
}

TEST	(	Hash	,
		TWang_Mix64
	)

Definition at line 116 of file HashTest.cpp.

References EXPECT_EQ, folly::hash::twang_mix64(), folly::hash::twang_unmix64(), and uint64_t.

                        {
  uint64_t i1 = 0x78a87873e2d31dafULL;
  uint64_t i1_res = 3389151152926383528ULL;
  EXPECT_EQ(i1_res, twang_mix64(i1));
  EXPECT_EQ(i1, twang_unmix64(i1_res));

  uint64_t i2 = 0x0123456789abcdefULL;
  uint64_t i2_res = 3061460455458984563ull;
  EXPECT_EQ(i2_res, twang_mix64(i2));
  EXPECT_EQ(i2, twang_unmix64(i2_res));
}

TEST	(	Hash	,
		TWang_Unmix64
	)

Definition at line 135 of file HashTest.cpp.

References i, and uint64_t.

                          {
  // We'll try (1 << i), (1 << i) + 1, (1 << i) - 1
  for (int i = 1; i < 64; i++) {
    checkTWang((uint64_t(1) << i) - 1);
    checkTWang(uint64_t(1) << i);
    checkTWang((uint64_t(1) << i) + 1);
  }
}

TEST	(	Hash	,
		TWang_32From64
	)

Definition at line 144 of file HashTest.cpp.

References EXPECT_EQ, folly::hash::twang_32from64(), uint32_t, and uint64_t.

                           {
  uint64_t i1 = 0x78a87873e2d31dafULL;
  uint32_t i1_res = 1525586863ul;
  EXPECT_EQ(twang_32from64(i1), i1_res);

  uint64_t i2 = 0x0123456789abcdefULL;
  uint32_t i2_res = 2918899159ul;
  EXPECT_EQ(twang_32from64(i2), i2_res);
}

TEST	(	Hash	,
		Jenkins_Rev_Mix32
	)

Definition at line 154 of file HashTest.cpp.

References EXPECT_EQ, folly::hash::jenkins_rev_mix32(), folly::hash::jenkins_rev_unmix32(), and uint32_t.

                              {
  uint32_t i1 = 3805486511ul;
  uint32_t i1_res = 381808021ul;
  EXPECT_EQ(i1_res, jenkins_rev_mix32(i1));
  EXPECT_EQ(i1, jenkins_rev_unmix32(i1_res));

  uint32_t i2 = 2309737967ul;
  uint32_t i2_res = 1834777923ul;
  EXPECT_EQ(i2_res, jenkins_rev_mix32(i2));
  EXPECT_EQ(i2, jenkins_rev_unmix32(i2_res));
}

TEST	(	Hash	,
		Jenkins_Rev_Unmix32
	)

Definition at line 173 of file HashTest.cpp.

References i.

                                {
  // We'll try (1 << i), (1 << i) + 1, (1 << i) - 1
  for (int i = 1; i < 32; i++) {
    checkJenkins((1U << i) - 1);
    checkJenkins(1U << i);
    checkJenkins((1U << i) + 1);
  }
}

TEST	(	Hash	,
		hasher
	)

Definition at line 182 of file HashTest.cpp.

References EXPECT_EQ, folly::get_default(), and m.

                   {
  // Basically just confirms that things compile ok.
  std::unordered_map<int32_t, int32_t, folly::hasher<int32_t>> m;
  m.insert(std::make_pair(4, 5));
  EXPECT_EQ(get_default(m, 4), 5);
}

TEST	(	Hash	,
		integral_types
	)

Definition at line 189 of file HashTest.cpp.

References EXPECT_EQ, int16_t, int32_t, int64_t, int8_t, uint16_t, uint32_t, uint64_t, and uint8_t.

                           {
  // Basically just confirms that things compile ok.
  std::unordered_set<size_t> hashes;
  folly::Hash hasher;
  hashes.insert(hasher((char)1));
  hashes.insert(hasher((signed char)2));
  hashes.insert(hasher((unsigned char)3));
  hashes.insert(hasher((short)4));
  hashes.insert(hasher((signed short)5));
  hashes.insert(hasher((unsigned short)6));
  hashes.insert(hasher((int)7));
  hashes.insert(hasher((signed int)8));
  hashes.insert(hasher((unsigned int)9));
  hashes.insert(hasher((long)10));
  hashes.insert(hasher((signed long)11));
  hashes.insert(hasher((unsigned long)12));
  hashes.insert(hasher((long long)13));
  hashes.insert(hasher((signed long long)14));
  hashes.insert(hasher((unsigned long long)15));
  hashes.insert(hasher((int8_t)16));
  hashes.insert(hasher((uint8_t)17));
  hashes.insert(hasher((int16_t)18));
  hashes.insert(hasher((uint16_t)19));
  hashes.insert(hasher((int32_t)20));
  hashes.insert(hasher((uint32_t)21));
  hashes.insert(hasher((int64_t)22));
  hashes.insert(hasher((uint64_t)23));
  hashes.insert(hasher((size_t)24));

  size_t setSize = 24;
#if FOLLY_HAVE_INT128_T
  hashes.insert(hasher((__int128_t)25));
  hashes.insert(hasher((__uint128_t)26));
  setSize += 2;
#endif
  EXPECT_EQ(setSize, hashes.size());
}

TEST	(	Hash	,
		noCachedHashCode
	)

Definition at line 360 of file HashTest.cpp.

                             {
  testNoCachedHashCode<bool, char, folly::hasher<bool>>();
  testNoCachedHashCode<int, char, folly::hasher<int>>();
  testNoCachedHashCode<double, char, folly::hasher<double>>();
  testNoCachedHashCode<TestEnum, char, folly::hasher<TestEnum>>();

  testNoCachedHashCode<bool, std::string, folly::Hash>();
  testNoCachedHashCode<int, std::string, folly::Hash>();
  testNoCachedHashCode<double, std::string, folly::Hash>();
  testNoCachedHashCode<TestEnum, std::string, folly::Hash>();
}

TEST	(	Hash	,
		integer_conversion
	)

Definition at line 372 of file HashTest.cpp.

References EXPECT_EQ, h, k, s, folly::TEST(), and uint64_t.

                               {
  folly::hasher<uint64_t> h;
  uint64_t k = 10;
  EXPECT_EQ(h(k), h(10));
}

TEST	(	Hash	,
		float_types
	)

Definition at line 392 of file HashTest.cpp.

References EXPECT_EQ, and f.

                        {
  folly::Hash hasher;

  EXPECT_EQ(hasher(0.0f), hasher(-0.0f));
  EXPECT_EQ(hasher(0.0), hasher(-0.0));

  // Basically just confirms that things compile ok.
  std::unordered_set<size_t> hashes;
  hashes.insert(hasher(0.0f));
  hashes.insert(hasher(0.1f));
  hashes.insert(hasher(0.2));
  hashes.insert(hasher(0.2f));
  hashes.insert(hasher(-0.3));
  hashes.insert(hasher(-0.3f));

  EXPECT_EQ(6, hashes.size());
}

TEST	(	Hash	,
		pair
	)

Definition at line 423 of file HashTest.cpp.

References a, b, c, EXPECT_EQ, EXPECT_NE, folly::hash::hash_combine(), and hash_combine_test().

                 {
  auto a = std::make_pair(1, 2);
  auto b = std::make_pair(3, 4);
  auto c = std::make_pair(1, 2);
  auto d = std::make_pair(2, 1);
  EXPECT_EQ(hash_combine(a), hash_combine(c));
  EXPECT_NE(hash_combine(b), hash_combine(c));
  EXPECT_NE(hash_combine(d), hash_combine(c));

  // With composition
  EXPECT_EQ(hash_combine(a, b), hash_combine(c, b));
  // Test order dependence
  EXPECT_NE(hash_combine(a, b), hash_combine(b, a));

  // Test with custom hasher
  EXPECT_EQ(hash_combine_test(a), hash_combine_test(c));
  // 3 + 4 != 1 + 2
  EXPECT_NE(hash_combine_test(b), hash_combine_test(c));
  // This time, thanks to a terrible hash function, these are equal
  EXPECT_EQ(hash_combine_test(d), hash_combine_test(c));
  // With composition
  EXPECT_EQ(hash_combine_test(a, b), hash_combine_test(c, b));
  // Test order dependence
  EXPECT_NE(hash_combine_test(a, b), hash_combine_test(b, a));
  // Again, 1 + 2 == 2 + 1
  EXPECT_EQ(hash_combine_test(a, b), hash_combine_test(d, b));
}

TEST	(	Hash	,
		hash_combine
	)

Definition at line 451 of file HashTest.cpp.

References EXPECT_NE, EXPECT_TRUE, folly::hash::hash_combine(), and folly::pushmi::__adl::noexcept().

                         {
  EXPECT_TRUE(noexcept(hash_combine(1, 2)));
  EXPECT_NE(hash_combine(1, 2), hash_combine(2, 1));
}

TEST	(	Hash	,
		hash_bool
	)

Definition at line 456 of file HashTest.cpp.

References EXPECT_NE.

                      {
  const auto hash = folly::Hash();
  EXPECT_NE(hash(true), hash(false));
}

TEST	(	Hash	,
		hash_bool10
	)

Definition at line 461 of file HashTest.cpp.

References EXPECT_EQ, and values().

                        {
  const auto hash = folly::Hash();
  std::set<size_t> values;
  for (bool b1 : {false, true}) {
    for (bool b2 : {false, true}) {
      for (bool b3 : {false, true}) {
        for (bool b4 : {false, true}) {
          for (bool b5 : {false, true}) {
            for (bool b6 : {false, true}) {
              for (bool b7 : {false, true}) {
                for (bool b8 : {false, true}) {
                  for (bool b9 : {false, true}) {
                    for (bool b10 : {false, true}) {
                      values.insert(
                          hash(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10));
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  EXPECT_EQ(values.size(), 1 << 10);
}

TEST	(	Hash	,
		std_tuple
	)

Definition at line 489 of file HashTest.cpp.

References EXPECT_EQ, m, and folly::pushmi::detail::t.

                      {
  typedef std::tuple<int64_t, std::string, int32_t> tuple3;
  tuple3 t(42, "foo", 1);

  std::unordered_map<tuple3, std::string> m;
  m[t] = "bar";
  EXPECT_EQ("bar", m[t]);
}

TEST	(	Hash	,
		enum_type
	)

Definition at line 498 of file HashTest.cpp.

References EXPECT_EQ, EXPECT_NE, int32_t, and int64_t.

                      {
  const auto hash = folly::Hash();

  enum class Enum32 : int32_t { Foo, Bar };
  EXPECT_EQ(hash(static_cast<int32_t>(Enum32::Foo)), hash(Enum32::Foo));
  EXPECT_EQ(hash(static_cast<int32_t>(Enum32::Bar)), hash(Enum32::Bar));
  EXPECT_NE(hash(Enum32::Foo), hash(Enum32::Bar));

  std::unordered_map<Enum32, std::string, folly::Hash> m32;
  m32[Enum32::Foo] = "foo";
  EXPECT_EQ("foo", m32[Enum32::Foo]);

  enum class Enum64 : int64_t { Foo, Bar };
  EXPECT_EQ(hash(static_cast<int64_t>(Enum64::Foo)), hash(Enum64::Foo));
  EXPECT_EQ(hash(static_cast<int64_t>(Enum64::Bar)), hash(Enum64::Bar));
  EXPECT_NE(hash(Enum64::Foo), hash(Enum64::Bar));

  std::unordered_map<Enum64, std::string, folly::Hash> m64;
  m64[Enum64::Foo] = "foo";
  EXPECT_EQ("foo", m64[Enum64::Foo]);
}

TEST	(	Hash	,
		pair_folly_hash
	)

Definition at line 520 of file HashTest.cpp.

References EXPECT_EQ, and m.

                            {
  typedef std::pair<int64_t, int32_t> pair2;
  pair2 p(42, 1);

  std::unordered_map<pair2, std::string, folly::Hash> m;
  m[p] = "bar";
  EXPECT_EQ("bar", m[p]);
}

TEST	(	Hash	,
		tuple_folly_hash
	)

Definition at line 529 of file HashTest.cpp.

References EXPECT_EQ, folly::hash::hash_range(), m, and folly::pushmi::detail::t.

                             {
  typedef std::tuple<int64_t, int32_t, int32_t> tuple3;
  tuple3 t(42, 1, 1);

  std::unordered_map<tuple3, std::string, folly::Hash> m;
  m[t] = "bar";
  EXPECT_EQ("bar", m[t]);
}

TEST	(	Hash	,
		hash_range
	)

Definition at line 545 of file HashTest.cpp.

References EXPECT_EQ, and EXPECT_NE.

                       {
  EXPECT_EQ(hash_vector<int32_t>({1, 2}), hash_vector<int16_t>({1, 2}));
  EXPECT_NE(hash_vector<int>({2, 1}), hash_vector<int>({1, 2}));
  EXPECT_EQ(hash_vector<int>({}), hash_vector<float>({}));
}

TEST	(	Hash	,
		commutative_hash_combine
	)

Definition at line 551 of file HashTest.cpp.

References folly::hash::commutative_hash_combine(), folly::hash::commutative_hash_combine_range(), folly::hash::commutative_hash_combine_range_generic(), folly::hash::commutative_hash_combine_value_generic(), EXPECT_EQ, EXPECT_NE, g(), h, i, and rd.

                                     {
  EXPECT_EQ(
      commutative_hash_combine_value_generic(
          folly::Hash{}(12345ul), folly::Hash{}, 6789ul),
      commutative_hash_combine_value_generic(
          folly::Hash{}(6789ul), folly::Hash{}, 12345ul));

  std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  std::random_device rd;
  std::mt19937 g(rd());
  auto h = commutative_hash_combine_range(v.begin(), v.end());
  for (int i = 0; i < 100; i++) {
    std::shuffle(v.begin(), v.end(), g);
    EXPECT_EQ(h, commutative_hash_combine_range(v.begin(), v.end()));
  }
  EXPECT_NE(
      h,
      commutative_hash_combine_range_generic(
          /* seed = */ 0xdeadbeef, folly::Hash{}, v.begin(), v.end()));
  EXPECT_NE(
      h, commutative_hash_combine_range(v.begin(), v.begin() + (v.size() - 1)));

  EXPECT_EQ(h, commutative_hash_combine(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
  EXPECT_EQ(h, commutative_hash_combine(10, 2, 3, 4, 5, 6, 7, 8, 9, 1));

  EXPECT_EQ(
      commutative_hash_combine(12345, 6789),
      commutative_hash_combine(6789, 12345));
}

TEST	(	Hash	,
		std_tuple_different_hash
	)

Definition at line 581 of file HashTest.cpp.

References EXPECT_NE.

                                     {
  typedef std::tuple<int64_t, std::string, int32_t> tuple3;
  tuple3 t1(42, "foo", 1);
  tuple3 t2(9, "bar", 3);
  tuple3 t3(42, "foo", 3);

  EXPECT_NE(std::hash<tuple3>()(t1), std::hash<tuple3>()(t2));
  EXPECT_NE(std::hash<tuple3>()(t1), std::hash<tuple3>()(t3));
}

TEST	(	Hash	,
		Strings
	)

Definition at line 591 of file HashTest.cpp.

References EXPECT_EQ, EXPECT_NE, folly::range(), and folly::Range< Iter >::str().

                    {
  using namespace folly;

  StringPiece a1 = "10050517", b1 = "51107032", a2 = "10050518",
              b2 = "51107033", a3 = "10050519", b3 = "51107034",
              a4 = "10050525", b4 = "51107040";
  Range<const wchar_t*> w1 = range(L"10050517"), w2 = range(L"51107032"),
                        w3 = range(L"10050518"), w4 = range(L"51107033");
  Hash h2;
  EXPECT_NE(h2(a1), h2(b1));
  EXPECT_NE(h2(a1), h2(b1));
  EXPECT_NE(h2(a2), h2(b2));
  EXPECT_NE(h2(a3), h2(b3));
  EXPECT_NE(h2(ByteRange(a1)), h2(ByteRange(b1)));
  EXPECT_NE(h2(ByteRange(a2)), h2(ByteRange(b2)));
  EXPECT_NE(h2(ByteRange(a3)), h2(ByteRange(b3)));
  EXPECT_NE(h2(ByteRange(a4)), h2(ByteRange(b4)));
  EXPECT_NE(h2(w1), h2(w2));
  EXPECT_NE(h2(w1), h2(w3));
  EXPECT_NE(h2(w2), h2(w4));

  // Check compatibility with std::string.
  EXPECT_EQ(h2(a1), h2(a1.str()));
  EXPECT_EQ(h2(a2), h2(a2.str()));
  EXPECT_EQ(h2(a3), h2(a3.str()));
  EXPECT_EQ(h2(a4), h2(a4.str()));
}

TEST	(	Traits	,
		stdHashPairAvalances
	)

Definition at line 899 of file HashTest.cpp.

References v.

                                   {
  verifyAvalanching<std::hash<std::pair<int, int>>>(
      std::make_pair(0, 0), [](std::pair<int, int>& v) { v.first++; });
}

TEST	(	Traits	,
		stdHashTuple2Avalances
	)

Definition at line 904 of file HashTest.cpp.

References std::tr1::make_tuple(), and v.

                                     {
  verifyAvalanching<std::hash<std::tuple<int, int>>>(
      std::make_tuple(0, 0),
      [](std::tuple<int, int>& v) { std::get<0>(v) += 1; });
}

TEST	(	Traits	,
		stdHashStringAvalances
	)

Definition at line 910 of file HashTest.cpp.

References i, and string.

                                     {
  verifyAvalanching<std::hash<std::string>, std::string>(
      "00000000000000000000000000000", [](std::string& str) {
        std::size_t i = 0;
        while (str[i] == '1') {
          str[i] = '0';
          ++i;
        }
        str[i] = '1';
      });
}

TEST	(	Traits	,
		follyHashUint64Avalances
	)

Definition at line 922 of file HashTest.cpp.

References uint64_t, and v.

                                       {
  verifyAvalanching<folly::Hash>(uint64_t{0}, [](uint64_t& v) { v++; });
}

TEST	(	Traits	,
		follyHasherInt64Avalances
	)

Definition at line 926 of file HashTest.cpp.

References int64_t, and v.

                                        {
  verifyAvalanching<folly::hasher<int64_t>>(
      int64_t{0}, [](int64_t& v) { v++; });
}

TEST	(	Traits	,
		follyHasherFloatAvalanches
	)

Definition at line 931 of file HashTest.cpp.

References v.

                                         {
  verifyAvalanching<folly::hasher<float>>(0.0f, [](float& v) { v += 1; });
}

TEST	(	Traits	,
		follyHasherDoubleAvalanches
	)

Definition at line 935 of file HashTest.cpp.

References v.

                                          {
  verifyAvalanching<folly::hasher<double>>(0.0, [](double& v) { v += 1; });
}

TEST_P	(	FNVTest	,
		Fnva64Buf
	)

Definition at line 626 of file HashTest.cpp.

References EXPECT_EQ, and folly::hash::fnva64_buf().

                           {
  EXPECT_EQ(
      GetParam().out, fnva64_buf(GetParam().in.data(), GetParam().in.size()));
}

TEST_P	(	FNVTest	,
		Fnva64
	)

Definition at line 631 of file HashTest.cpp.

References EXPECT_EQ, and folly::hash::fnva64().

                        {
  EXPECT_EQ(GetParam().out, fnva64(GetParam().in));
}

TEST_P	(	FNVTest	,
		Fnva64Partial
	)

Definition at line 635 of file HashTest.cpp.

References folly::data(), EXPECT_EQ, folly::hash::fnva64_buf(), INSTANTIATE_TEST_CASE_P(), and folly::partial().

                               {
  size_t partialLen = GetParam().in.size() / 2;
  auto data = GetParam().in.data();
  auto partial = fnva64_buf(data, partialLen);
  EXPECT_EQ(
      GetParam().out,
      fnva64_buf(
          data + partialLen, GetParam().in.size() - partialLen, partial));
}

Variable Documentation

constexpr bool k32Bit = sizeof(std::size_t) == 4

static

Definition at line 663 of file HashTest.cpp.