Debian Codegraph @

tests/parallel_hash_set_test.cc

raw
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