Debian Codegraph @

tests/parallel_hash_map_test.cc

raw
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