unordered_set_modifiers_test.h
Go to the documentation of this file.
1 // Copyright 2018 The Abseil Authors.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 #ifndef ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MODIFIERS_TEST_H_
16 #define ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MODIFIERS_TEST_H_
17 
18 #include "gmock/gmock.h"
19 #include "gtest/gtest.h"
22 
23 namespace absl {
24 namespace container_internal {
25 
26 template <class UnordSet>
27 class ModifiersTest : public ::testing::Test {};
28 
29 TYPED_TEST_SUITE_P(ModifiersTest);
30 
31 TYPED_TEST_P(ModifiersTest, Clear) {
32  using T = hash_internal::GeneratedType<TypeParam>;
33  std::vector<T> values;
34  std::generate_n(std::back_inserter(values), 10,
35  hash_internal::Generator<T>());
36  TypeParam m(values.begin(), values.end());
37  ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
38  m.clear();
39  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
40  EXPECT_TRUE(m.empty());
41 }
42 
43 TYPED_TEST_P(ModifiersTest, Insert) {
44  using T = hash_internal::GeneratedType<TypeParam>;
45  T val = hash_internal::Generator<T>()();
46  TypeParam m;
47  auto p = m.insert(val);
48  EXPECT_TRUE(p.second);
49  EXPECT_EQ(val, *p.first);
50  p = m.insert(val);
51  EXPECT_FALSE(p.second);
52 }
53 
54 TYPED_TEST_P(ModifiersTest, InsertHint) {
55  using T = hash_internal::GeneratedType<TypeParam>;
56  T val = hash_internal::Generator<T>()();
57  TypeParam m;
58  auto it = m.insert(m.end(), val);
59  EXPECT_TRUE(it != m.end());
60  EXPECT_EQ(val, *it);
61  it = m.insert(it, val);
62  EXPECT_TRUE(it != m.end());
63  EXPECT_EQ(val, *it);
64 }
65 
66 TYPED_TEST_P(ModifiersTest, InsertRange) {
67  using T = hash_internal::GeneratedType<TypeParam>;
68  std::vector<T> values;
69  std::generate_n(std::back_inserter(values), 10,
70  hash_internal::Generator<T>());
71  TypeParam m;
72  m.insert(values.begin(), values.end());
73  ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
74 }
75 
76 TYPED_TEST_P(ModifiersTest, Emplace) {
77  using T = hash_internal::GeneratedType<TypeParam>;
78  T val = hash_internal::Generator<T>()();
79  TypeParam m;
80  // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
81  // with test traits/policy.
82  auto p = m.emplace(val);
83  EXPECT_TRUE(p.second);
84  EXPECT_EQ(val, *p.first);
85  p = m.emplace(val);
86  EXPECT_FALSE(p.second);
87  EXPECT_EQ(val, *p.first);
88 }
89 
90 TYPED_TEST_P(ModifiersTest, EmplaceHint) {
91  using T = hash_internal::GeneratedType<TypeParam>;
92  T val = hash_internal::Generator<T>()();
93  TypeParam m;
94  // TODO(alkis): We need a way to run emplace in a more meaningful way. Perhaps
95  // with test traits/policy.
96  auto it = m.emplace_hint(m.end(), val);
97  EXPECT_EQ(val, *it);
98  it = m.emplace_hint(it, val);
99  EXPECT_EQ(val, *it);
100 }
101 
102 template <class V>
103 using IfNotVoid = typename std::enable_if<!std::is_void<V>::value, V>::type;
104 
105 // In openmap we chose not to return the iterator from erase because that's
106 // more expensive. As such we adapt erase to return an iterator here.
107 struct EraseFirst {
108  template <class Map>
109  auto operator()(Map* m, int) const
110  -> IfNotVoid<decltype(m->erase(m->begin()))> {
111  return m->erase(m->begin());
112  }
113  template <class Map>
114  typename Map::iterator operator()(Map* m, ...) const {
115  auto it = m->begin();
116  m->erase(it++);
117  return it;
118  }
119 };
120 
121 TYPED_TEST_P(ModifiersTest, Erase) {
123  std::vector<T> values;
124  std::generate_n(std::back_inserter(values), 10,
126  TypeParam m(values.begin(), values.end());
127  ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
128  std::vector<T> values2;
129  for (const auto& val : values)
130  if (val != *m.begin()) values2.push_back(val);
131  auto it = EraseFirst()(&m, 0);
132  ASSERT_TRUE(it != m.end());
133  EXPECT_EQ(1, std::count(values2.begin(), values2.end(), *it));
134  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values2.begin(),
135  values2.end()));
136 }
137 
138 TYPED_TEST_P(ModifiersTest, EraseRange) {
140  std::vector<T> values;
141  std::generate_n(std::back_inserter(values), 10,
143  TypeParam m(values.begin(), values.end());
144  ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
145  auto it = m.erase(m.begin(), m.end());
146  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAre());
147  EXPECT_TRUE(it == m.end());
148 }
149 
150 TYPED_TEST_P(ModifiersTest, EraseKey) {
152  std::vector<T> values;
153  std::generate_n(std::back_inserter(values), 10,
155  TypeParam m(values.begin(), values.end());
156  ASSERT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values));
157  EXPECT_EQ(1, m.erase(values[0]));
158  EXPECT_EQ(0, std::count(m.begin(), m.end(), values[0]));
159  EXPECT_THAT(keys(m), ::testing::UnorderedElementsAreArray(values.begin() + 1,
160  values.end()));
161 }
162 
165  std::vector<T> v1;
166  std::vector<T> v2;
167  std::generate_n(std::back_inserter(v1), 5, hash_internal::Generator<T>());
168  std::generate_n(std::back_inserter(v2), 5, hash_internal::Generator<T>());
169  TypeParam m1(v1.begin(), v1.end());
170  TypeParam m2(v2.begin(), v2.end());
171  EXPECT_THAT(keys(m1), ::testing::UnorderedElementsAreArray(v1));
172  EXPECT_THAT(keys(m2), ::testing::UnorderedElementsAreArray(v2));
173  m1.swap(m2);
174  EXPECT_THAT(keys(m1), ::testing::UnorderedElementsAreArray(v2));
175  EXPECT_THAT(keys(m2), ::testing::UnorderedElementsAreArray(v1));
176 }
177 
178 // TODO(alkis): Write tests for extract.
179 // TODO(alkis): Write tests for merge.
180 
181 REGISTER_TYPED_TEST_CASE_P(ModifiersTest, Clear, Insert, InsertHint,
182  InsertRange, Emplace, EmplaceHint, Erase, EraseRange,
183  EraseKey, Swap);
184 
185 } // namespace container_internal
186 } // namespace absl
187 
188 #endif // ABSL_CONTAINER_INTERNAL_UNORDERED_SET_MODIFIERS_TEST_H_
char * begin
typename std::enable_if<!std::is_void< V >::value, V >::type IfNotVoid
auto keys(const Set &s) -> std::vector< typename std::decay< typename Set::key_type >::type >
TYPED_TEST_SUITE_P(ConstructorTest)
Definition: algorithm.h:29
void Swap(T &lhs, T &rhs) noexcept(IsNothrowSwappable< T >::value)
Definition: type_traits.h:673
size_t value
TYPED_TEST_P(ConstructorTest, NoArgs)
decltype(std::declval< const Generator< typename std::conditional< generator_internal::IsMap< Container >::value, typename Container::value_type, typename Container::key_type >::type > & >()()) GeneratedType
auto operator()(Map *m, int) const -> IfNotVoid< decltype(m->erase(m->begin()))>
Map::iterator operator()(Map *m,...) const
REGISTER_TYPED_TEST_CASE_P(ConstructorTest, NoArgs, BucketCount, BucketCountHash, BucketCountHashEqual, BucketCountHashEqualAlloc, BucketCountAlloc, BucketCountHashAlloc, Alloc, InputIteratorBucketHashEqualAlloc, InputIteratorBucketAlloc, InputIteratorBucketHashAlloc, CopyConstructor, CopyConstructorAlloc, MoveConstructor, MoveConstructorAlloc, InitializerListBucketHashEqualAlloc, InitializerListBucketAlloc, InitializerListBucketHashAlloc, Assignment, MoveAssignment, AssignmentFromInitializerList, AssignmentOverwritesExisting, MoveAssignmentOverwritesExisting, AssignmentFromInitializerListOverwritesExisting, AssignmentOnSelf)


abseil_cpp
Author(s):
autogenerated on Wed Jun 19 2019 19:19:58