| 1 |
#ifndef THIS_HASH_SET |
| 2 |
#define THIS_HASH_SET parallel_flat_hash_set |
| 3 |
#define THIS_TEST_NAME ParallelFlatHashSet |
| 4 |
#endif |
| 5 |
|
| 6 |
#include "flat_hash_set_test.cc" |
| 7 |
|
| 8 |
namespace phmap { |
| 9 |
namespace priv { |
| 10 |
namespace { |
| 11 |
|
| 12 |
struct Entry |
| 13 |
{ |
| 14 |
Entry(int k, int v=0) : key(k), value(v) {} |
| 15 |
|
| 16 |
bool operator==(const Entry &o) const |
| 17 |
{ |
| 18 |
return key == o.key; // not checking value |
| 19 |
} |
| 20 |
|
| 21 |
// Demonstrates how to provide the hash function as a friend member function of the class |
| 22 |
// This can be used as an alternative to providing a std::hash<Person> specialization |
| 23 |
// -------------------------------------------------------------------------------------- |
| 24 |
friend size_t hash_value(const Entry &p) |
| 25 |
{ |
| 26 |
return phmap::HashState().combine(0, p.key); // not checking value |
| 27 |
} |
| 28 |
|
| 29 |
int key; |
| 30 |
int value; |
| 31 |
}; |
| 32 |
|
| 33 |
TEST(THIS_TEST_NAME, IfContains) { |
| 34 |
// ---------------- |
| 35 |
// test if_contains |
| 36 |
// ---------------- |
| 37 |
using Set = phmap::THIS_HASH_SET<Entry>; |
| 38 |
Set m = { {1, 7}, {2, 9} }; |
| 39 |
const Set& const_m(m); |
| 40 |
|
| 41 |
auto val = 0; |
| 42 |
auto get_value = [&val](const Set::value_type& v) { val = v.value; }; |
| 43 |
EXPECT_TRUE(const_m.if_contains(Entry{2}, get_value)); |
| 44 |
EXPECT_EQ(val, 9); |
| 45 |
|
| 46 |
EXPECT_FALSE(m.if_contains(Entry{3}, get_value)); |
| 47 |
} |
| 48 |
|
| 49 |
TEST(THIS_TEST_NAME, ModifyIf) { |
| 50 |
// -------------- |
| 51 |
// test modify_if |
| 52 |
// -------------- |
| 53 |
using Set = phmap::THIS_HASH_SET<Entry>; |
| 54 |
Set m = { {1, 7}, {2, 9} }; |
| 55 |
|
| 56 |
auto set_value = [](Set::value_type& v) { v.value = 11; }; |
| 57 |
EXPECT_TRUE(m.modify_if(Entry{2}, set_value)); |
| 58 |
|
| 59 |
auto val = 0; |
| 60 |
auto get_value = [&val](const Set::value_type& v) { val = v.value; }; |
| 61 |
EXPECT_TRUE(m.if_contains(Entry{2}, get_value)); |
| 62 |
EXPECT_EQ(val, 11); |
| 63 |
|
| 64 |
EXPECT_FALSE(m.modify_if(Entry{3}, set_value)); // because m[3] does not exist |
| 65 |
} |
| 66 |
|
| 67 |
TEST(THIS_TEST_NAME, LazyEmplaceL) { |
| 68 |
// -------------------- |
| 69 |
// test lazy_emplace_l |
| 70 |
// -------------------- |
| 71 |
using Set = phmap::THIS_HASH_SET<Entry>; |
| 72 |
Set m = { {1, 7}, {2, 9} }; |
| 73 |
|
| 74 |
// insert a value that is not already present. |
| 75 |
// right now m[5] does not exist |
| 76 |
m.lazy_emplace_l(Entry{5}, |
| 77 |
[](Set::value_type& v) { v.value = 6; }, // called only when key was already present |
| 78 |
[](const Set::constructor& ctor) { ctor(5, 13); }); // construct value_type in place when key not present |
| 79 |
EXPECT_EQ(m.find(Entry{5})->value, 13); |
| 80 |
|
| 81 |
// change a value that is present. |
| 82 |
m.lazy_emplace_l(Entry{5}, |
| 83 |
[](Set::value_type& v) { v.value = 6; }, // called only when key was already present |
| 84 |
[](const Set::constructor& ctor) { ctor(5, 13); }); // construct value_type in place when key not present |
| 85 |
EXPECT_EQ(m.find(Entry{5})->value, 6); |
| 86 |
} |
| 87 |
|
| 88 |
TEST(THIS_TEST_NAME, EraseIf) { |
| 89 |
// ------------- |
| 90 |
// test erase_if |
| 91 |
// ------------- |
| 92 |
using Set = phmap::THIS_HASH_SET<Entry>; |
| 93 |
Set m = { {1, 7}, {2, 9}, {5, 6} }; |
| 94 |
|
| 95 |
EXPECT_EQ(m.erase_if(Entry{9}, [](Set::value_type& v) { assert(0); return v.value == 12; }), false); // m[9] not present - lambda not called |
| 96 |
EXPECT_EQ(m.erase_if(Entry{5}, [](Set::value_type& v) { return v.value == 12; }), false); // m[5] == 6, so erase not performed |
| 97 |
EXPECT_EQ(m.find(Entry{5})->value, 6); |
| 98 |
EXPECT_EQ(m.erase_if(Entry{5}, [](Set::value_type& v) { return v.value == 6; }), true); // lambda returns true, so m[5] erased |
| 99 |
EXPECT_EQ(m.find(Entry{5}), m.end()); |
| 100 |
} |
| 101 |
|
| 102 |
TEST(THIS_TEST_NAME, ForEach) { |
| 103 |
// ------------- |
| 104 |
// test for_each |
| 105 |
// ------------- |
| 106 |
using Set = phmap::THIS_HASH_SET<Entry>; |
| 107 |
Set m = { {1, 7}, {2, 8}, {5, 11} }; |
| 108 |
|
| 109 |
int counter = 0; |
| 110 |
m.for_each([&counter](const Set::value_type &v) { |
| 111 |
++counter; |
| 112 |
EXPECT_EQ(v.key + 6, v.value); |
| 113 |
}); |
| 114 |
EXPECT_EQ(counter, 3); |
| 115 |
} |
| 116 |
|
| 117 |
TEST(THIS_TEST_NAME, EmplaceSingle) { |
| 118 |
using Set = phmap::THIS_HASH_SET<int>; |
| 119 |
|
| 120 |
// -------------------- |
| 121 |
// test emplace_single |
| 122 |
// -------------------- |
| 123 |
Set m = { 1, 11 }; |
| 124 |
|
| 125 |
// emplace_single insert a value if not already present, else removes it |
| 126 |
for (int i=0; i<12; ++i) |
| 127 |
m.emplace_single(i, [i](const Set::constructor& ctor) { ctor(i); }); |
| 128 |
EXPECT_EQ(m.count(0), 1); |
| 129 |
EXPECT_EQ(m.count(1), 0); |
| 130 |
EXPECT_EQ(m.count(2), 1); |
| 131 |
EXPECT_EQ(m.count(11), 0); |
| 132 |
} |
| 133 |
|
| 134 |
} // namespace |
| 135 |
} // namespace priv |
| 136 |
} // namespace phmap |