blob: 489e1f43ca188c05003aa2f78199725a0c3aa504 [file] [log] [blame]
Max Boguefef332d2016-07-28 22:09:091// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
Albert J. Wongd1bfdb022021-08-11 17:52:485#include "base/containers/enum_set.h"
Max Boguefef332d2016-07-28 22:09:096
7#include <stddef.h>
8
Dan McArdlee6914572021-12-15 19:10:019#include "base/test/gtest_util.h"
10#include "testing/gtest/include/gtest/gtest-death-test.h"
Max Boguefef332d2016-07-28 22:09:0911#include "testing/gtest/include/gtest/gtest.h"
12
Fergal Dalydd4e8c52021-07-05 03:19:0513namespace base {
Max Boguefef332d2016-07-28 22:09:0914namespace {
15
Maksim Moskvitincfdd1282019-01-31 13:16:1916enum class TestEnum {
Dan McArdlee6914572021-12-15 19:10:0117 TEST_BELOW_MIN_NEGATIVE = -1,
18 TEST_BELOW_MIN = 0,
Fergal Daly74a98992021-07-05 03:54:4119 TEST_1 = 1,
20 TEST_MIN = TEST_1,
Max Boguefef332d2016-07-28 22:09:0921 TEST_2,
22 TEST_3,
23 TEST_4,
Fergal Daly74a98992021-07-05 03:54:4124 TEST_5,
25 TEST_MAX = TEST_5,
Dan McArdlee6914572021-12-15 19:10:0126 TEST_6_OUT_OF_BOUNDS,
27 TEST_7_OUT_OF_BOUNDS
Max Boguefef332d2016-07-28 22:09:0928};
Maksim Moskvitincfdd1282019-01-31 13:16:1929using TestEnumSet = EnumSet<TestEnum, TestEnum::TEST_MIN, TestEnum::TEST_MAX>;
Max Boguefef332d2016-07-28 22:09:0930
Fergal Daly16e30f012021-07-05 03:45:5931enum class TestEnumExtreme {
32 TEST_0 = 0,
33 TEST_MIN = TEST_0,
34 TEST_63 = 63,
35 TEST_MAX = TEST_63,
36 TEST_64_OUT_OF_BOUNDS,
37};
38using TestEnumExtremeSet = EnumSet<TestEnumExtreme,
39 TestEnumExtreme::TEST_MIN,
40 TestEnumExtreme::TEST_MAX>;
41
Max Boguefef332d2016-07-28 22:09:0942class EnumSetTest : public ::testing::Test {};
Dan McArdlee6914572021-12-15 19:10:0143class EnumSetDeathTest : public ::testing::Test {};
Max Boguefef332d2016-07-28 22:09:0944
45TEST_F(EnumSetTest, ClassConstants) {
Maksim Moskvitincfdd1282019-01-31 13:16:1946 EXPECT_EQ(TestEnum::TEST_MIN, TestEnumSet::kMinValue);
47 EXPECT_EQ(TestEnum::TEST_MAX, TestEnumSet::kMaxValue);
Max Boguefef332d2016-07-28 22:09:0948 EXPECT_EQ(static_cast<size_t>(5), TestEnumSet::kValueCount);
49}
50
pnoland4d8a7c12017-06-13 00:52:0951// Use static_assert to check that functions we expect to be compile time
52// evaluatable are really that way.
53TEST_F(EnumSetTest, ConstexprsAreValid) {
Fergal Daly74a98992021-07-05 03:54:4154 static_assert(TestEnumSet::All().Has(TestEnum::TEST_2),
Dan McArdlee6914572021-12-15 19:10:0155 "Expected All() to be integral constant expression");
Fergal Daly74a98992021-07-05 03:54:4156 static_assert(TestEnumSet::FromRange(TestEnum::TEST_2, TestEnum::TEST_4)
57 .Has(TestEnum::TEST_2),
Dan McArdlee6914572021-12-15 19:10:0158 "Expected FromRange() to be integral constant expression");
Fergal Daly74a98992021-07-05 03:54:4159 static_assert(TestEnumSet(TestEnum::TEST_2).Has(TestEnum::TEST_2),
Dan McArdlee6914572021-12-15 19:10:0160 "Expected TestEnumSet() to be integral constant expression");
Fergal Daly74a98992021-07-05 03:54:4161 static_assert(
62 TestEnumSet::FromEnumBitmask(1 << static_cast<uint64_t>(TestEnum::TEST_2))
63 .Has(TestEnum::TEST_2),
64 "Expected TestEnumSet() to be integral constant expression");
Dan McArdlee6914572021-12-15 19:10:0165 static_assert(
66 TestEnumSet::single_val_bitstring(TestEnum::TEST_1) == 1,
67 "Expected single_val_bitstring() to be integral constant expression");
68 static_assert(TestEnumSet::bitstring(TestEnum::TEST_1, TestEnum::TEST_2) == 3,
69 "Expected bitstring() to be integral constant expression");
pnoland4d8a7c12017-06-13 00:52:0970}
71
Max Boguefef332d2016-07-28 22:09:0972TEST_F(EnumSetTest, DefaultConstructor) {
73 const TestEnumSet enums;
74 EXPECT_TRUE(enums.Empty());
75 EXPECT_EQ(static_cast<size_t>(0), enums.Size());
Maksim Moskvitincfdd1282019-01-31 13:16:1976 EXPECT_FALSE(enums.Has(TestEnum::TEST_1));
77 EXPECT_FALSE(enums.Has(TestEnum::TEST_2));
78 EXPECT_FALSE(enums.Has(TestEnum::TEST_3));
79 EXPECT_FALSE(enums.Has(TestEnum::TEST_4));
Fergal Daly74a98992021-07-05 03:54:4180 EXPECT_FALSE(enums.Has(TestEnum::TEST_5));
Max Boguefef332d2016-07-28 22:09:0981}
82
83TEST_F(EnumSetTest, OneArgConstructor) {
Fergal Daly74a98992021-07-05 03:54:4184 const TestEnumSet enums(TestEnum::TEST_4);
Max Boguefef332d2016-07-28 22:09:0985 EXPECT_FALSE(enums.Empty());
86 EXPECT_EQ(static_cast<size_t>(1), enums.Size());
Maksim Moskvitincfdd1282019-01-31 13:16:1987 EXPECT_FALSE(enums.Has(TestEnum::TEST_1));
88 EXPECT_FALSE(enums.Has(TestEnum::TEST_2));
Fergal Daly74a98992021-07-05 03:54:4189 EXPECT_FALSE(enums.Has(TestEnum::TEST_3));
90 EXPECT_TRUE(enums.Has(TestEnum::TEST_4));
91 EXPECT_FALSE(enums.Has(TestEnum::TEST_5));
Max Boguefef332d2016-07-28 22:09:0992}
93
Fergal Daly16e30f012021-07-05 03:45:5994TEST_F(EnumSetTest, OneArgConstructorSize) {
95 TestEnumExtremeSet enums(TestEnumExtreme::TEST_0);
96 EXPECT_TRUE(enums.Has(TestEnumExtreme::TEST_0));
97}
98
Max Boguefef332d2016-07-28 22:09:0999TEST_F(EnumSetTest, TwoArgConstructor) {
Fergal Daly74a98992021-07-05 03:54:41100 const TestEnumSet enums(TestEnum::TEST_4, TestEnum::TEST_2);
Max Boguefef332d2016-07-28 22:09:09101 EXPECT_FALSE(enums.Empty());
102 EXPECT_EQ(static_cast<size_t>(2), enums.Size());
Fergal Daly74a98992021-07-05 03:54:41103 EXPECT_FALSE(enums.Has(TestEnum::TEST_1));
104 EXPECT_TRUE(enums.Has(TestEnum::TEST_2));
105 EXPECT_FALSE(enums.Has(TestEnum::TEST_3));
106 EXPECT_TRUE(enums.Has(TestEnum::TEST_4));
107 EXPECT_FALSE(enums.Has(TestEnum::TEST_5));
Max Boguefef332d2016-07-28 22:09:09108}
109
110TEST_F(EnumSetTest, ThreeArgConstructor) {
Fergal Daly74a98992021-07-05 03:54:41111 const TestEnumSet enums(TestEnum::TEST_4, TestEnum::TEST_2, TestEnum::TEST_1);
Max Boguefef332d2016-07-28 22:09:09112 EXPECT_FALSE(enums.Empty());
113 EXPECT_EQ(static_cast<size_t>(3), enums.Size());
Maksim Moskvitincfdd1282019-01-31 13:16:19114 EXPECT_TRUE(enums.Has(TestEnum::TEST_1));
Fergal Daly74a98992021-07-05 03:54:41115 EXPECT_TRUE(enums.Has(TestEnum::TEST_2));
116 EXPECT_FALSE(enums.Has(TestEnum::TEST_3));
117 EXPECT_TRUE(enums.Has(TestEnum::TEST_4));
118 EXPECT_FALSE(enums.Has(TestEnum::TEST_5));
Max Boguefef332d2016-07-28 22:09:09119}
120
skyme8c91962017-02-28 16:31:15121TEST_F(EnumSetTest, DuplicatesInConstructor) {
Fergal Daly74a98992021-07-05 03:54:41122 EXPECT_EQ(TestEnumSet(TestEnum::TEST_4, TestEnum::TEST_2, TestEnum::TEST_1,
123 TestEnum::TEST_4, TestEnum::TEST_2, TestEnum::TEST_4),
124 TestEnumSet(TestEnum::TEST_1, TestEnum::TEST_2, TestEnum::TEST_4));
skyme8c91962017-02-28 16:31:15125}
126
Max Boguefef332d2016-07-28 22:09:09127TEST_F(EnumSetTest, All) {
128 const TestEnumSet enums(TestEnumSet::All());
129 EXPECT_FALSE(enums.Empty());
130 EXPECT_EQ(static_cast<size_t>(5), enums.Size());
Maksim Moskvitincfdd1282019-01-31 13:16:19131 EXPECT_TRUE(enums.Has(TestEnum::TEST_1));
132 EXPECT_TRUE(enums.Has(TestEnum::TEST_2));
133 EXPECT_TRUE(enums.Has(TestEnum::TEST_3));
134 EXPECT_TRUE(enums.Has(TestEnum::TEST_4));
Fergal Daly74a98992021-07-05 03:54:41135 EXPECT_TRUE(enums.Has(TestEnum::TEST_5));
Max Boguefef332d2016-07-28 22:09:09136}
137
skyme8c91962017-02-28 16:31:15138TEST_F(EnumSetTest, FromRange) {
Fergal Daly74a98992021-07-05 03:54:41139 EXPECT_EQ(TestEnumSet(TestEnum::TEST_2, TestEnum::TEST_3, TestEnum::TEST_4),
140 TestEnumSet::FromRange(TestEnum::TEST_2, TestEnum::TEST_4));
Maksim Moskvitincfdd1282019-01-31 13:16:19141 EXPECT_EQ(TestEnumSet::All(),
Fergal Daly74a98992021-07-05 03:54:41142 TestEnumSet::FromRange(TestEnum::TEST_1, TestEnum::TEST_5));
143 EXPECT_EQ(TestEnumSet(TestEnum::TEST_2),
144 TestEnumSet::FromRange(TestEnum::TEST_2, TestEnum::TEST_2));
pnoland4d8a7c12017-06-13 00:52:09145
Maksim Moskvitincfdd1282019-01-31 13:16:19146 using RestrictedRangeSet =
Fergal Daly74a98992021-07-05 03:54:41147 EnumSet<TestEnum, TestEnum::TEST_2, TestEnum::TEST_MAX>;
Maksim Moskvitincfdd1282019-01-31 13:16:19148 EXPECT_EQ(
Fergal Daly74a98992021-07-05 03:54:41149 RestrictedRangeSet(TestEnum::TEST_2, TestEnum::TEST_3, TestEnum::TEST_4),
150 RestrictedRangeSet::FromRange(TestEnum::TEST_2, TestEnum::TEST_4));
pnoland4d8a7c12017-06-13 00:52:09151 EXPECT_EQ(RestrictedRangeSet::All(),
Fergal Daly74a98992021-07-05 03:54:41152 RestrictedRangeSet::FromRange(TestEnum::TEST_2, TestEnum::TEST_5));
skyme8c91962017-02-28 16:31:15153}
154
Max Boguefef332d2016-07-28 22:09:09155TEST_F(EnumSetTest, Put) {
Fergal Daly74a98992021-07-05 03:54:41156 TestEnumSet enums(TestEnum::TEST_4);
157 enums.Put(TestEnum::TEST_3);
158 EXPECT_EQ(TestEnumSet(TestEnum::TEST_3, TestEnum::TEST_4), enums);
159 enums.Put(TestEnum::TEST_5);
160 EXPECT_EQ(TestEnumSet(TestEnum::TEST_3, TestEnum::TEST_4, TestEnum::TEST_5),
Maksim Moskvitincfdd1282019-01-31 13:16:19161 enums);
Max Boguefef332d2016-07-28 22:09:09162}
163
164TEST_F(EnumSetTest, PutAll) {
Fergal Daly74a98992021-07-05 03:54:41165 TestEnumSet enums(TestEnum::TEST_4, TestEnum::TEST_5);
166 enums.PutAll(TestEnumSet(TestEnum::TEST_3, TestEnum::TEST_4));
167 EXPECT_EQ(TestEnumSet(TestEnum::TEST_3, TestEnum::TEST_4, TestEnum::TEST_5),
Maksim Moskvitincfdd1282019-01-31 13:16:19168 enums);
Max Boguefef332d2016-07-28 22:09:09169}
170
skyme8c91962017-02-28 16:31:15171TEST_F(EnumSetTest, PutRange) {
172 TestEnumSet enums;
Fergal Daly74a98992021-07-05 03:54:41173 enums.PutRange(TestEnum::TEST_2, TestEnum::TEST_4);
174 EXPECT_EQ(TestEnumSet(TestEnum::TEST_2, TestEnum::TEST_3, TestEnum::TEST_4),
Maksim Moskvitincfdd1282019-01-31 13:16:19175 enums);
skyme8c91962017-02-28 16:31:15176}
177
Max Boguefef332d2016-07-28 22:09:09178TEST_F(EnumSetTest, RetainAll) {
Fergal Daly74a98992021-07-05 03:54:41179 TestEnumSet enums(TestEnum::TEST_4, TestEnum::TEST_5);
180 enums.RetainAll(TestEnumSet(TestEnum::TEST_3, TestEnum::TEST_4));
181 EXPECT_EQ(TestEnumSet(TestEnum::TEST_4), enums);
Max Boguefef332d2016-07-28 22:09:09182}
183
184TEST_F(EnumSetTest, Remove) {
Fergal Daly74a98992021-07-05 03:54:41185 TestEnumSet enums(TestEnum::TEST_4, TestEnum::TEST_5);
186 enums.Remove(TestEnum::TEST_1);
Maksim Moskvitincfdd1282019-01-31 13:16:19187 enums.Remove(TestEnum::TEST_3);
Fergal Daly74a98992021-07-05 03:54:41188 EXPECT_EQ(TestEnumSet(TestEnum::TEST_4, TestEnum::TEST_5), enums);
Maksim Moskvitincfdd1282019-01-31 13:16:19189 enums.Remove(TestEnum::TEST_4);
Fergal Daly74a98992021-07-05 03:54:41190 EXPECT_EQ(TestEnumSet(TestEnum::TEST_5), enums);
Maksim Moskvitincfdd1282019-01-31 13:16:19191 enums.Remove(TestEnum::TEST_5);
Fergal Daly74a98992021-07-05 03:54:41192 enums.Remove(TestEnum::TEST_6_OUT_OF_BOUNDS);
Max Boguefef332d2016-07-28 22:09:09193 EXPECT_TRUE(enums.Empty());
194}
195
196TEST_F(EnumSetTest, RemoveAll) {
Fergal Daly74a98992021-07-05 03:54:41197 TestEnumSet enums(TestEnum::TEST_4, TestEnum::TEST_5);
198 enums.RemoveAll(TestEnumSet(TestEnum::TEST_3, TestEnum::TEST_4));
199 EXPECT_EQ(TestEnumSet(TestEnum::TEST_5), enums);
Max Boguefef332d2016-07-28 22:09:09200}
201
202TEST_F(EnumSetTest, Clear) {
Fergal Daly74a98992021-07-05 03:54:41203 TestEnumSet enums(TestEnum::TEST_4, TestEnum::TEST_5);
Max Boguefef332d2016-07-28 22:09:09204 enums.Clear();
205 EXPECT_TRUE(enums.Empty());
206}
207
208TEST_F(EnumSetTest, Has) {
Fergal Daly74a98992021-07-05 03:54:41209 const TestEnumSet enums(TestEnum::TEST_4, TestEnum::TEST_5);
Maksim Moskvitincfdd1282019-01-31 13:16:19210 EXPECT_FALSE(enums.Has(TestEnum::TEST_1));
211 EXPECT_FALSE(enums.Has(TestEnum::TEST_2));
Fergal Daly74a98992021-07-05 03:54:41212 EXPECT_FALSE(enums.Has(TestEnum::TEST_3));
Maksim Moskvitincfdd1282019-01-31 13:16:19213 EXPECT_TRUE(enums.Has(TestEnum::TEST_4));
Fergal Daly74a98992021-07-05 03:54:41214 EXPECT_TRUE(enums.Has(TestEnum::TEST_5));
215 EXPECT_FALSE(enums.Has(TestEnum::TEST_6_OUT_OF_BOUNDS));
Max Boguefef332d2016-07-28 22:09:09216}
217
218TEST_F(EnumSetTest, HasAll) {
Fergal Daly74a98992021-07-05 03:54:41219 const TestEnumSet enums1(TestEnum::TEST_4, TestEnum::TEST_5);
220 const TestEnumSet enums2(TestEnum::TEST_3, TestEnum::TEST_4);
Max Boguefef332d2016-07-28 22:09:09221 const TestEnumSet enums3 = Union(enums1, enums2);
222 EXPECT_TRUE(enums1.HasAll(enums1));
223 EXPECT_FALSE(enums1.HasAll(enums2));
224 EXPECT_FALSE(enums1.HasAll(enums3));
225
226 EXPECT_FALSE(enums2.HasAll(enums1));
227 EXPECT_TRUE(enums2.HasAll(enums2));
228 EXPECT_FALSE(enums2.HasAll(enums3));
229
230 EXPECT_TRUE(enums3.HasAll(enums1));
231 EXPECT_TRUE(enums3.HasAll(enums2));
232 EXPECT_TRUE(enums3.HasAll(enums3));
233}
234
235TEST_F(EnumSetTest, Iterators) {
Fergal Daly74a98992021-07-05 03:54:41236 const TestEnumSet enums1(TestEnum::TEST_4, TestEnum::TEST_5);
Max Boguefef332d2016-07-28 22:09:09237 TestEnumSet enums2;
David Davidović64a65922018-08-17 10:54:16238 for (TestEnumSet::Iterator it = enums1.begin(); it != enums1.end(); it++) {
239 enums2.Put(*it);
Max Boguefef332d2016-07-28 22:09:09240 }
241 EXPECT_EQ(enums2, enums1);
242}
243
David Davidović75f9b722018-08-16 19:16:11244TEST_F(EnumSetTest, RangeBasedForLoop) {
Dan McArdlee6914572021-12-15 19:10:01245 const TestEnumSet enums1(TestEnum::TEST_2, TestEnum::TEST_5);
David Davidović75f9b722018-08-16 19:16:11246 TestEnumSet enums2;
247 for (TestEnum e : enums1) {
248 enums2.Put(e);
249 }
250 EXPECT_EQ(enums2, enums1);
251}
252
253TEST_F(EnumSetTest, IteratorComparisonOperators) {
Dan McArdlee6914572021-12-15 19:10:01254 const TestEnumSet enums(TestEnum::TEST_2, TestEnum::TEST_4);
David Davidović75f9b722018-08-16 19:16:11255 const auto first_it = enums.begin();
256 const auto second_it = ++enums.begin();
257
258 // Copy for equality testing.
259 const auto first_it_copy = first_it;
260
261 // Sanity check, as the rest of the test relies on |first_it| and
262 // |first_it_copy| pointing to the same element and |first_it| and |second_it|
263 // pointing to different elements.
264 ASSERT_EQ(*first_it, *first_it_copy);
265 ASSERT_NE(*first_it, *second_it);
266
267 EXPECT_TRUE(first_it == first_it_copy);
268 EXPECT_FALSE(first_it != first_it_copy);
269
270 EXPECT_TRUE(first_it != second_it);
271 EXPECT_FALSE(first_it == second_it);
272}
273
274TEST_F(EnumSetTest, IteratorIncrementOperators) {
Dan McArdlee6914572021-12-15 19:10:01275 const TestEnumSet enums(TestEnum::TEST_2, TestEnum::TEST_4);
David Davidović75f9b722018-08-16 19:16:11276 const auto begin = enums.begin();
277
278 auto post_inc_it = begin;
279 auto pre_inc_it = begin;
280
281 auto post_inc_return_it = post_inc_it++;
282 auto pre_inc_return_it = ++pre_inc_it;
283
284 // |pre_inc_it| and |post_inc_it| should point to the same element.
285 EXPECT_EQ(pre_inc_it, post_inc_it);
286 EXPECT_EQ(*pre_inc_it, *post_inc_it);
287
288 // |pre_inc_it| should NOT point to the first element.
289 EXPECT_NE(begin, pre_inc_it);
290 EXPECT_NE(*begin, *pre_inc_it);
291
292 // |post_inc_it| should NOT point to the first element.
293 EXPECT_NE(begin, post_inc_it);
294 EXPECT_NE(*begin, *post_inc_it);
295
296 // Prefix increment should return new iterator.
297 EXPECT_EQ(pre_inc_return_it, post_inc_it);
298 EXPECT_EQ(*pre_inc_return_it, *post_inc_it);
299
300 // Postfix increment should return original iterator.
301 EXPECT_EQ(post_inc_return_it, begin);
302 EXPECT_EQ(*post_inc_return_it, *begin);
303}
304
Max Boguefef332d2016-07-28 22:09:09305TEST_F(EnumSetTest, Union) {
Fergal Daly74a98992021-07-05 03:54:41306 const TestEnumSet enums1(TestEnum::TEST_4, TestEnum::TEST_5);
307 const TestEnumSet enums2(TestEnum::TEST_3, TestEnum::TEST_4);
Max Boguefef332d2016-07-28 22:09:09308 const TestEnumSet enums3 = Union(enums1, enums2);
309
Fergal Daly74a98992021-07-05 03:54:41310 EXPECT_EQ(TestEnumSet(TestEnum::TEST_3, TestEnum::TEST_4, TestEnum::TEST_5),
Maksim Moskvitincfdd1282019-01-31 13:16:19311 enums3);
Max Boguefef332d2016-07-28 22:09:09312}
313
314TEST_F(EnumSetTest, Intersection) {
Fergal Daly74a98992021-07-05 03:54:41315 const TestEnumSet enums1(TestEnum::TEST_4, TestEnum::TEST_5);
316 const TestEnumSet enums2(TestEnum::TEST_3, TestEnum::TEST_4);
Max Boguefef332d2016-07-28 22:09:09317 const TestEnumSet enums3 = Intersection(enums1, enums2);
318
Fergal Daly74a98992021-07-05 03:54:41319 EXPECT_EQ(TestEnumSet(TestEnum::TEST_4), enums3);
Max Boguefef332d2016-07-28 22:09:09320}
321
322TEST_F(EnumSetTest, Difference) {
Fergal Daly74a98992021-07-05 03:54:41323 const TestEnumSet enums1(TestEnum::TEST_4, TestEnum::TEST_5);
324 const TestEnumSet enums2(TestEnum::TEST_3, TestEnum::TEST_4);
Max Boguefef332d2016-07-28 22:09:09325 const TestEnumSet enums3 = Difference(enums1, enums2);
326
Fergal Daly74a98992021-07-05 03:54:41327 EXPECT_EQ(TestEnumSet(TestEnum::TEST_5), enums3);
328}
329
330TEST_F(EnumSetTest, ToFromEnumBitmask) {
331 const TestEnumSet empty;
332 EXPECT_EQ(empty.ToEnumBitmask(), 0ULL);
333 EXPECT_EQ(TestEnumSet::FromEnumBitmask(0), empty);
334
335 const TestEnumSet enums1(TestEnum::TEST_2);
336 const uint64_t val1 = 1ULL << static_cast<uint64_t>(TestEnum::TEST_2);
337 EXPECT_EQ(enums1.ToEnumBitmask(), val1);
338 EXPECT_EQ(TestEnumSet::FromEnumBitmask(val1), enums1);
339
340 const TestEnumSet enums2(TestEnum::TEST_3, TestEnum::TEST_4);
341 const uint64_t val2 = 1ULL << static_cast<uint64_t>(TestEnum::TEST_3) |
342 1ULL << static_cast<uint64_t>(TestEnum::TEST_4);
343 EXPECT_EQ(enums2.ToEnumBitmask(), val2);
344 EXPECT_EQ(TestEnumSet::FromEnumBitmask(val2), enums2);
345}
346
347TEST_F(EnumSetTest, ToFromEnumBitmaskExtreme) {
348 const TestEnumExtremeSet empty;
349 EXPECT_EQ(empty.ToEnumBitmask(), 0ULL);
350 EXPECT_EQ(TestEnumExtremeSet::FromEnumBitmask(0ULL), empty);
351
352 const TestEnumExtremeSet enums1(TestEnumExtreme::TEST_63);
353 const uint64_t val1 = 1ULL << static_cast<uint64_t>(TestEnumExtreme::TEST_63);
354 EXPECT_EQ(enums1.ToEnumBitmask(), val1);
355 EXPECT_EQ(TestEnumExtremeSet::FromEnumBitmask(val1), enums1);
Max Boguefef332d2016-07-28 22:09:09356}
357
Dan McArdlee6914572021-12-15 19:10:01358TEST_F(EnumSetTest, FromEnumBitmaskIgnoresExtraBits) {
359 const TestEnumSet kSets[] = {
360 TestEnumSet(),
361 TestEnumSet(TestEnum::TEST_MIN),
362 TestEnumSet(TestEnum::TEST_MAX),
363 TestEnumSet(TestEnum::TEST_MIN, TestEnum::TEST_MAX),
364 TestEnumSet(TestEnum::TEST_MIN, TestEnum::TEST_MAX),
365 TestEnumSet(TestEnum::TEST_2, TestEnum::TEST_4),
366 };
367 size_t i = 0;
368 for (const TestEnumSet& set : kSets) {
369 SCOPED_TRACE(i++);
370 const uint64_t val = set.ToEnumBitmask();
371
372 // Produce a bitstring for a single enum value. When `e` is in range
373 // relative to TestEnumSet, this function behaves identically to
374 // `single_val_bitstring`. When `e` is not in range, this function attempts
375 // to compute a value, while `single_val_bitstring` intentionally crashes.
376 auto single_val_bitstring = [](TestEnum e) -> uint64_t {
377 uint64_t shift_amount = static_cast<uint64_t>(e);
378 // Shifting left more than the number of bits in the lhs would be UB.
379 CHECK_LT(shift_amount, sizeof(uint64_t) * 8);
380 return 1ULL << shift_amount;
381 };
382
383 const uint64_t kJunkVals[] = {
384 // Add junk bits above TEST_MAX.
385 val | single_val_bitstring(TestEnum::TEST_6_OUT_OF_BOUNDS),
386 val | single_val_bitstring(TestEnum::TEST_7_OUT_OF_BOUNDS),
387 val | single_val_bitstring(TestEnum::TEST_6_OUT_OF_BOUNDS) |
388 single_val_bitstring(TestEnum::TEST_7_OUT_OF_BOUNDS),
389 // Add junk bits below TEST_MIN.
390 val | single_val_bitstring(TestEnum::TEST_BELOW_MIN),
391 };
392 for (uint64_t junk_val : kJunkVals) {
393 SCOPED_TRACE(junk_val);
394 ASSERT_NE(val, junk_val);
395
396 const TestEnumSet set_from_junk = TestEnumSet::FromEnumBitmask(junk_val);
397 EXPECT_EQ(set_from_junk, set);
398 EXPECT_EQ(set_from_junk.ToEnumBitmask(), set.ToEnumBitmask());
399
400 // Iterating both sets should produce the same sequence.
401 auto it1 = set.begin();
402 auto it2 = set_from_junk.begin();
403 while (it1 != set.end() && it2 != set_from_junk.end()) {
404 EXPECT_EQ(*it1, *it2);
405 ++it1;
406 ++it2;
407 }
408 EXPECT_TRUE(it1 == set.end());
409 EXPECT_TRUE(it2 == set_from_junk.end());
410 }
411 }
412}
413
414TEST_F(EnumSetDeathTest, SingleValBitstringCrashesOnOutOfRange) {
415 EXPECT_CHECK_DEATH(
416 TestEnumSet::single_val_bitstring(TestEnum::TEST_BELOW_MIN));
417 EXPECT_CHECK_DEATH(
418 TestEnumSet::single_val_bitstring(TestEnum::TEST_6_OUT_OF_BOUNDS));
419 EXPECT_CHECK_DEATH(
420 TestEnumSet::single_val_bitstring(TestEnum::TEST_7_OUT_OF_BOUNDS));
421}
422
Dan McArdle0fdeeb772021-12-22 21:41:03423TEST_F(EnumSetTest, SparseEnum) {
424 enum class TestEnumSparse {
425 TEST_1 = 1,
426 TEST_MIN = 1,
427 TEST_50 = 50,
428 TEST_100 = 100,
429 TEST_MAX = TEST_100,
430 };
431 using TestEnumSparseSet = EnumSet<TestEnumSparse, TestEnumSparse::TEST_MIN,
432 TestEnumSparse::TEST_MAX>;
433 TestEnumSparseSet sparse;
434 sparse.Put(TestEnumSparse::TEST_MIN);
435 sparse.Put(TestEnumSparse::TEST_MAX);
436 EXPECT_EQ(sparse.Size(), 2u);
437
438 // TestEnumSparseSet::All() does not compile because there are more than 64
439 // possible values. See NCTEST_ALL_METHOD_DISALLOWED_ON_LARGE_SPARSE_ENUM in
440 // enum_set_unittest.nc.
441}
442
443TEST_F(EnumSetTest, SparseEnumSmall) {
444 enum class TestEnumSparse {
445 TEST_1 = 1,
446 TEST_MIN = 1,
447 TEST_50 = 50,
448 TEST_60 = 60,
449 TEST_MAX = TEST_60,
450 };
451 using TestEnumSparseSet = EnumSet<TestEnumSparse, TestEnumSparse::TEST_MIN,
452 TestEnumSparse::TEST_MAX>;
453 TestEnumSparseSet sparse;
454 sparse.Put(TestEnumSparse::TEST_MIN);
455 sparse.Put(TestEnumSparse::TEST_MAX);
456 EXPECT_EQ(sparse.Size(), 2u);
457
458 // This may seem a little surprising! There are only 3 distinct values in
459 // TestEnumSparse, so why does TestEnumSparseSet think it has 60 of them? This
460 // is an artifact of EnumSet's design, as it has no way of knowing which
461 // values between the min and max are actually named in the enum's definition.
462 EXPECT_EQ(TestEnumSparseSet::All().Size(), 60u);
463}
464
465TEST_F(EnumSetTest, SingleValBitstringCrashesOnOutOfRange) {
466 EXPECT_CHECK_DEATH(
467 TestEnumSet::single_val_bitstring(TestEnum::TEST_BELOW_MIN));
468 EXPECT_CHECK_DEATH(
469 TestEnumSet::single_val_bitstring(TestEnum::TEST_6_OUT_OF_BOUNDS));
470 EXPECT_CHECK_DEATH(
471 TestEnumSet::single_val_bitstring(TestEnum::TEST_7_OUT_OF_BOUNDS));
472}
473
Dan McArdlee6914572021-12-15 19:10:01474TEST_F(EnumSetDeathTest, SingleValBitstringEnumWithNegatives) {
475 enum class TestEnumNeg {
476 TEST_BELOW_MIN = -3,
477 TEST_A = -2,
478 TEST_MIN = TEST_A,
479 TEST_B = -1,
480 TEST_C = 0,
481 TEST_D = 1,
482 TEST_E = 2,
483 TEST_MAX = TEST_E,
484 TEST_F = 3,
485 };
486 // This EnumSet starts negative and ends positive.
487 using TestEnumWithNegSet =
488 EnumSet<TestEnumNeg, TestEnumNeg::TEST_MIN, TestEnumNeg::TEST_MAX>;
489
490 // Should crash because TEST_BELOW_MIN is not in range.
491 EXPECT_CHECK_DEATH(
492 TestEnumWithNegSet::single_val_bitstring(TestEnumNeg::TEST_BELOW_MIN));
493 // TEST_D is in range, but note that TEST_MIN is negative. This should work.
494 EXPECT_EQ(TestEnumWithNegSet::single_val_bitstring(TestEnumNeg::TEST_D),
495 1u << 3);
496 // Even though TEST_A is negative, it is in range, so this should work.
497 EXPECT_EQ(TestEnumWithNegSet::single_val_bitstring(TestEnumNeg::TEST_A),
498 1u << 0);
499}
500
501TEST_F(EnumSetDeathTest, SingleValBitstringEnumWithOnlyNegatives) {
502 enum class TestEnumNeg {
503 TEST_BELOW_MIN = -10,
504 TEST_A = -9,
505 TEST_MIN = TEST_A,
506 TEST_B = -8,
507 TEST_C = -7,
508 TEST_D = -6,
509 TEST_MAX = TEST_D,
510 TEST_F = -5,
511 };
512 // This EnumSet starts negative and ends negative.
513 using TestEnumWithNegSet =
514 EnumSet<TestEnumNeg, TestEnumNeg::TEST_MIN, TestEnumNeg::TEST_MAX>;
515
516 // Should crash because TEST_BELOW_MIN is not in range.
517 EXPECT_CHECK_DEATH(
518 TestEnumWithNegSet::single_val_bitstring(TestEnumNeg::TEST_BELOW_MIN));
519 // TEST_D is in range, but note that TEST_MIN is negative. This should work.
520 EXPECT_EQ(TestEnumWithNegSet::single_val_bitstring(TestEnumNeg::TEST_D),
521 1u << 3);
522 // Even though TEST_A is negative, it is in range, so this should work.
523 EXPECT_EQ(TestEnumWithNegSet::single_val_bitstring(TestEnumNeg::TEST_A),
524 1u << 0);
525}
526
527TEST_F(EnumSetDeathTest, VariadicConstructorCrashesOnOutOfRange) {
528 // Constructor should crash given out-of-range values.
529 EXPECT_CHECK_DEATH(TestEnumSet(TestEnum::TEST_BELOW_MIN).Empty());
530 EXPECT_CHECK_DEATH(TestEnumSet(TestEnum::TEST_BELOW_MIN_NEGATIVE).Empty());
531 EXPECT_CHECK_DEATH(TestEnumSet(TestEnum::TEST_6_OUT_OF_BOUNDS).Empty());
532}
533
534TEST_F(EnumSetDeathTest, FromRangeCrashesOnBadInputs) {
535 // FromRange crashes when the bounds are in range, but out of order.
536 EXPECT_CHECK_DEATH(
537 TestEnumSet().FromRange(TestEnum::TEST_3, TestEnum::TEST_1));
538
539 // FromRange crashes when the start value is out of range.
540 EXPECT_CHECK_DEATH(
541 TestEnumSet().FromRange(TestEnum::TEST_BELOW_MIN, TestEnum::TEST_1));
542 EXPECT_CHECK_DEATH(TestEnumSet().FromRange(TestEnum::TEST_BELOW_MIN_NEGATIVE,
543 TestEnum::TEST_1));
544 EXPECT_CHECK_DEATH(TestEnumSet().FromRange(TestEnum::TEST_6_OUT_OF_BOUNDS,
545 TestEnum::TEST_1));
546
547 // FromRange crashes when the end value is out of range.
548 EXPECT_CHECK_DEATH(
549 TestEnumSet().FromRange(TestEnum::TEST_3, TestEnum::TEST_BELOW_MIN));
550 EXPECT_CHECK_DEATH(TestEnumSet().FromRange(
551 TestEnum::TEST_3, TestEnum::TEST_BELOW_MIN_NEGATIVE));
552 EXPECT_CHECK_DEATH(TestEnumSet().FromRange(TestEnum::TEST_3,
553 TestEnum::TEST_6_OUT_OF_BOUNDS));
554
555 // Crashes when start and end are both out of range.
556 EXPECT_CHECK_DEATH(TestEnumSet().FromRange(TestEnum::TEST_7_OUT_OF_BOUNDS,
557 TestEnum::TEST_6_OUT_OF_BOUNDS));
558 EXPECT_CHECK_DEATH(TestEnumSet().FromRange(TestEnum::TEST_6_OUT_OF_BOUNDS,
559 TestEnum::TEST_7_OUT_OF_BOUNDS));
560}
561
562TEST_F(EnumSetDeathTest, PutCrashesOnOutOfRange) {
563 EXPECT_CHECK_DEATH(TestEnumSet().Put(TestEnum::TEST_BELOW_MIN));
564 EXPECT_CHECK_DEATH(TestEnumSet().Put(TestEnum::TEST_BELOW_MIN_NEGATIVE));
565 EXPECT_CHECK_DEATH(TestEnumSet().Put(TestEnum::TEST_6_OUT_OF_BOUNDS));
566 EXPECT_CHECK_DEATH(TestEnumSet().Put(TestEnum::TEST_7_OUT_OF_BOUNDS));
567}
568
569TEST_F(EnumSetDeathTest, PutRangeCrashesOnBadInputs) {
570 // Crashes when one input is out of range.
571 EXPECT_CHECK_DEATH(TestEnumSet().PutRange(TestEnum::TEST_BELOW_MIN_NEGATIVE,
572 TestEnum::TEST_BELOW_MIN));
573 EXPECT_CHECK_DEATH(
574 TestEnumSet().PutRange(TestEnum::TEST_3, TestEnum::TEST_7_OUT_OF_BOUNDS));
575
576 // Crashes when both inputs are out of range.
577 EXPECT_CHECK_DEATH(TestEnumSet().PutRange(TestEnum::TEST_6_OUT_OF_BOUNDS,
578 TestEnum::TEST_7_OUT_OF_BOUNDS));
579
580 // Crashes when inputs are out of order.
581 EXPECT_CHECK_DEATH(
582 TestEnumSet().PutRange(TestEnum::TEST_2, TestEnum::TEST_1));
583}
584
Max Boguefef332d2016-07-28 22:09:09585} // namespace
Fergal Dalydd4e8c52021-07-05 03:19:05586} // namespace base