| 1 |
#ifndef THIS_HASH_MAP |
| 2 |
#define THIS_HASH_MAP parallel_flat_hash_map |
| 3 |
#define THIS_TEST_NAME ParallelFlatHashMap |
| 4 |
#endif |
| 5 |
|
| 6 |
#include "flat_hash_map_test.cc" |
| 7 |
|
| 8 |
namespace phmap { |
| 9 |
namespace priv { |
| 10 |
namespace { |
| 11 |
|
| 12 |
TEST(THIS_TEST_NAME, Swap) { |
| 13 |
using Map = ThisMap<int, int>; |
| 14 |
using MapB = ThisMap_NullMutex<int, int>; |
| 15 |
|
| 16 |
Map t; |
| 17 |
EXPECT_TRUE(t.find(0) == t.end()); |
| 18 |
auto res = t.emplace(0, 1); |
| 19 |
EXPECT_TRUE(res.second); |
| 20 |
EXPECT_EQ(1, t.size()); |
| 21 |
MapB u; |
| 22 |
t.swap(u); |
| 23 |
EXPECT_EQ(0, t.size()); |
| 24 |
EXPECT_EQ(1, u.size()); |
| 25 |
EXPECT_TRUE(t.find(0) == t.end()); |
| 26 |
EXPECT_TRUE(u[0] == 1); |
| 27 |
} |
| 28 |
|
| 29 |
|
| 30 |
TEST(THIS_TEST_NAME, IfContains) { |
| 31 |
// ---------------- |
| 32 |
// test if_contains |
| 33 |
// ---------------- |
| 34 |
|
| 35 |
using Map = ThisMap<int, int>; |
| 36 |
Map m = { {1, 7}, {2, 9} }; |
| 37 |
const Map& const_m(m); |
| 38 |
|
| 39 |
auto val = 0; |
| 40 |
auto get_value = [&val](const Map::value_type& v) { val = v.second; }; |
| 41 |
EXPECT_TRUE(const_m.if_contains(2, get_value)); |
| 42 |
EXPECT_EQ(val, 9); |
| 43 |
|
| 44 |
EXPECT_FALSE(m.if_contains(3, get_value)); |
| 45 |
} |
| 46 |
|
| 47 |
TEST(THIS_TEST_NAME, ModifyIf) { |
| 48 |
// -------------- |
| 49 |
// test modify_if |
| 50 |
// -------------- |
| 51 |
using Map = ThisMap<int, int>; |
| 52 |
Map m = { {1, 7}, {2, 9} }; |
| 53 |
|
| 54 |
auto set_value = [](Map::value_type& v) { v.second = 11; }; |
| 55 |
EXPECT_TRUE(m.modify_if(2, set_value)); |
| 56 |
EXPECT_EQ(m[2], 11); |
| 57 |
|
| 58 |
EXPECT_FALSE(m.modify_if(3, set_value)); // because m[3] does not exist |
| 59 |
} |
| 60 |
|
| 61 |
TEST(THIS_TEST_NAME, TryEmplaceL) { |
| 62 |
// ------------------ |
| 63 |
// test try_emplace_l |
| 64 |
// ------------------ |
| 65 |
using Map = ThisMap<int, int>; |
| 66 |
Map m = { {1, 7}, {2, 9} }; |
| 67 |
|
| 68 |
// overwrite an existing value |
| 69 |
m.try_emplace_l(2, [](Map::value_type& v) { v.second = 5; }); |
| 70 |
EXPECT_EQ(m[2], 5); |
| 71 |
|
| 72 |
// insert a value that is not already present. Will be default initialised to 0 and lambda not called |
| 73 |
m.try_emplace_l(3, |
| 74 |
[](Map::value_type& v) { v.second = 6; }, // called only when key was already present |
| 75 |
1); // argument to construct new value is key not present |
| 76 |
EXPECT_EQ(m[3], 1); |
| 77 |
|
| 78 |
// insert a value that is not already present, provide argument to value-construct it |
| 79 |
m.try_emplace_l(4, |
| 80 |
[](Map::value_type& ) {}, // called only when key was already present |
| 81 |
999); // argument to construct new value is key not present |
| 82 |
|
| 83 |
EXPECT_EQ(m[4], 999); |
| 84 |
} |
| 85 |
|
| 86 |
TEST(THIS_TEST_NAME, LazyEmplaceL) { |
| 87 |
// -------------------- |
| 88 |
// test lazy_emplace_l |
| 89 |
// -------------------- |
| 90 |
using Map = ThisMap<int, int>; |
| 91 |
Map m = { {1, 7}, {2, 9} }; |
| 92 |
|
| 93 |
// insert a value that is not already present. |
| 94 |
// right now m[5] does not exist |
| 95 |
m.lazy_emplace_l(5, |
| 96 |
[](Map::value_type& v) { v.second = 6; }, // called only when key was already present |
| 97 |
[](const Map::constructor& ctor) { ctor(5, 13); }); // construct value_type in place when key not present |
| 98 |
EXPECT_EQ(m[5], 13); |
| 99 |
|
| 100 |
// change a value that is present. Currently m[5] == 13 |
| 101 |
m.lazy_emplace_l(5, |
| 102 |
[](Map::value_type& v) { v.second = 6; }, // called only when key was already present |
| 103 |
[](const Map::constructor& ctor) { ctor(5, 13); }); // construct value_type in place when key not present |
| 104 |
EXPECT_EQ(m[5], 6); |
| 105 |
} |
| 106 |
|
| 107 |
TEST(THIS_TEST_NAME, EraseIf) { |
| 108 |
// ------------- |
| 109 |
// test erase_if |
| 110 |
// ------------- |
| 111 |
using Map = ThisMap<int, int>; |
| 112 |
Map m = { {1, 7}, {2, 9}, {5, 6} }; |
| 113 |
|
| 114 |
EXPECT_EQ(m.erase_if(9, [](Map::value_type& v) { assert(0); return v.second == 12; }), false); // m[9] not present - lambda not called |
| 115 |
EXPECT_EQ(m.erase_if(5, [](Map::value_type& v) { return v.second == 12; }), false); // m[5] == 6, so erase not performed |
| 116 |
EXPECT_EQ(m[5], 6); |
| 117 |
EXPECT_EQ(m.erase_if(5, [](Map::value_type& v) { return v.second == 6; }), true); // lambda returns true, so m[5] erased |
| 118 |
EXPECT_EQ(m[5], 0); |
| 119 |
} |
| 120 |
|
| 121 |
TEST(THIS_TEST_NAME, ForEach) { |
| 122 |
// ------------- |
| 123 |
// test for_each |
| 124 |
// ------------- |
| 125 |
using Map = ThisMap<int, int>; |
| 126 |
Map m = { {1, 7}, {2, 8}, {5, 11} }; |
| 127 |
|
| 128 |
// increment all values by 1 |
| 129 |
m.for_each_m([](Map::value_type &pair) { ++pair.second; }); |
| 130 |
|
| 131 |
int counter = 0; |
| 132 |
m.for_each([&counter](const Map::value_type &pair) { |
| 133 |
++counter; |
| 134 |
EXPECT_EQ(pair.first + 7, pair.second); |
| 135 |
}); |
| 136 |
EXPECT_EQ(counter, 3); |
| 137 |
|
| 138 |
counter = 0; |
| 139 |
for (size_t i=0; i<m.subcnt(); ++i) { |
| 140 |
m.with_submap(i, [&](const Map::EmbeddedSet& set) { |
| 141 |
for (auto& p : set) { |
| 142 |
++counter; |
| 143 |
EXPECT_EQ(p.first + 7, p.second); |
| 144 |
} |
| 145 |
}); |
| 146 |
} |
| 147 |
EXPECT_EQ(counter, 3); |
| 148 |
} |
| 149 |
|
| 150 |
TEST(THIS_TEST_NAME, EmplaceSingle) { |
| 151 |
// -------------------- |
| 152 |
// test emplace_single |
| 153 |
// -------------------- |
| 154 |
using Map = ThisMap<int, int>; |
| 155 |
Map m = { {1, 4}, {11, 4} }; |
| 156 |
|
| 157 |
// emplace_single insert a value if not already present, else removes it |
| 158 |
for (int i=0; i<12; ++i) |
| 159 |
m.emplace_single(i, [i](const Map::constructor& ctor) { ctor(i, 4); }); |
| 160 |
EXPECT_EQ(m.count(0), 1); |
| 161 |
EXPECT_EQ(m.count(1), 0); |
| 162 |
EXPECT_EQ(m.count(2), 1); |
| 163 |
EXPECT_EQ(m.count(11), 0); |
| 164 |
} |
| 165 |
|
| 166 |
|
| 167 |
} // namespace |
| 168 |
} // namespace priv |
| 169 |
} // namespace phmap |