Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 1 | // 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. Wong | d1bfdb02 | 2021-08-11 17:52:48 | [diff] [blame] | 5 | #include "base/containers/enum_set.h" |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 6 | |
| 7 | #include <stddef.h> |
| 8 | |
Dan McArdle | e691457 | 2021-12-15 19:10:01 | [diff] [blame] | 9 | #include "base/test/gtest_util.h" |
| 10 | #include "testing/gtest/include/gtest/gtest-death-test.h" |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 11 | #include "testing/gtest/include/gtest/gtest.h" |
| 12 | |
Fergal Daly | dd4e8c5 | 2021-07-05 03:19:05 | [diff] [blame] | 13 | namespace base { |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 14 | namespace { |
| 15 | |
Maksim Moskvitin | cfdd128 | 2019-01-31 13:16:19 | [diff] [blame] | 16 | enum class TestEnum { |
Dan McArdle | e691457 | 2021-12-15 19:10:01 | [diff] [blame] | 17 | TEST_BELOW_MIN_NEGATIVE = -1, |
| 18 | TEST_BELOW_MIN = 0, |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 19 | TEST_1 = 1, |
| 20 | TEST_MIN = TEST_1, |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 21 | TEST_2, |
| 22 | TEST_3, |
| 23 | TEST_4, |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 24 | TEST_5, |
| 25 | TEST_MAX = TEST_5, |
Dan McArdle | e691457 | 2021-12-15 19:10:01 | [diff] [blame] | 26 | TEST_6_OUT_OF_BOUNDS, |
| 27 | TEST_7_OUT_OF_BOUNDS |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 28 | }; |
Maksim Moskvitin | cfdd128 | 2019-01-31 13:16:19 | [diff] [blame] | 29 | using TestEnumSet = EnumSet<TestEnum, TestEnum::TEST_MIN, TestEnum::TEST_MAX>; |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 30 | |
Fergal Daly | 16e30f01 | 2021-07-05 03:45:59 | [diff] [blame] | 31 | enum 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 | }; |
| 38 | using TestEnumExtremeSet = EnumSet<TestEnumExtreme, |
| 39 | TestEnumExtreme::TEST_MIN, |
| 40 | TestEnumExtreme::TEST_MAX>; |
| 41 | |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 42 | class EnumSetTest : public ::testing::Test {}; |
Dan McArdle | e691457 | 2021-12-15 19:10:01 | [diff] [blame] | 43 | class EnumSetDeathTest : public ::testing::Test {}; |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 44 | |
| 45 | TEST_F(EnumSetTest, ClassConstants) { |
Maksim Moskvitin | cfdd128 | 2019-01-31 13:16:19 | [diff] [blame] | 46 | EXPECT_EQ(TestEnum::TEST_MIN, TestEnumSet::kMinValue); |
| 47 | EXPECT_EQ(TestEnum::TEST_MAX, TestEnumSet::kMaxValue); |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 48 | EXPECT_EQ(static_cast<size_t>(5), TestEnumSet::kValueCount); |
| 49 | } |
| 50 | |
pnoland | 4d8a7c1 | 2017-06-13 00:52:09 | [diff] [blame] | 51 | // Use static_assert to check that functions we expect to be compile time |
| 52 | // evaluatable are really that way. |
| 53 | TEST_F(EnumSetTest, ConstexprsAreValid) { |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 54 | static_assert(TestEnumSet::All().Has(TestEnum::TEST_2), |
Dan McArdle | e691457 | 2021-12-15 19:10:01 | [diff] [blame] | 55 | "Expected All() to be integral constant expression"); |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 56 | static_assert(TestEnumSet::FromRange(TestEnum::TEST_2, TestEnum::TEST_4) |
| 57 | .Has(TestEnum::TEST_2), |
Dan McArdle | e691457 | 2021-12-15 19:10:01 | [diff] [blame] | 58 | "Expected FromRange() to be integral constant expression"); |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 59 | static_assert(TestEnumSet(TestEnum::TEST_2).Has(TestEnum::TEST_2), |
Dan McArdle | e691457 | 2021-12-15 19:10:01 | [diff] [blame] | 60 | "Expected TestEnumSet() to be integral constant expression"); |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 61 | 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 McArdle | e691457 | 2021-12-15 19:10:01 | [diff] [blame] | 65 | 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"); |
pnoland | 4d8a7c1 | 2017-06-13 00:52:09 | [diff] [blame] | 70 | } |
| 71 | |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 72 | TEST_F(EnumSetTest, DefaultConstructor) { |
| 73 | const TestEnumSet enums; |
| 74 | EXPECT_TRUE(enums.Empty()); |
| 75 | EXPECT_EQ(static_cast<size_t>(0), enums.Size()); |
Maksim Moskvitin | cfdd128 | 2019-01-31 13:16:19 | [diff] [blame] | 76 | 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 Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 80 | EXPECT_FALSE(enums.Has(TestEnum::TEST_5)); |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 81 | } |
| 82 | |
| 83 | TEST_F(EnumSetTest, OneArgConstructor) { |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 84 | const TestEnumSet enums(TestEnum::TEST_4); |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 85 | EXPECT_FALSE(enums.Empty()); |
| 86 | EXPECT_EQ(static_cast<size_t>(1), enums.Size()); |
Maksim Moskvitin | cfdd128 | 2019-01-31 13:16:19 | [diff] [blame] | 87 | EXPECT_FALSE(enums.Has(TestEnum::TEST_1)); |
| 88 | EXPECT_FALSE(enums.Has(TestEnum::TEST_2)); |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 89 | EXPECT_FALSE(enums.Has(TestEnum::TEST_3)); |
| 90 | EXPECT_TRUE(enums.Has(TestEnum::TEST_4)); |
| 91 | EXPECT_FALSE(enums.Has(TestEnum::TEST_5)); |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 92 | } |
| 93 | |
Fergal Daly | 16e30f01 | 2021-07-05 03:45:59 | [diff] [blame] | 94 | TEST_F(EnumSetTest, OneArgConstructorSize) { |
| 95 | TestEnumExtremeSet enums(TestEnumExtreme::TEST_0); |
| 96 | EXPECT_TRUE(enums.Has(TestEnumExtreme::TEST_0)); |
| 97 | } |
| 98 | |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 99 | TEST_F(EnumSetTest, TwoArgConstructor) { |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 100 | const TestEnumSet enums(TestEnum::TEST_4, TestEnum::TEST_2); |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 101 | EXPECT_FALSE(enums.Empty()); |
| 102 | EXPECT_EQ(static_cast<size_t>(2), enums.Size()); |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 103 | 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 Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 108 | } |
| 109 | |
| 110 | TEST_F(EnumSetTest, ThreeArgConstructor) { |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 111 | const TestEnumSet enums(TestEnum::TEST_4, TestEnum::TEST_2, TestEnum::TEST_1); |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 112 | EXPECT_FALSE(enums.Empty()); |
| 113 | EXPECT_EQ(static_cast<size_t>(3), enums.Size()); |
Maksim Moskvitin | cfdd128 | 2019-01-31 13:16:19 | [diff] [blame] | 114 | EXPECT_TRUE(enums.Has(TestEnum::TEST_1)); |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 115 | 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 Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 119 | } |
| 120 | |
skym | e8c9196 | 2017-02-28 16:31:15 | [diff] [blame] | 121 | TEST_F(EnumSetTest, DuplicatesInConstructor) { |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 122 | 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)); |
skym | e8c9196 | 2017-02-28 16:31:15 | [diff] [blame] | 125 | } |
| 126 | |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 127 | TEST_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 Moskvitin | cfdd128 | 2019-01-31 13:16:19 | [diff] [blame] | 131 | 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 Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 135 | EXPECT_TRUE(enums.Has(TestEnum::TEST_5)); |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 136 | } |
| 137 | |
skym | e8c9196 | 2017-02-28 16:31:15 | [diff] [blame] | 138 | TEST_F(EnumSetTest, FromRange) { |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 139 | EXPECT_EQ(TestEnumSet(TestEnum::TEST_2, TestEnum::TEST_3, TestEnum::TEST_4), |
| 140 | TestEnumSet::FromRange(TestEnum::TEST_2, TestEnum::TEST_4)); |
Maksim Moskvitin | cfdd128 | 2019-01-31 13:16:19 | [diff] [blame] | 141 | EXPECT_EQ(TestEnumSet::All(), |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 142 | TestEnumSet::FromRange(TestEnum::TEST_1, TestEnum::TEST_5)); |
| 143 | EXPECT_EQ(TestEnumSet(TestEnum::TEST_2), |
| 144 | TestEnumSet::FromRange(TestEnum::TEST_2, TestEnum::TEST_2)); |
pnoland | 4d8a7c1 | 2017-06-13 00:52:09 | [diff] [blame] | 145 | |
Maksim Moskvitin | cfdd128 | 2019-01-31 13:16:19 | [diff] [blame] | 146 | using RestrictedRangeSet = |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 147 | EnumSet<TestEnum, TestEnum::TEST_2, TestEnum::TEST_MAX>; |
Maksim Moskvitin | cfdd128 | 2019-01-31 13:16:19 | [diff] [blame] | 148 | EXPECT_EQ( |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 149 | RestrictedRangeSet(TestEnum::TEST_2, TestEnum::TEST_3, TestEnum::TEST_4), |
| 150 | RestrictedRangeSet::FromRange(TestEnum::TEST_2, TestEnum::TEST_4)); |
pnoland | 4d8a7c1 | 2017-06-13 00:52:09 | [diff] [blame] | 151 | EXPECT_EQ(RestrictedRangeSet::All(), |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 152 | RestrictedRangeSet::FromRange(TestEnum::TEST_2, TestEnum::TEST_5)); |
skym | e8c9196 | 2017-02-28 16:31:15 | [diff] [blame] | 153 | } |
| 154 | |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 155 | TEST_F(EnumSetTest, Put) { |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 156 | 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 Moskvitin | cfdd128 | 2019-01-31 13:16:19 | [diff] [blame] | 161 | enums); |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 162 | } |
| 163 | |
| 164 | TEST_F(EnumSetTest, PutAll) { |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 165 | 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 Moskvitin | cfdd128 | 2019-01-31 13:16:19 | [diff] [blame] | 168 | enums); |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 169 | } |
| 170 | |
skym | e8c9196 | 2017-02-28 16:31:15 | [diff] [blame] | 171 | TEST_F(EnumSetTest, PutRange) { |
| 172 | TestEnumSet enums; |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 173 | enums.PutRange(TestEnum::TEST_2, TestEnum::TEST_4); |
| 174 | EXPECT_EQ(TestEnumSet(TestEnum::TEST_2, TestEnum::TEST_3, TestEnum::TEST_4), |
Maksim Moskvitin | cfdd128 | 2019-01-31 13:16:19 | [diff] [blame] | 175 | enums); |
skym | e8c9196 | 2017-02-28 16:31:15 | [diff] [blame] | 176 | } |
| 177 | |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 178 | TEST_F(EnumSetTest, RetainAll) { |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 179 | 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 Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 182 | } |
| 183 | |
| 184 | TEST_F(EnumSetTest, Remove) { |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 185 | TestEnumSet enums(TestEnum::TEST_4, TestEnum::TEST_5); |
| 186 | enums.Remove(TestEnum::TEST_1); |
Maksim Moskvitin | cfdd128 | 2019-01-31 13:16:19 | [diff] [blame] | 187 | enums.Remove(TestEnum::TEST_3); |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 188 | EXPECT_EQ(TestEnumSet(TestEnum::TEST_4, TestEnum::TEST_5), enums); |
Maksim Moskvitin | cfdd128 | 2019-01-31 13:16:19 | [diff] [blame] | 189 | enums.Remove(TestEnum::TEST_4); |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 190 | EXPECT_EQ(TestEnumSet(TestEnum::TEST_5), enums); |
Maksim Moskvitin | cfdd128 | 2019-01-31 13:16:19 | [diff] [blame] | 191 | enums.Remove(TestEnum::TEST_5); |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 192 | enums.Remove(TestEnum::TEST_6_OUT_OF_BOUNDS); |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 193 | EXPECT_TRUE(enums.Empty()); |
| 194 | } |
| 195 | |
| 196 | TEST_F(EnumSetTest, RemoveAll) { |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 197 | 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 Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 200 | } |
| 201 | |
| 202 | TEST_F(EnumSetTest, Clear) { |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 203 | TestEnumSet enums(TestEnum::TEST_4, TestEnum::TEST_5); |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 204 | enums.Clear(); |
| 205 | EXPECT_TRUE(enums.Empty()); |
| 206 | } |
| 207 | |
| 208 | TEST_F(EnumSetTest, Has) { |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 209 | const TestEnumSet enums(TestEnum::TEST_4, TestEnum::TEST_5); |
Maksim Moskvitin | cfdd128 | 2019-01-31 13:16:19 | [diff] [blame] | 210 | EXPECT_FALSE(enums.Has(TestEnum::TEST_1)); |
| 211 | EXPECT_FALSE(enums.Has(TestEnum::TEST_2)); |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 212 | EXPECT_FALSE(enums.Has(TestEnum::TEST_3)); |
Maksim Moskvitin | cfdd128 | 2019-01-31 13:16:19 | [diff] [blame] | 213 | EXPECT_TRUE(enums.Has(TestEnum::TEST_4)); |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 214 | EXPECT_TRUE(enums.Has(TestEnum::TEST_5)); |
| 215 | EXPECT_FALSE(enums.Has(TestEnum::TEST_6_OUT_OF_BOUNDS)); |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 216 | } |
| 217 | |
| 218 | TEST_F(EnumSetTest, HasAll) { |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 219 | const TestEnumSet enums1(TestEnum::TEST_4, TestEnum::TEST_5); |
| 220 | const TestEnumSet enums2(TestEnum::TEST_3, TestEnum::TEST_4); |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 221 | 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 | |
| 235 | TEST_F(EnumSetTest, Iterators) { |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 236 | const TestEnumSet enums1(TestEnum::TEST_4, TestEnum::TEST_5); |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 237 | TestEnumSet enums2; |
David Davidović | 64a6592 | 2018-08-17 10:54:16 | [diff] [blame] | 238 | for (TestEnumSet::Iterator it = enums1.begin(); it != enums1.end(); it++) { |
| 239 | enums2.Put(*it); |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 240 | } |
| 241 | EXPECT_EQ(enums2, enums1); |
| 242 | } |
| 243 | |
David Davidović | 75f9b72 | 2018-08-16 19:16:11 | [diff] [blame] | 244 | TEST_F(EnumSetTest, RangeBasedForLoop) { |
Dan McArdle | e691457 | 2021-12-15 19:10:01 | [diff] [blame] | 245 | const TestEnumSet enums1(TestEnum::TEST_2, TestEnum::TEST_5); |
David Davidović | 75f9b72 | 2018-08-16 19:16:11 | [diff] [blame] | 246 | TestEnumSet enums2; |
| 247 | for (TestEnum e : enums1) { |
| 248 | enums2.Put(e); |
| 249 | } |
| 250 | EXPECT_EQ(enums2, enums1); |
| 251 | } |
| 252 | |
| 253 | TEST_F(EnumSetTest, IteratorComparisonOperators) { |
Dan McArdle | e691457 | 2021-12-15 19:10:01 | [diff] [blame] | 254 | const TestEnumSet enums(TestEnum::TEST_2, TestEnum::TEST_4); |
David Davidović | 75f9b72 | 2018-08-16 19:16:11 | [diff] [blame] | 255 | 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 | |
| 274 | TEST_F(EnumSetTest, IteratorIncrementOperators) { |
Dan McArdle | e691457 | 2021-12-15 19:10:01 | [diff] [blame] | 275 | const TestEnumSet enums(TestEnum::TEST_2, TestEnum::TEST_4); |
David Davidović | 75f9b72 | 2018-08-16 19:16:11 | [diff] [blame] | 276 | 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 Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 305 | TEST_F(EnumSetTest, Union) { |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 306 | const TestEnumSet enums1(TestEnum::TEST_4, TestEnum::TEST_5); |
| 307 | const TestEnumSet enums2(TestEnum::TEST_3, TestEnum::TEST_4); |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 308 | const TestEnumSet enums3 = Union(enums1, enums2); |
| 309 | |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 310 | EXPECT_EQ(TestEnumSet(TestEnum::TEST_3, TestEnum::TEST_4, TestEnum::TEST_5), |
Maksim Moskvitin | cfdd128 | 2019-01-31 13:16:19 | [diff] [blame] | 311 | enums3); |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 312 | } |
| 313 | |
| 314 | TEST_F(EnumSetTest, Intersection) { |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 315 | const TestEnumSet enums1(TestEnum::TEST_4, TestEnum::TEST_5); |
| 316 | const TestEnumSet enums2(TestEnum::TEST_3, TestEnum::TEST_4); |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 317 | const TestEnumSet enums3 = Intersection(enums1, enums2); |
| 318 | |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 319 | EXPECT_EQ(TestEnumSet(TestEnum::TEST_4), enums3); |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 320 | } |
| 321 | |
| 322 | TEST_F(EnumSetTest, Difference) { |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 323 | const TestEnumSet enums1(TestEnum::TEST_4, TestEnum::TEST_5); |
| 324 | const TestEnumSet enums2(TestEnum::TEST_3, TestEnum::TEST_4); |
Max Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 325 | const TestEnumSet enums3 = Difference(enums1, enums2); |
| 326 | |
Fergal Daly | 74a9899 | 2021-07-05 03:54:41 | [diff] [blame] | 327 | EXPECT_EQ(TestEnumSet(TestEnum::TEST_5), enums3); |
| 328 | } |
| 329 | |
| 330 | TEST_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 | |
| 347 | TEST_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 Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 356 | } |
| 357 | |
Dan McArdle | e691457 | 2021-12-15 19:10:01 | [diff] [blame] | 358 | TEST_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 | |
| 414 | TEST_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 McArdle | 0fdeeb77 | 2021-12-22 21:41:03 | [diff] [blame] | 423 | TEST_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 | |
| 443 | TEST_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 | |
| 465 | TEST_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 McArdle | e691457 | 2021-12-15 19:10:01 | [diff] [blame] | 474 | TEST_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 | |
| 501 | TEST_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 | |
| 527 | TEST_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 | |
| 534 | TEST_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 | |
| 562 | TEST_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 | |
| 569 | TEST_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 Bogue | fef332d | 2016-07-28 22:09:09 | [diff] [blame] | 585 | } // namespace |
Fergal Daly | dd4e8c5 | 2021-07-05 03:19:05 | [diff] [blame] | 586 | } // namespace base |