1 // Copyright 2017 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 // Unit tests for the variant template. The 'is' and 'IsEmpty' methods
16 // of variant are not explicitly tested because they are used repeatedly
17 // in building other tests. All other public variant methods should have
18 // explicit tests.
19
20 #include "absl/types/variant.h"
21
22 // This test is a no-op when absl::variant is an alias for std::variant.
23 #if !defined(ABSL_USES_STD_VARIANT)
24
25 #include <algorithm>
26 #include <cstddef>
27 #include <functional>
28 #include <initializer_list>
29 #include <memory>
30 #include <ostream>
31 #include <queue>
32 #include <type_traits>
33 #include <unordered_set>
34 #include <utility>
35 #include <vector>
36
37 #include "gmock/gmock.h"
38 #include "gtest/gtest.h"
39 #include "absl/base/config.h"
40 #include "absl/base/port.h"
41 #include "absl/memory/memory.h"
42 #include "absl/meta/type_traits.h"
43 #include "absl/strings/string_view.h"
44
45 #ifdef ABSL_HAVE_EXCEPTIONS
46
47 #define ABSL_VARIANT_TEST_EXPECT_FAIL(expr, exception_t, text) \
48 EXPECT_THROW(expr, exception_t)
49
50 #else
51
52 #define ABSL_VARIANT_TEST_EXPECT_FAIL(expr, exception_t, text) \
53 EXPECT_DEATH_IF_SUPPORTED(expr, text)
54
55 #endif // ABSL_HAVE_EXCEPTIONS
56
57 #define ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(...) \
58 ABSL_VARIANT_TEST_EXPECT_FAIL((void)(__VA_ARGS__), absl::bad_variant_access, \
59 "Bad variant access")
60
61 struct Hashable {};
62
63 namespace std {
64 template <>
65 struct hash<Hashable> {
66 size_t operator()(const Hashable&);
67 };
68 } // namespace std
69
70 struct NonHashable {};
71
72 namespace absl {
73 ABSL_NAMESPACE_BEGIN
74 namespace {
75
76 using ::testing::DoubleEq;
77 using ::testing::Pointee;
78 using ::testing::VariantWith;
79
80 struct MoveCanThrow {
MoveCanThrowabsl::__anon997132050111::MoveCanThrow81 MoveCanThrow() : v(0) {}
MoveCanThrowabsl::__anon997132050111::MoveCanThrow82 MoveCanThrow(int v) : v(v) {} // NOLINT(runtime/explicit)
MoveCanThrowabsl::__anon997132050111::MoveCanThrow83 MoveCanThrow(const MoveCanThrow& other) : v(other.v) {}
operator =absl::__anon997132050111::MoveCanThrow84 MoveCanThrow& operator=(const MoveCanThrow& /*other*/) { return *this; }
85 int v;
86 };
87
operator ==(MoveCanThrow lhs,MoveCanThrow rhs)88 bool operator==(MoveCanThrow lhs, MoveCanThrow rhs) { return lhs.v == rhs.v; }
operator !=(MoveCanThrow lhs,MoveCanThrow rhs)89 bool operator!=(MoveCanThrow lhs, MoveCanThrow rhs) { return lhs.v != rhs.v; }
operator <(MoveCanThrow lhs,MoveCanThrow rhs)90 bool operator<(MoveCanThrow lhs, MoveCanThrow rhs) { return lhs.v < rhs.v; }
operator <=(MoveCanThrow lhs,MoveCanThrow rhs)91 bool operator<=(MoveCanThrow lhs, MoveCanThrow rhs) { return lhs.v <= rhs.v; }
operator >=(MoveCanThrow lhs,MoveCanThrow rhs)92 bool operator>=(MoveCanThrow lhs, MoveCanThrow rhs) { return lhs.v >= rhs.v; }
operator >(MoveCanThrow lhs,MoveCanThrow rhs)93 bool operator>(MoveCanThrow lhs, MoveCanThrow rhs) { return lhs.v > rhs.v; }
94
95 // This helper class allows us to determine if it was swapped with std::swap()
96 // or with its friend swap() function.
97 struct SpecialSwap {
SpecialSwapabsl::__anon997132050111::SpecialSwap98 explicit SpecialSwap(int i) : i(i) {}
swap(SpecialSwap & a,SpecialSwap & b)99 friend void swap(SpecialSwap& a, SpecialSwap& b) {
100 a.special_swap = b.special_swap = true;
101 std::swap(a.i, b.i);
102 }
operator ==absl::__anon997132050111::SpecialSwap103 bool operator==(SpecialSwap other) const { return i == other.i; }
104 int i;
105 bool special_swap = false;
106 };
107
108 struct MoveOnlyWithListConstructor {
109 MoveOnlyWithListConstructor() = default;
MoveOnlyWithListConstructorabsl::__anon997132050111::MoveOnlyWithListConstructor110 explicit MoveOnlyWithListConstructor(std::initializer_list<int> /*ilist*/,
111 int value)
112 : value(value) {}
113 MoveOnlyWithListConstructor(MoveOnlyWithListConstructor&&) = default;
114 MoveOnlyWithListConstructor& operator=(MoveOnlyWithListConstructor&&) =
115 default;
116
117 int value = 0;
118 };
119
120 #ifdef ABSL_HAVE_EXCEPTIONS
121
122 struct ConversionException {};
123
124 template <class T>
125 struct ExceptionOnConversion {
operator Tabsl::__anon997132050111::ExceptionOnConversion126 operator T() const { // NOLINT(runtime/explicit)
127 throw ConversionException();
128 }
129 };
130
131 // Forces a variant into the valueless by exception state.
132 template <class H, class... T>
ToValuelessByException(absl::variant<H,T...> & v)133 void ToValuelessByException(absl::variant<H, T...>& v) { // NOLINT
134 try {
135 v.template emplace<0>(ExceptionOnConversion<H>());
136 } catch (ConversionException& /*e*/) {
137 // This space intentionally left blank.
138 }
139 }
140
141 #endif // ABSL_HAVE_EXCEPTIONS
142
143 // An indexed sequence of distinct structures holding a single
144 // value of type T
145 template<typename T, size_t N>
146 struct ValueHolder {
ValueHolderabsl::__anon997132050111::ValueHolder147 explicit ValueHolder(const T& x) : value(x) {}
148 typedef T value_type;
149 value_type value;
150 static const size_t kIndex = N;
151 };
152 template<typename T, size_t N>
153 const size_t ValueHolder<T, N>::kIndex;
154
155 // The following three functions make ValueHolder compatible with
156 // EXPECT_EQ and EXPECT_NE
157 template<typename T, size_t N>
operator ==(const ValueHolder<T,N> & left,const ValueHolder<T,N> & right)158 inline bool operator==(const ValueHolder<T, N>& left,
159 const ValueHolder<T, N>& right) {
160 return left.value == right.value;
161 }
162
163 template<typename T, size_t N>
operator !=(const ValueHolder<T,N> & left,const ValueHolder<T,N> & right)164 inline bool operator!=(const ValueHolder<T, N>& left,
165 const ValueHolder<T, N>& right) {
166 return left.value != right.value;
167 }
168
169 template<typename T, size_t N>
operator <<(std::ostream & stream,const ValueHolder<T,N> & object)170 inline std::ostream& operator<<(
171 std::ostream& stream, const ValueHolder<T, N>& object) {
172 return stream << object.value;
173 }
174
175 // Makes a variant holding twelve uniquely typed T wrappers.
176 template<typename T>
177 struct VariantFactory {
178 typedef variant<ValueHolder<T, 1>, ValueHolder<T, 2>, ValueHolder<T, 3>,
179 ValueHolder<T, 4>>
180 Type;
181 };
182
183 // A typelist in 1:1 with VariantFactory, to use type driven unit tests.
184 typedef ::testing::Types<ValueHolder<size_t, 1>, ValueHolder<size_t, 2>,
185 ValueHolder<size_t, 3>,
186 ValueHolder<size_t, 4>> VariantTypes;
187
188 // Increments the provided counter pointer in the destructor
189 struct IncrementInDtor {
IncrementInDtorabsl::__anon997132050111::IncrementInDtor190 explicit IncrementInDtor(int* counter) : counter(counter) {}
~IncrementInDtorabsl::__anon997132050111::IncrementInDtor191 ~IncrementInDtor() { *counter += 1; }
192 int* counter;
193 };
194
195 struct IncrementInDtorCopyCanThrow {
IncrementInDtorCopyCanThrowabsl::__anon997132050111::IncrementInDtorCopyCanThrow196 explicit IncrementInDtorCopyCanThrow(int* counter) : counter(counter) {}
197 IncrementInDtorCopyCanThrow(IncrementInDtorCopyCanThrow&& other) noexcept =
198 default;
IncrementInDtorCopyCanThrowabsl::__anon997132050111::IncrementInDtorCopyCanThrow199 IncrementInDtorCopyCanThrow(const IncrementInDtorCopyCanThrow& other)
200 : counter(other.counter) {}
201 IncrementInDtorCopyCanThrow& operator=(
202 IncrementInDtorCopyCanThrow&&) noexcept = default;
operator =absl::__anon997132050111::IncrementInDtorCopyCanThrow203 IncrementInDtorCopyCanThrow& operator=(
204 IncrementInDtorCopyCanThrow const& other) {
205 counter = other.counter;
206 return *this;
207 }
~IncrementInDtorCopyCanThrowabsl::__anon997132050111::IncrementInDtorCopyCanThrow208 ~IncrementInDtorCopyCanThrow() { *counter += 1; }
209 int* counter;
210 };
211
212 // This is defined so operator== for ValueHolder<IncrementInDtor> will
213 // return true if two IncrementInDtor objects increment the same
214 // counter
operator ==(const IncrementInDtor & left,const IncrementInDtor & right)215 inline bool operator==(const IncrementInDtor& left,
216 const IncrementInDtor& right) {
217 return left.counter == right.counter;
218 }
219
220 // This is defined so EXPECT_EQ can work with IncrementInDtor
operator <<(std::ostream & stream,const IncrementInDtor & object)221 inline std::ostream& operator<<(
222 std::ostream& stream, const IncrementInDtor& object) {
223 return stream << object.counter;
224 }
225
226 // A class that can be copied, but not assigned.
227 class CopyNoAssign {
228 public:
CopyNoAssign(int value)229 explicit CopyNoAssign(int value) : foo(value) {}
CopyNoAssign(const CopyNoAssign & other)230 CopyNoAssign(const CopyNoAssign& other) : foo(other.foo) {}
231 int foo;
232 private:
233 const CopyNoAssign& operator=(const CopyNoAssign&);
234 };
235
236 // A class that can neither be copied nor assigned. We provide
237 // overloads for the constructor with up to four parameters so we can
238 // test the overloads of variant::emplace.
239 class NonCopyable {
240 public:
NonCopyable()241 NonCopyable()
242 : value(0) {}
NonCopyable(int value1)243 explicit NonCopyable(int value1)
244 : value(value1) {}
245
NonCopyable(int value1,int value2)246 NonCopyable(int value1, int value2)
247 : value(value1 + value2) {}
248
NonCopyable(int value1,int value2,int value3)249 NonCopyable(int value1, int value2, int value3)
250 : value(value1 + value2 + value3) {}
251
NonCopyable(int value1,int value2,int value3,int value4)252 NonCopyable(int value1, int value2, int value3, int value4)
253 : value(value1 + value2 + value3 + value4) {}
254 NonCopyable(const NonCopyable&) = delete;
255 NonCopyable& operator=(const NonCopyable&) = delete;
256 int value;
257 };
258
259 // A typed test and typed test case over the VariantTypes typelist,
260 // from which we derive a number of tests that will execute for one of
261 // each type.
262 template <typename T>
263 class VariantTypesTest : public ::testing::Test {};
264 TYPED_TEST_SUITE(VariantTypesTest, VariantTypes);
265
266 ////////////////////
267 // [variant.ctor] //
268 ////////////////////
269
270 struct NonNoexceptDefaultConstructible {
NonNoexceptDefaultConstructibleabsl::__anon997132050111::NonNoexceptDefaultConstructible271 NonNoexceptDefaultConstructible() {}
272 int value = 5;
273 };
274
275 struct NonDefaultConstructible {
276 NonDefaultConstructible() = delete;
277 };
278
TEST(VariantTest,TestDefaultConstructor)279 TEST(VariantTest, TestDefaultConstructor) {
280 {
281 using X = variant<int>;
282 constexpr variant<int> x{};
283 ASSERT_FALSE(x.valueless_by_exception());
284 ASSERT_EQ(0, x.index());
285 EXPECT_EQ(0, absl::get<0>(x));
286 EXPECT_TRUE(std::is_nothrow_default_constructible<X>::value);
287 }
288
289 {
290 using X = variant<NonNoexceptDefaultConstructible>;
291 X x{};
292 ASSERT_FALSE(x.valueless_by_exception());
293 ASSERT_EQ(0, x.index());
294 EXPECT_EQ(5, absl::get<0>(x).value);
295 EXPECT_FALSE(std::is_nothrow_default_constructible<X>::value);
296 }
297
298 {
299 using X = variant<int, NonNoexceptDefaultConstructible>;
300 X x{};
301 ASSERT_FALSE(x.valueless_by_exception());
302 ASSERT_EQ(0, x.index());
303 EXPECT_EQ(0, absl::get<0>(x));
304 EXPECT_TRUE(std::is_nothrow_default_constructible<X>::value);
305 }
306
307 {
308 using X = variant<NonNoexceptDefaultConstructible, int>;
309 X x{};
310 ASSERT_FALSE(x.valueless_by_exception());
311 ASSERT_EQ(0, x.index());
312 EXPECT_EQ(5, absl::get<0>(x).value);
313 EXPECT_FALSE(std::is_nothrow_default_constructible<X>::value);
314 }
315 EXPECT_FALSE(
316 std::is_default_constructible<variant<NonDefaultConstructible>>::value);
317 EXPECT_FALSE((std::is_default_constructible<
318 variant<NonDefaultConstructible, int>>::value));
319 EXPECT_TRUE((std::is_default_constructible<
320 variant<int, NonDefaultConstructible>>::value));
321 }
322
323 // Test that for each slot, copy constructing a variant with that type
324 // produces a sensible object that correctly reports its type, and
325 // that copies the provided value.
TYPED_TEST(VariantTypesTest,TestCopyCtor)326 TYPED_TEST(VariantTypesTest, TestCopyCtor) {
327 typedef typename VariantFactory<typename TypeParam::value_type>::Type Variant;
328 using value_type1 = absl::variant_alternative_t<0, Variant>;
329 using value_type2 = absl::variant_alternative_t<1, Variant>;
330 using value_type3 = absl::variant_alternative_t<2, Variant>;
331 using value_type4 = absl::variant_alternative_t<3, Variant>;
332 const TypeParam value(TypeParam::kIndex);
333 Variant original(value);
334 Variant copied(original);
335 EXPECT_TRUE(absl::holds_alternative<value_type1>(copied) ||
336 TypeParam::kIndex != 1);
337 EXPECT_TRUE(absl::holds_alternative<value_type2>(copied) ||
338 TypeParam::kIndex != 2);
339 EXPECT_TRUE(absl::holds_alternative<value_type3>(copied) ||
340 TypeParam::kIndex != 3);
341 EXPECT_TRUE(absl::holds_alternative<value_type4>(copied) ||
342 TypeParam::kIndex != 4);
343 EXPECT_TRUE((absl::get_if<value_type1>(&original) ==
344 absl::get_if<value_type1>(&copied)) ||
345 TypeParam::kIndex == 1);
346 EXPECT_TRUE((absl::get_if<value_type2>(&original) ==
347 absl::get_if<value_type2>(&copied)) ||
348 TypeParam::kIndex == 2);
349 EXPECT_TRUE((absl::get_if<value_type3>(&original) ==
350 absl::get_if<value_type3>(&copied)) ||
351 TypeParam::kIndex == 3);
352 EXPECT_TRUE((absl::get_if<value_type4>(&original) ==
353 absl::get_if<value_type4>(&copied)) ||
354 TypeParam::kIndex == 4);
355 EXPECT_TRUE((absl::get_if<value_type1>(&original) ==
356 absl::get_if<value_type1>(&copied)) ||
357 TypeParam::kIndex == 1);
358 EXPECT_TRUE((absl::get_if<value_type2>(&original) ==
359 absl::get_if<value_type2>(&copied)) ||
360 TypeParam::kIndex == 2);
361 EXPECT_TRUE((absl::get_if<value_type3>(&original) ==
362 absl::get_if<value_type3>(&copied)) ||
363 TypeParam::kIndex == 3);
364 EXPECT_TRUE((absl::get_if<value_type4>(&original) ==
365 absl::get_if<value_type4>(&copied)) ||
366 TypeParam::kIndex == 4);
367 const TypeParam* ovalptr = absl::get_if<TypeParam>(&original);
368 const TypeParam* cvalptr = absl::get_if<TypeParam>(&copied);
369 ASSERT_TRUE(ovalptr != nullptr);
370 ASSERT_TRUE(cvalptr != nullptr);
371 EXPECT_EQ(*ovalptr, *cvalptr);
372 TypeParam* mutable_ovalptr = absl::get_if<TypeParam>(&original);
373 TypeParam* mutable_cvalptr = absl::get_if<TypeParam>(&copied);
374 ASSERT_TRUE(mutable_ovalptr != nullptr);
375 ASSERT_TRUE(mutable_cvalptr != nullptr);
376 EXPECT_EQ(*mutable_ovalptr, *mutable_cvalptr);
377 }
378
379 template <class>
380 struct MoveOnly {
381 MoveOnly() = default;
MoveOnlyabsl::__anon997132050111::MoveOnly382 explicit MoveOnly(int value) : value(value) {}
383 MoveOnly(MoveOnly&&) = default;
384 MoveOnly& operator=(MoveOnly&&) = default;
385 int value = 5;
386 };
387
TEST(VariantTest,TestMoveConstruct)388 TEST(VariantTest, TestMoveConstruct) {
389 using V = variant<MoveOnly<class A>, MoveOnly<class B>, MoveOnly<class C>>;
390
391 V v(in_place_index<1>, 10);
392 V v2 = absl::move(v);
393 EXPECT_EQ(10, absl::get<1>(v2).value);
394 }
395
396 // Used internally to emulate missing triviality traits for tests.
397 template <class T>
398 union SingleUnion {
399 T member;
400 };
401
402 // NOTE: These don't work with types that can't be union members.
403 // They are just for testing.
404 template <class T>
405 struct is_trivially_move_constructible
406 : std::is_move_constructible<SingleUnion<T>>::type {};
407
408 template <class T>
409 struct is_trivially_move_assignable
410 : absl::is_move_assignable<SingleUnion<T>>::type {};
411
TEST(VariantTest,NothrowMoveConstructible)412 TEST(VariantTest, NothrowMoveConstructible) {
413 // Verify that variant is nothrow move constructible iff its template
414 // arguments are.
415 using U = std::unique_ptr<int>;
416 struct E {
417 E(E&&) {}
418 };
419 static_assert(std::is_nothrow_move_constructible<variant<U>>::value, "");
420 static_assert(std::is_nothrow_move_constructible<variant<U, int>>::value, "");
421 static_assert(!std::is_nothrow_move_constructible<variant<U, E>>::value, "");
422 }
423
424 // Test that for each slot, constructing a variant with that type
425 // produces a sensible object that correctly reports its type, and
426 // that copies the provided value.
TYPED_TEST(VariantTypesTest,TestValueCtor)427 TYPED_TEST(VariantTypesTest, TestValueCtor) {
428 typedef typename VariantFactory<typename TypeParam::value_type>::Type Variant;
429 using value_type1 = absl::variant_alternative_t<0, Variant>;
430 using value_type2 = absl::variant_alternative_t<1, Variant>;
431 using value_type3 = absl::variant_alternative_t<2, Variant>;
432 using value_type4 = absl::variant_alternative_t<3, Variant>;
433 const TypeParam value(TypeParam::kIndex);
434 Variant v(value);
435 EXPECT_TRUE(absl::holds_alternative<value_type1>(v) ||
436 TypeParam::kIndex != 1);
437 EXPECT_TRUE(absl::holds_alternative<value_type2>(v) ||
438 TypeParam::kIndex != 2);
439 EXPECT_TRUE(absl::holds_alternative<value_type3>(v) ||
440 TypeParam::kIndex != 3);
441 EXPECT_TRUE(absl::holds_alternative<value_type4>(v) ||
442 TypeParam::kIndex != 4);
443 EXPECT_TRUE(nullptr != absl::get_if<value_type1>(&v) ||
444 TypeParam::kIndex != 1);
445 EXPECT_TRUE(nullptr != absl::get_if<value_type2>(&v) ||
446 TypeParam::kIndex != 2);
447 EXPECT_TRUE(nullptr != absl::get_if<value_type3>(&v) ||
448 TypeParam::kIndex != 3);
449 EXPECT_TRUE(nullptr != absl::get_if<value_type4>(&v) ||
450 TypeParam::kIndex != 4);
451 EXPECT_TRUE(nullptr != absl::get_if<value_type1>(&v) ||
452 TypeParam::kIndex != 1);
453 EXPECT_TRUE(nullptr != absl::get_if<value_type2>(&v) ||
454 TypeParam::kIndex != 2);
455 EXPECT_TRUE(nullptr != absl::get_if<value_type3>(&v) ||
456 TypeParam::kIndex != 3);
457 EXPECT_TRUE(nullptr != absl::get_if<value_type4>(&v) ||
458 TypeParam::kIndex != 4);
459 const TypeParam* valptr = absl::get_if<TypeParam>(&v);
460 ASSERT_TRUE(nullptr != valptr);
461 EXPECT_EQ(value.value, valptr->value);
462 const TypeParam* mutable_valptr = absl::get_if<TypeParam>(&v);
463 ASSERT_TRUE(nullptr != mutable_valptr);
464 EXPECT_EQ(value.value, mutable_valptr->value);
465 }
466
TEST(VariantTest,AmbiguousValueConstructor)467 TEST(VariantTest, AmbiguousValueConstructor) {
468 EXPECT_FALSE((std::is_convertible<int, absl::variant<int, int>>::value));
469 EXPECT_FALSE((std::is_constructible<absl::variant<int, int>, int>::value));
470 }
471
TEST(VariantTest,InPlaceType)472 TEST(VariantTest, InPlaceType) {
473 using Var = variant<int, std::string, NonCopyable, std::vector<int>>;
474
475 Var v1(in_place_type_t<int>(), 7);
476 ASSERT_TRUE(absl::holds_alternative<int>(v1));
477 EXPECT_EQ(7, absl::get<int>(v1));
478
479 Var v2(in_place_type_t<std::string>(), "ABC");
480 ASSERT_TRUE(absl::holds_alternative<std::string>(v2));
481 EXPECT_EQ("ABC", absl::get<std::string>(v2));
482
483 Var v3(in_place_type_t<std::string>(), "ABC", 2);
484 ASSERT_TRUE(absl::holds_alternative<std::string>(v3));
485 EXPECT_EQ("AB", absl::get<std::string>(v3));
486
487 Var v4(in_place_type_t<NonCopyable>{});
488 ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v4));
489
490 Var v5(in_place_type_t<std::vector<int>>(), {1, 2, 3});
491 ASSERT_TRUE(absl::holds_alternative<std::vector<int>>(v5));
492 EXPECT_THAT(absl::get<std::vector<int>>(v5), ::testing::ElementsAre(1, 2, 3));
493 }
494
TEST(VariantTest,InPlaceTypeVariableTemplate)495 TEST(VariantTest, InPlaceTypeVariableTemplate) {
496 using Var = variant<int, std::string, NonCopyable, std::vector<int>>;
497
498 Var v1(in_place_type<int>, 7);
499 ASSERT_TRUE(absl::holds_alternative<int>(v1));
500 EXPECT_EQ(7, absl::get<int>(v1));
501
502 Var v2(in_place_type<std::string>, "ABC");
503 ASSERT_TRUE(absl::holds_alternative<std::string>(v2));
504 EXPECT_EQ("ABC", absl::get<std::string>(v2));
505
506 Var v3(in_place_type<std::string>, "ABC", 2);
507 ASSERT_TRUE(absl::holds_alternative<std::string>(v3));
508 EXPECT_EQ("AB", absl::get<std::string>(v3));
509
510 Var v4(in_place_type<NonCopyable>);
511 ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v4));
512
513 Var v5(in_place_type<std::vector<int>>, {1, 2, 3});
514 ASSERT_TRUE(absl::holds_alternative<std::vector<int>>(v5));
515 EXPECT_THAT(absl::get<std::vector<int>>(v5), ::testing::ElementsAre(1, 2, 3));
516 }
517
TEST(VariantTest,InPlaceTypeInitializerList)518 TEST(VariantTest, InPlaceTypeInitializerList) {
519 using Var =
520 variant<int, std::string, NonCopyable, MoveOnlyWithListConstructor>;
521
522 Var v1(in_place_type_t<MoveOnlyWithListConstructor>(), {1, 2, 3, 4, 5}, 6);
523 ASSERT_TRUE(absl::holds_alternative<MoveOnlyWithListConstructor>(v1));
524 EXPECT_EQ(6, absl::get<MoveOnlyWithListConstructor>(v1).value);
525 }
526
TEST(VariantTest,InPlaceTypeInitializerListVariabletemplate)527 TEST(VariantTest, InPlaceTypeInitializerListVariabletemplate) {
528 using Var =
529 variant<int, std::string, NonCopyable, MoveOnlyWithListConstructor>;
530
531 Var v1(in_place_type<MoveOnlyWithListConstructor>, {1, 2, 3, 4, 5}, 6);
532 ASSERT_TRUE(absl::holds_alternative<MoveOnlyWithListConstructor>(v1));
533 EXPECT_EQ(6, absl::get<MoveOnlyWithListConstructor>(v1).value);
534 }
535
TEST(VariantTest,InPlaceIndex)536 TEST(VariantTest, InPlaceIndex) {
537 using Var = variant<int, std::string, NonCopyable, std::vector<int>>;
538
539 Var v1(in_place_index_t<0>(), 7);
540 ASSERT_TRUE(absl::holds_alternative<int>(v1));
541 EXPECT_EQ(7, absl::get<int>(v1));
542
543 Var v2(in_place_index_t<1>(), "ABC");
544 ASSERT_TRUE(absl::holds_alternative<std::string>(v2));
545 EXPECT_EQ("ABC", absl::get<std::string>(v2));
546
547 Var v3(in_place_index_t<1>(), "ABC", 2);
548 ASSERT_TRUE(absl::holds_alternative<std::string>(v3));
549 EXPECT_EQ("AB", absl::get<std::string>(v3));
550
551 Var v4(in_place_index_t<2>{});
552 EXPECT_TRUE(absl::holds_alternative<NonCopyable>(v4));
553
554 // Verify that a variant with only non-copyables can still be constructed.
555 EXPECT_TRUE(absl::holds_alternative<NonCopyable>(
556 variant<NonCopyable>(in_place_index_t<0>{})));
557
558 Var v5(in_place_index_t<3>(), {1, 2, 3});
559 ASSERT_TRUE(absl::holds_alternative<std::vector<int>>(v5));
560 EXPECT_THAT(absl::get<std::vector<int>>(v5), ::testing::ElementsAre(1, 2, 3));
561 }
562
TEST(VariantTest,InPlaceIndexVariableTemplate)563 TEST(VariantTest, InPlaceIndexVariableTemplate) {
564 using Var = variant<int, std::string, NonCopyable, std::vector<int>>;
565
566 Var v1(in_place_index<0>, 7);
567 ASSERT_TRUE(absl::holds_alternative<int>(v1));
568 EXPECT_EQ(7, absl::get<int>(v1));
569
570 Var v2(in_place_index<1>, "ABC");
571 ASSERT_TRUE(absl::holds_alternative<std::string>(v2));
572 EXPECT_EQ("ABC", absl::get<std::string>(v2));
573
574 Var v3(in_place_index<1>, "ABC", 2);
575 ASSERT_TRUE(absl::holds_alternative<std::string>(v3));
576 EXPECT_EQ("AB", absl::get<std::string>(v3));
577
578 Var v4(in_place_index<2>);
579 EXPECT_TRUE(absl::holds_alternative<NonCopyable>(v4));
580
581 // Verify that a variant with only non-copyables can still be constructed.
582 EXPECT_TRUE(absl::holds_alternative<NonCopyable>(
583 variant<NonCopyable>(in_place_index<0>)));
584
585 Var v5(in_place_index<3>, {1, 2, 3});
586 ASSERT_TRUE(absl::holds_alternative<std::vector<int>>(v5));
587 EXPECT_THAT(absl::get<std::vector<int>>(v5), ::testing::ElementsAre(1, 2, 3));
588 }
589
TEST(VariantTest,InPlaceIndexInitializerList)590 TEST(VariantTest, InPlaceIndexInitializerList) {
591 using Var =
592 variant<int, std::string, NonCopyable, MoveOnlyWithListConstructor>;
593
594 Var v1(in_place_index_t<3>(), {1, 2, 3, 4, 5}, 6);
595 ASSERT_TRUE(absl::holds_alternative<MoveOnlyWithListConstructor>(v1));
596 EXPECT_EQ(6, absl::get<MoveOnlyWithListConstructor>(v1).value);
597 }
598
TEST(VariantTest,InPlaceIndexInitializerListVariableTemplate)599 TEST(VariantTest, InPlaceIndexInitializerListVariableTemplate) {
600 using Var =
601 variant<int, std::string, NonCopyable, MoveOnlyWithListConstructor>;
602
603 Var v1(in_place_index<3>, {1, 2, 3, 4, 5}, 6);
604 ASSERT_TRUE(absl::holds_alternative<MoveOnlyWithListConstructor>(v1));
605 EXPECT_EQ(6, absl::get<MoveOnlyWithListConstructor>(v1).value);
606 }
607
608 ////////////////////
609 // [variant.dtor] //
610 ////////////////////
611
612 // Make sure that the destructor destroys the contained value
TEST(VariantTest,TestDtor)613 TEST(VariantTest, TestDtor) {
614 typedef VariantFactory<IncrementInDtor>::Type Variant;
615 using value_type1 = absl::variant_alternative_t<0, Variant>;
616 using value_type2 = absl::variant_alternative_t<1, Variant>;
617 using value_type3 = absl::variant_alternative_t<2, Variant>;
618 using value_type4 = absl::variant_alternative_t<3, Variant>;
619 int counter = 0;
620 IncrementInDtor counter_adjuster(&counter);
621 EXPECT_EQ(0, counter);
622
623 value_type1 value1(counter_adjuster);
624 { Variant object(value1); }
625 EXPECT_EQ(1, counter);
626
627 value_type2 value2(counter_adjuster);
628 { Variant object(value2); }
629 EXPECT_EQ(2, counter);
630
631 value_type3 value3(counter_adjuster);
632 { Variant object(value3); }
633 EXPECT_EQ(3, counter);
634
635 value_type4 value4(counter_adjuster);
636 { Variant object(value4); }
637 EXPECT_EQ(4, counter);
638 }
639
640 #ifdef ABSL_HAVE_EXCEPTIONS
641
642 // See comment in absl/base/config.h
643 #if defined(ABSL_INTERNAL_MSVC_2017_DBG_MODE)
TEST(VariantTest,DISABLED_TestDtorValuelessByException)644 TEST(VariantTest, DISABLED_TestDtorValuelessByException)
645 #else
646 // Test destruction when in the valueless_by_exception state.
647 TEST(VariantTest, TestDtorValuelessByException)
648 #endif
649 {
650 int counter = 0;
651 IncrementInDtor counter_adjuster(&counter);
652
653 {
654 using Variant = VariantFactory<IncrementInDtor>::Type;
655
656 Variant v(in_place_index<0>, counter_adjuster);
657 EXPECT_EQ(0, counter);
658
659 ToValuelessByException(v);
660 ASSERT_TRUE(v.valueless_by_exception());
661 EXPECT_EQ(1, counter);
662 }
663 EXPECT_EQ(1, counter);
664 }
665
666 #endif // ABSL_HAVE_EXCEPTIONS
667
668 //////////////////////
669 // [variant.assign] //
670 //////////////////////
671
672 // Test that self-assignment doesn't destroy the current value
TEST(VariantTest,TestSelfAssignment)673 TEST(VariantTest, TestSelfAssignment) {
674 typedef VariantFactory<IncrementInDtor>::Type Variant;
675 int counter = 0;
676 IncrementInDtor counter_adjuster(&counter);
677 absl::variant_alternative_t<0, Variant> value(counter_adjuster);
678 Variant object(value);
679 object.operator=(object);
680 EXPECT_EQ(0, counter);
681
682 // A string long enough that it's likely to defeat any inline representation
683 // optimization.
684 const std::string long_str(128, 'a');
685
686 std::string foo = long_str;
687 foo = *&foo;
688 EXPECT_EQ(long_str, foo);
689
690 variant<int, std::string> so = long_str;
691 ASSERT_EQ(1, so.index());
692 EXPECT_EQ(long_str, absl::get<1>(so));
693 so = *&so;
694
695 ASSERT_EQ(1, so.index());
696 EXPECT_EQ(long_str, absl::get<1>(so));
697 }
698
699 // Test that assigning a variant<..., T, ...> to a variant<..., T, ...> produces
700 // a variant<..., T, ...> with the correct value.
TYPED_TEST(VariantTypesTest,TestAssignmentCopiesValueSameTypes)701 TYPED_TEST(VariantTypesTest, TestAssignmentCopiesValueSameTypes) {
702 typedef typename VariantFactory<typename TypeParam::value_type>::Type Variant;
703 const TypeParam value(TypeParam::kIndex);
704 const Variant source(value);
705 Variant target(TypeParam(value.value + 1));
706 ASSERT_TRUE(absl::holds_alternative<TypeParam>(source));
707 ASSERT_TRUE(absl::holds_alternative<TypeParam>(target));
708 ASSERT_NE(absl::get<TypeParam>(source), absl::get<TypeParam>(target));
709 target = source;
710 ASSERT_TRUE(absl::holds_alternative<TypeParam>(source));
711 ASSERT_TRUE(absl::holds_alternative<TypeParam>(target));
712 EXPECT_EQ(absl::get<TypeParam>(source), absl::get<TypeParam>(target));
713 }
714
715 // Test that assisnging a variant<..., T, ...> to a variant<1, ...>
716 // produces a variant<..., T, ...> with the correct value.
TYPED_TEST(VariantTypesTest,TestAssignmentCopiesValuesVaryingSourceType)717 TYPED_TEST(VariantTypesTest, TestAssignmentCopiesValuesVaryingSourceType) {
718 typedef typename VariantFactory<typename TypeParam::value_type>::Type Variant;
719 using value_type1 = absl::variant_alternative_t<0, Variant>;
720 const TypeParam value(TypeParam::kIndex);
721 const Variant source(value);
722 ASSERT_TRUE(absl::holds_alternative<TypeParam>(source));
723 Variant target(value_type1(1));
724 ASSERT_TRUE(absl::holds_alternative<value_type1>(target));
725 target = source;
726 EXPECT_TRUE(absl::holds_alternative<TypeParam>(source));
727 EXPECT_TRUE(absl::holds_alternative<TypeParam>(target));
728 EXPECT_EQ(absl::get<TypeParam>(source), absl::get<TypeParam>(target));
729 }
730
731 // Test that assigning a variant<1, ...> to a variant<..., T, ...>
732 // produces a variant<1, ...> with the correct value.
TYPED_TEST(VariantTypesTest,TestAssignmentCopiesValuesVaryingTargetType)733 TYPED_TEST(VariantTypesTest, TestAssignmentCopiesValuesVaryingTargetType) {
734 typedef typename VariantFactory<typename TypeParam::value_type>::Type Variant;
735 using value_type1 = absl::variant_alternative_t<0, Variant>;
736 const Variant source(value_type1(1));
737 ASSERT_TRUE(absl::holds_alternative<value_type1>(source));
738 const TypeParam value(TypeParam::kIndex);
739 Variant target(value);
740 ASSERT_TRUE(absl::holds_alternative<TypeParam>(target));
741 target = source;
742 EXPECT_TRUE(absl::holds_alternative<value_type1>(target));
743 EXPECT_TRUE(absl::holds_alternative<value_type1>(source));
744 EXPECT_EQ(absl::get<value_type1>(source), absl::get<value_type1>(target));
745 }
746
747 // Test that operator=<T> works, that assigning a new value destroys
748 // the old and that assigning the new value again does not redestroy
749 // the old
TEST(VariantTest,TestAssign)750 TEST(VariantTest, TestAssign) {
751 typedef VariantFactory<IncrementInDtor>::Type Variant;
752 using value_type1 = absl::variant_alternative_t<0, Variant>;
753 using value_type2 = absl::variant_alternative_t<1, Variant>;
754 using value_type3 = absl::variant_alternative_t<2, Variant>;
755 using value_type4 = absl::variant_alternative_t<3, Variant>;
756
757 const int kSize = 4;
758 int counter[kSize];
759 std::unique_ptr<IncrementInDtor> counter_adjustor[kSize];
760 for (int i = 0; i != kSize; i++) {
761 counter[i] = 0;
762 counter_adjustor[i] = absl::make_unique<IncrementInDtor>(&counter[i]);
763 }
764
765 value_type1 v1(*counter_adjustor[0]);
766 value_type2 v2(*counter_adjustor[1]);
767 value_type3 v3(*counter_adjustor[2]);
768 value_type4 v4(*counter_adjustor[3]);
769
770 // Test that reassignment causes destruction of old value
771 {
772 Variant object(v1);
773 object = v2;
774 object = v3;
775 object = v4;
776 object = v1;
777 }
778
779 EXPECT_EQ(2, counter[0]);
780 EXPECT_EQ(1, counter[1]);
781 EXPECT_EQ(1, counter[2]);
782 EXPECT_EQ(1, counter[3]);
783
784 std::fill(std::begin(counter), std::end(counter), 0);
785
786 // Test that self-assignment does not cause destruction of old value
787 {
788 Variant object(v1);
789 object.operator=(object);
790 EXPECT_EQ(0, counter[0]);
791 }
792 {
793 Variant object(v2);
794 object.operator=(object);
795 EXPECT_EQ(0, counter[1]);
796 }
797 {
798 Variant object(v3);
799 object.operator=(object);
800 EXPECT_EQ(0, counter[2]);
801 }
802 {
803 Variant object(v4);
804 object.operator=(object);
805 EXPECT_EQ(0, counter[3]);
806 }
807
808 EXPECT_EQ(1, counter[0]);
809 EXPECT_EQ(1, counter[1]);
810 EXPECT_EQ(1, counter[2]);
811 EXPECT_EQ(1, counter[3]);
812 }
813
814 // This tests that we perform a backup if the copy-assign can throw but the move
815 // cannot throw.
TEST(VariantTest,TestBackupAssign)816 TEST(VariantTest, TestBackupAssign) {
817 typedef VariantFactory<IncrementInDtorCopyCanThrow>::Type Variant;
818 using value_type1 = absl::variant_alternative_t<0, Variant>;
819 using value_type2 = absl::variant_alternative_t<1, Variant>;
820 using value_type3 = absl::variant_alternative_t<2, Variant>;
821 using value_type4 = absl::variant_alternative_t<3, Variant>;
822
823 const int kSize = 4;
824 int counter[kSize];
825 std::unique_ptr<IncrementInDtorCopyCanThrow> counter_adjustor[kSize];
826 for (int i = 0; i != kSize; i++) {
827 counter[i] = 0;
828 counter_adjustor[i].reset(new IncrementInDtorCopyCanThrow(&counter[i]));
829 }
830
831 value_type1 v1(*counter_adjustor[0]);
832 value_type2 v2(*counter_adjustor[1]);
833 value_type3 v3(*counter_adjustor[2]);
834 value_type4 v4(*counter_adjustor[3]);
835
836 // Test that reassignment causes destruction of old value
837 {
838 Variant object(v1);
839 object = v2;
840 object = v3;
841 object = v4;
842 object = v1;
843 }
844
845 // libstdc++ doesn't pass this test
846 #if !(defined(ABSL_USES_STD_VARIANT) && defined(__GLIBCXX__))
847 EXPECT_EQ(3, counter[0]);
848 EXPECT_EQ(2, counter[1]);
849 EXPECT_EQ(2, counter[2]);
850 EXPECT_EQ(2, counter[3]);
851 #endif
852
853 std::fill(std::begin(counter), std::end(counter), 0);
854
855 // Test that self-assignment does not cause destruction of old value
856 {
857 Variant object(v1);
858 object.operator=(object);
859 EXPECT_EQ(0, counter[0]);
860 }
861 {
862 Variant object(v2);
863 object.operator=(object);
864 EXPECT_EQ(0, counter[1]);
865 }
866 {
867 Variant object(v3);
868 object.operator=(object);
869 EXPECT_EQ(0, counter[2]);
870 }
871 {
872 Variant object(v4);
873 object.operator=(object);
874 EXPECT_EQ(0, counter[3]);
875 }
876
877 EXPECT_EQ(1, counter[0]);
878 EXPECT_EQ(1, counter[1]);
879 EXPECT_EQ(1, counter[2]);
880 EXPECT_EQ(1, counter[3]);
881 }
882
883 ///////////////////
884 // [variant.mod] //
885 ///////////////////
886
TEST(VariantTest,TestEmplaceBasic)887 TEST(VariantTest, TestEmplaceBasic) {
888 using Variant = variant<int, char>;
889
890 Variant v(absl::in_place_index<0>, 0);
891
892 {
893 char& emplace_result = v.emplace<char>();
894 ASSERT_TRUE(absl::holds_alternative<char>(v));
895 EXPECT_EQ(absl::get<char>(v), 0);
896 EXPECT_EQ(&emplace_result, &absl::get<char>(v));
897 }
898
899 // Make sure that another emplace does zero-initialization
900 absl::get<char>(v) = 'a';
901 v.emplace<char>('b');
902 ASSERT_TRUE(absl::holds_alternative<char>(v));
903 EXPECT_EQ(absl::get<char>(v), 'b');
904
905 {
906 int& emplace_result = v.emplace<int>();
907 EXPECT_TRUE(absl::holds_alternative<int>(v));
908 EXPECT_EQ(absl::get<int>(v), 0);
909 EXPECT_EQ(&emplace_result, &absl::get<int>(v));
910 }
911 }
912
TEST(VariantTest,TestEmplaceInitializerList)913 TEST(VariantTest, TestEmplaceInitializerList) {
914 using Var =
915 variant<int, std::string, NonCopyable, MoveOnlyWithListConstructor>;
916
917 Var v1(absl::in_place_index<0>, 555);
918 MoveOnlyWithListConstructor& emplace_result =
919 v1.emplace<MoveOnlyWithListConstructor>({1, 2, 3, 4, 5}, 6);
920 ASSERT_TRUE(absl::holds_alternative<MoveOnlyWithListConstructor>(v1));
921 EXPECT_EQ(6, absl::get<MoveOnlyWithListConstructor>(v1).value);
922 EXPECT_EQ(&emplace_result, &absl::get<MoveOnlyWithListConstructor>(v1));
923 }
924
TEST(VariantTest,TestEmplaceIndex)925 TEST(VariantTest, TestEmplaceIndex) {
926 using Variant = variant<int, char>;
927
928 Variant v(absl::in_place_index<0>, 555);
929
930 {
931 char& emplace_result = v.emplace<1>();
932 ASSERT_TRUE(absl::holds_alternative<char>(v));
933 EXPECT_EQ(absl::get<char>(v), 0);
934 EXPECT_EQ(&emplace_result, &absl::get<char>(v));
935 }
936
937 // Make sure that another emplace does zero-initialization
938 absl::get<char>(v) = 'a';
939 v.emplace<1>('b');
940 ASSERT_TRUE(absl::holds_alternative<char>(v));
941 EXPECT_EQ(absl::get<char>(v), 'b');
942
943 {
944 int& emplace_result = v.emplace<0>();
945 EXPECT_TRUE(absl::holds_alternative<int>(v));
946 EXPECT_EQ(absl::get<int>(v), 0);
947 EXPECT_EQ(&emplace_result, &absl::get<int>(v));
948 }
949 }
950
TEST(VariantTest,TestEmplaceIndexInitializerList)951 TEST(VariantTest, TestEmplaceIndexInitializerList) {
952 using Var =
953 variant<int, std::string, NonCopyable, MoveOnlyWithListConstructor>;
954
955 Var v1(absl::in_place_index<0>, 555);
956 MoveOnlyWithListConstructor& emplace_result =
957 v1.emplace<3>({1, 2, 3, 4, 5}, 6);
958 ASSERT_TRUE(absl::holds_alternative<MoveOnlyWithListConstructor>(v1));
959 EXPECT_EQ(6, absl::get<MoveOnlyWithListConstructor>(v1).value);
960 EXPECT_EQ(&emplace_result, &absl::get<MoveOnlyWithListConstructor>(v1));
961 }
962
963 //////////////////////
964 // [variant.status] //
965 //////////////////////
966
TEST(VariantTest,Index)967 TEST(VariantTest, Index) {
968 using Var = variant<int, std::string, double>;
969
970 Var v = 1;
971 EXPECT_EQ(0, v.index());
972 v = "str";
973 EXPECT_EQ(1, v.index());
974 v = 0.;
975 EXPECT_EQ(2, v.index());
976
977 Var v2 = v;
978 EXPECT_EQ(2, v2.index());
979 v2.emplace<int>(3);
980 EXPECT_EQ(0, v2.index());
981 }
982
TEST(VariantTest,NotValuelessByException)983 TEST(VariantTest, NotValuelessByException) {
984 using Var = variant<int, std::string, double>;
985
986 Var v = 1;
987 EXPECT_FALSE(v.valueless_by_exception());
988 v = "str";
989 EXPECT_FALSE(v.valueless_by_exception());
990 v = 0.;
991 EXPECT_FALSE(v.valueless_by_exception());
992
993 Var v2 = v;
994 EXPECT_FALSE(v.valueless_by_exception());
995 v2.emplace<int>(3);
996 EXPECT_FALSE(v.valueless_by_exception());
997 }
998
999 #ifdef ABSL_HAVE_EXCEPTIONS
1000
TEST(VariantTest,IndexValuelessByException)1001 TEST(VariantTest, IndexValuelessByException) {
1002 using Var = variant<MoveCanThrow, std::string, double>;
1003
1004 Var v(absl::in_place_index<0>);
1005 EXPECT_EQ(0, v.index());
1006 ToValuelessByException(v);
1007 EXPECT_EQ(absl::variant_npos, v.index());
1008 v = "str";
1009 EXPECT_EQ(1, v.index());
1010 }
1011
TEST(VariantTest,ValuelessByException)1012 TEST(VariantTest, ValuelessByException) {
1013 using Var = variant<MoveCanThrow, std::string, double>;
1014
1015 Var v(absl::in_place_index<0>);
1016 EXPECT_FALSE(v.valueless_by_exception());
1017 ToValuelessByException(v);
1018 EXPECT_TRUE(v.valueless_by_exception());
1019 v = "str";
1020 EXPECT_FALSE(v.valueless_by_exception());
1021 }
1022
1023 #endif // ABSL_HAVE_EXCEPTIONS
1024
1025 ////////////////////
1026 // [variant.swap] //
1027 ////////////////////
1028
TEST(VariantTest,MemberSwap)1029 TEST(VariantTest, MemberSwap) {
1030 SpecialSwap v1(3);
1031 SpecialSwap v2(7);
1032
1033 variant<SpecialSwap> a = v1, b = v2;
1034
1035 EXPECT_THAT(a, VariantWith<SpecialSwap>(v1));
1036 EXPECT_THAT(b, VariantWith<SpecialSwap>(v2));
1037
1038 a.swap(b);
1039 EXPECT_THAT(a, VariantWith<SpecialSwap>(v2));
1040 EXPECT_THAT(b, VariantWith<SpecialSwap>(v1));
1041 EXPECT_TRUE(absl::get<SpecialSwap>(a).special_swap);
1042
1043 using V = variant<MoveCanThrow, std::string, int>;
1044 int i = 33;
1045 std::string s = "abc";
1046 {
1047 // lhs and rhs holds different alternative
1048 V lhs(i), rhs(s);
1049 lhs.swap(rhs);
1050 EXPECT_THAT(lhs, VariantWith<std::string>(s));
1051 EXPECT_THAT(rhs, VariantWith<int>(i));
1052 }
1053 #ifdef ABSL_HAVE_EXCEPTIONS
1054 V valueless(in_place_index<0>);
1055 ToValuelessByException(valueless);
1056 {
1057 // lhs is valueless
1058 V lhs(valueless), rhs(i);
1059 lhs.swap(rhs);
1060 EXPECT_THAT(lhs, VariantWith<int>(i));
1061 EXPECT_TRUE(rhs.valueless_by_exception());
1062 }
1063 {
1064 // rhs is valueless
1065 V lhs(s), rhs(valueless);
1066 lhs.swap(rhs);
1067 EXPECT_THAT(rhs, VariantWith<std::string>(s));
1068 EXPECT_TRUE(lhs.valueless_by_exception());
1069 }
1070 {
1071 // both are valueless
1072 V lhs(valueless), rhs(valueless);
1073 lhs.swap(rhs);
1074 EXPECT_TRUE(lhs.valueless_by_exception());
1075 EXPECT_TRUE(rhs.valueless_by_exception());
1076 }
1077 #endif // ABSL_HAVE_EXCEPTIONS
1078 }
1079
1080 //////////////////////
1081 // [variant.helper] //
1082 //////////////////////
1083
TEST(VariantTest,VariantSize)1084 TEST(VariantTest, VariantSize) {
1085 {
1086 using Size1Variant = absl::variant<int>;
1087 EXPECT_EQ(1, absl::variant_size<Size1Variant>::value);
1088 EXPECT_EQ(1, absl::variant_size<const Size1Variant>::value);
1089 EXPECT_EQ(1, absl::variant_size<volatile Size1Variant>::value);
1090 EXPECT_EQ(1, absl::variant_size<const volatile Size1Variant>::value);
1091 }
1092
1093 {
1094 using Size3Variant = absl::variant<int, float, int>;
1095 EXPECT_EQ(3, absl::variant_size<Size3Variant>::value);
1096 EXPECT_EQ(3, absl::variant_size<const Size3Variant>::value);
1097 EXPECT_EQ(3, absl::variant_size<volatile Size3Variant>::value);
1098 EXPECT_EQ(3, absl::variant_size<const volatile Size3Variant>::value);
1099 }
1100 }
1101
TEST(VariantTest,VariantAlternative)1102 TEST(VariantTest, VariantAlternative) {
1103 {
1104 using V = absl::variant<float, int, const char*>;
1105 EXPECT_TRUE(
1106 (std::is_same<float, absl::variant_alternative_t<0, V>>::value));
1107 EXPECT_TRUE((std::is_same<const float,
1108 absl::variant_alternative_t<0, const V>>::value));
1109 EXPECT_TRUE(
1110 (std::is_same<volatile float,
1111 absl::variant_alternative_t<0, volatile V>>::value));
1112 EXPECT_TRUE((
1113 std::is_same<const volatile float,
1114 absl::variant_alternative_t<0, const volatile V>>::value));
1115
1116 EXPECT_TRUE((std::is_same<int, absl::variant_alternative_t<1, V>>::value));
1117 EXPECT_TRUE((std::is_same<const int,
1118 absl::variant_alternative_t<1, const V>>::value));
1119 EXPECT_TRUE(
1120 (std::is_same<volatile int,
1121 absl::variant_alternative_t<1, volatile V>>::value));
1122 EXPECT_TRUE((
1123 std::is_same<const volatile int,
1124 absl::variant_alternative_t<1, const volatile V>>::value));
1125
1126 EXPECT_TRUE(
1127 (std::is_same<const char*, absl::variant_alternative_t<2, V>>::value));
1128 EXPECT_TRUE((std::is_same<const char* const,
1129 absl::variant_alternative_t<2, const V>>::value));
1130 EXPECT_TRUE(
1131 (std::is_same<const char* volatile,
1132 absl::variant_alternative_t<2, volatile V>>::value));
1133 EXPECT_TRUE((
1134 std::is_same<const char* const volatile,
1135 absl::variant_alternative_t<2, const volatile V>>::value));
1136 }
1137
1138 {
1139 using V = absl::variant<float, volatile int, const char*>;
1140 EXPECT_TRUE(
1141 (std::is_same<float, absl::variant_alternative_t<0, V>>::value));
1142 EXPECT_TRUE((std::is_same<const float,
1143 absl::variant_alternative_t<0, const V>>::value));
1144 EXPECT_TRUE(
1145 (std::is_same<volatile float,
1146 absl::variant_alternative_t<0, volatile V>>::value));
1147 EXPECT_TRUE((
1148 std::is_same<const volatile float,
1149 absl::variant_alternative_t<0, const volatile V>>::value));
1150
1151 EXPECT_TRUE(
1152 (std::is_same<volatile int, absl::variant_alternative_t<1, V>>::value));
1153 EXPECT_TRUE((std::is_same<const volatile int,
1154 absl::variant_alternative_t<1, const V>>::value));
1155 EXPECT_TRUE(
1156 (std::is_same<volatile int,
1157 absl::variant_alternative_t<1, volatile V>>::value));
1158 EXPECT_TRUE((
1159 std::is_same<const volatile int,
1160 absl::variant_alternative_t<1, const volatile V>>::value));
1161
1162 EXPECT_TRUE(
1163 (std::is_same<const char*, absl::variant_alternative_t<2, V>>::value));
1164 EXPECT_TRUE((std::is_same<const char* const,
1165 absl::variant_alternative_t<2, const V>>::value));
1166 EXPECT_TRUE(
1167 (std::is_same<const char* volatile,
1168 absl::variant_alternative_t<2, volatile V>>::value));
1169 EXPECT_TRUE((
1170 std::is_same<const char* const volatile,
1171 absl::variant_alternative_t<2, const volatile V>>::value));
1172 }
1173 }
1174
1175 ///////////////////
1176 // [variant.get] //
1177 ///////////////////
1178
TEST(VariantTest,HoldsAlternative)1179 TEST(VariantTest, HoldsAlternative) {
1180 using Var = variant<int, std::string, double>;
1181
1182 Var v = 1;
1183 EXPECT_TRUE(absl::holds_alternative<int>(v));
1184 EXPECT_FALSE(absl::holds_alternative<std::string>(v));
1185 EXPECT_FALSE(absl::holds_alternative<double>(v));
1186 v = "str";
1187 EXPECT_FALSE(absl::holds_alternative<int>(v));
1188 EXPECT_TRUE(absl::holds_alternative<std::string>(v));
1189 EXPECT_FALSE(absl::holds_alternative<double>(v));
1190 v = 0.;
1191 EXPECT_FALSE(absl::holds_alternative<int>(v));
1192 EXPECT_FALSE(absl::holds_alternative<std::string>(v));
1193 EXPECT_TRUE(absl::holds_alternative<double>(v));
1194
1195 Var v2 = v;
1196 EXPECT_FALSE(absl::holds_alternative<int>(v2));
1197 EXPECT_FALSE(absl::holds_alternative<std::string>(v2));
1198 EXPECT_TRUE(absl::holds_alternative<double>(v2));
1199 v2.emplace<int>(3);
1200 EXPECT_TRUE(absl::holds_alternative<int>(v2));
1201 EXPECT_FALSE(absl::holds_alternative<std::string>(v2));
1202 EXPECT_FALSE(absl::holds_alternative<double>(v2));
1203 }
1204
TEST(VariantTest,GetIndex)1205 TEST(VariantTest, GetIndex) {
1206 using Var = variant<int, std::string, double, int>;
1207
1208 {
1209 Var v(absl::in_place_index<0>, 0);
1210
1211 using LValueGetType = decltype(absl::get<0>(v));
1212 using RValueGetType = decltype(absl::get<0>(absl::move(v)));
1213
1214 EXPECT_TRUE((std::is_same<LValueGetType, int&>::value));
1215 EXPECT_TRUE((std::is_same<RValueGetType, int&&>::value));
1216 EXPECT_EQ(absl::get<0>(v), 0);
1217 EXPECT_EQ(absl::get<0>(absl::move(v)), 0);
1218
1219 const Var& const_v = v;
1220 using ConstLValueGetType = decltype(absl::get<0>(const_v));
1221 using ConstRValueGetType = decltype(absl::get<0>(absl::move(const_v)));
1222 EXPECT_TRUE((std::is_same<ConstLValueGetType, const int&>::value));
1223 EXPECT_TRUE((std::is_same<ConstRValueGetType, const int&&>::value));
1224 EXPECT_EQ(absl::get<0>(const_v), 0);
1225 EXPECT_EQ(absl::get<0>(absl::move(const_v)), 0);
1226 }
1227
1228 {
1229 Var v = std::string("Hello");
1230
1231 using LValueGetType = decltype(absl::get<1>(v));
1232 using RValueGetType = decltype(absl::get<1>(absl::move(v)));
1233
1234 EXPECT_TRUE((std::is_same<LValueGetType, std::string&>::value));
1235 EXPECT_TRUE((std::is_same<RValueGetType, std::string&&>::value));
1236 EXPECT_EQ(absl::get<1>(v), "Hello");
1237 EXPECT_EQ(absl::get<1>(absl::move(v)), "Hello");
1238
1239 const Var& const_v = v;
1240 using ConstLValueGetType = decltype(absl::get<1>(const_v));
1241 using ConstRValueGetType = decltype(absl::get<1>(absl::move(const_v)));
1242 EXPECT_TRUE((std::is_same<ConstLValueGetType, const std::string&>::value));
1243 EXPECT_TRUE((std::is_same<ConstRValueGetType, const std::string&&>::value));
1244 EXPECT_EQ(absl::get<1>(const_v), "Hello");
1245 EXPECT_EQ(absl::get<1>(absl::move(const_v)), "Hello");
1246 }
1247
1248 {
1249 Var v = 2.0;
1250
1251 using LValueGetType = decltype(absl::get<2>(v));
1252 using RValueGetType = decltype(absl::get<2>(absl::move(v)));
1253
1254 EXPECT_TRUE((std::is_same<LValueGetType, double&>::value));
1255 EXPECT_TRUE((std::is_same<RValueGetType, double&&>::value));
1256 EXPECT_EQ(absl::get<2>(v), 2.);
1257 EXPECT_EQ(absl::get<2>(absl::move(v)), 2.);
1258
1259 const Var& const_v = v;
1260 using ConstLValueGetType = decltype(absl::get<2>(const_v));
1261 using ConstRValueGetType = decltype(absl::get<2>(absl::move(const_v)));
1262 EXPECT_TRUE((std::is_same<ConstLValueGetType, const double&>::value));
1263 EXPECT_TRUE((std::is_same<ConstRValueGetType, const double&&>::value));
1264 EXPECT_EQ(absl::get<2>(const_v), 2.);
1265 EXPECT_EQ(absl::get<2>(absl::move(const_v)), 2.);
1266 }
1267
1268 {
1269 Var v(absl::in_place_index<0>, 0);
1270 v.emplace<3>(1);
1271
1272 using LValueGetType = decltype(absl::get<3>(v));
1273 using RValueGetType = decltype(absl::get<3>(absl::move(v)));
1274
1275 EXPECT_TRUE((std::is_same<LValueGetType, int&>::value));
1276 EXPECT_TRUE((std::is_same<RValueGetType, int&&>::value));
1277 EXPECT_EQ(absl::get<3>(v), 1);
1278 EXPECT_EQ(absl::get<3>(absl::move(v)), 1);
1279
1280 const Var& const_v = v;
1281 using ConstLValueGetType = decltype(absl::get<3>(const_v));
1282 using ConstRValueGetType = decltype(absl::get<3>(absl::move(const_v)));
1283 EXPECT_TRUE((std::is_same<ConstLValueGetType, const int&>::value));
1284 EXPECT_TRUE((std::is_same<ConstRValueGetType, const int&&>::value));
1285 EXPECT_EQ(absl::get<3>(const_v), 1);
1286 EXPECT_EQ(absl::get<3>(absl::move(const_v)), 1); // NOLINT
1287 }
1288 }
1289
TEST(VariantTest,BadGetIndex)1290 TEST(VariantTest, BadGetIndex) {
1291 using Var = variant<int, std::string, double>;
1292
1293 {
1294 Var v = 1;
1295
1296 ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<1>(v));
1297 ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<1>(std::move(v)));
1298
1299 const Var& const_v = v;
1300 ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<1>(const_v));
1301 ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(
1302 absl::get<1>(std::move(const_v))); // NOLINT
1303 }
1304
1305 {
1306 Var v = std::string("Hello");
1307
1308 ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<0>(v));
1309 ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<0>(std::move(v)));
1310
1311 const Var& const_v = v;
1312 ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<0>(const_v));
1313 ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(
1314 absl::get<0>(std::move(const_v))); // NOLINT
1315 }
1316 }
1317
TEST(VariantTest,GetType)1318 TEST(VariantTest, GetType) {
1319 using Var = variant<int, std::string, double>;
1320
1321 {
1322 Var v = 1;
1323
1324 using LValueGetType = decltype(absl::get<int>(v));
1325 using RValueGetType = decltype(absl::get<int>(absl::move(v)));
1326
1327 EXPECT_TRUE((std::is_same<LValueGetType, int&>::value));
1328 EXPECT_TRUE((std::is_same<RValueGetType, int&&>::value));
1329 EXPECT_EQ(absl::get<int>(v), 1);
1330 EXPECT_EQ(absl::get<int>(absl::move(v)), 1);
1331
1332 const Var& const_v = v;
1333 using ConstLValueGetType = decltype(absl::get<int>(const_v));
1334 using ConstRValueGetType = decltype(absl::get<int>(absl::move(const_v)));
1335 EXPECT_TRUE((std::is_same<ConstLValueGetType, const int&>::value));
1336 EXPECT_TRUE((std::is_same<ConstRValueGetType, const int&&>::value));
1337 EXPECT_EQ(absl::get<int>(const_v), 1);
1338 EXPECT_EQ(absl::get<int>(absl::move(const_v)), 1);
1339 }
1340
1341 {
1342 Var v = std::string("Hello");
1343
1344 using LValueGetType = decltype(absl::get<1>(v));
1345 using RValueGetType = decltype(absl::get<1>(absl::move(v)));
1346
1347 EXPECT_TRUE((std::is_same<LValueGetType, std::string&>::value));
1348 EXPECT_TRUE((std::is_same<RValueGetType, std::string&&>::value));
1349 EXPECT_EQ(absl::get<std::string>(v), "Hello");
1350 EXPECT_EQ(absl::get<std::string>(absl::move(v)), "Hello");
1351
1352 const Var& const_v = v;
1353 using ConstLValueGetType = decltype(absl::get<1>(const_v));
1354 using ConstRValueGetType = decltype(absl::get<1>(absl::move(const_v)));
1355 EXPECT_TRUE((std::is_same<ConstLValueGetType, const std::string&>::value));
1356 EXPECT_TRUE((std::is_same<ConstRValueGetType, const std::string&&>::value));
1357 EXPECT_EQ(absl::get<std::string>(const_v), "Hello");
1358 EXPECT_EQ(absl::get<std::string>(absl::move(const_v)), "Hello");
1359 }
1360
1361 {
1362 Var v = 2.0;
1363
1364 using LValueGetType = decltype(absl::get<2>(v));
1365 using RValueGetType = decltype(absl::get<2>(absl::move(v)));
1366
1367 EXPECT_TRUE((std::is_same<LValueGetType, double&>::value));
1368 EXPECT_TRUE((std::is_same<RValueGetType, double&&>::value));
1369 EXPECT_EQ(absl::get<double>(v), 2.);
1370 EXPECT_EQ(absl::get<double>(absl::move(v)), 2.);
1371
1372 const Var& const_v = v;
1373 using ConstLValueGetType = decltype(absl::get<2>(const_v));
1374 using ConstRValueGetType = decltype(absl::get<2>(absl::move(const_v)));
1375 EXPECT_TRUE((std::is_same<ConstLValueGetType, const double&>::value));
1376 EXPECT_TRUE((std::is_same<ConstRValueGetType, const double&&>::value));
1377 EXPECT_EQ(absl::get<double>(const_v), 2.);
1378 EXPECT_EQ(absl::get<double>(absl::move(const_v)), 2.);
1379 }
1380 }
1381
TEST(VariantTest,BadGetType)1382 TEST(VariantTest, BadGetType) {
1383 using Var = variant<int, std::string, double>;
1384
1385 {
1386 Var v = 1;
1387
1388 ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<std::string>(v));
1389 ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(
1390 absl::get<std::string>(std::move(v)));
1391
1392 const Var& const_v = v;
1393 ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(
1394 absl::get<std::string>(const_v));
1395 ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(
1396 absl::get<std::string>(std::move(const_v))); // NOLINT
1397 }
1398
1399 {
1400 Var v = std::string("Hello");
1401
1402 ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<int>(v));
1403 ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<int>(std::move(v)));
1404
1405 const Var& const_v = v;
1406 ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<int>(const_v));
1407 ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(
1408 absl::get<int>(std::move(const_v))); // NOLINT
1409 }
1410 }
1411
TEST(VariantTest,GetIfIndex)1412 TEST(VariantTest, GetIfIndex) {
1413 using Var = variant<int, std::string, double, int>;
1414
1415 {
1416 Var v(absl::in_place_index<0>, 0);
1417 EXPECT_TRUE(noexcept(absl::get_if<0>(&v)));
1418
1419 {
1420 auto* elem = absl::get_if<0>(&v);
1421 EXPECT_TRUE((std::is_same<decltype(elem), int*>::value));
1422 ASSERT_NE(elem, nullptr);
1423 EXPECT_EQ(*elem, 0);
1424 {
1425 auto* bad_elem = absl::get_if<1>(&v);
1426 EXPECT_TRUE((std::is_same<decltype(bad_elem), std::string*>::value));
1427 EXPECT_EQ(bad_elem, nullptr);
1428 }
1429 {
1430 auto* bad_elem = absl::get_if<2>(&v);
1431 EXPECT_TRUE((std::is_same<decltype(bad_elem), double*>::value));
1432 EXPECT_EQ(bad_elem, nullptr);
1433 }
1434 {
1435 auto* bad_elem = absl::get_if<3>(&v);
1436 EXPECT_TRUE((std::is_same<decltype(bad_elem), int*>::value));
1437 EXPECT_EQ(bad_elem, nullptr);
1438 }
1439 }
1440
1441 const Var& const_v = v;
1442 EXPECT_TRUE(noexcept(absl::get_if<0>(&const_v)));
1443
1444 {
1445 auto* elem = absl::get_if<0>(&const_v);
1446 EXPECT_TRUE((std::is_same<decltype(elem), const int*>::value));
1447 ASSERT_NE(elem, nullptr);
1448 EXPECT_EQ(*elem, 0);
1449 {
1450 auto* bad_elem = absl::get_if<1>(&const_v);
1451 EXPECT_TRUE(
1452 (std::is_same<decltype(bad_elem), const std::string*>::value));
1453 EXPECT_EQ(bad_elem, nullptr);
1454 }
1455 {
1456 auto* bad_elem = absl::get_if<2>(&const_v);
1457 EXPECT_TRUE((std::is_same<decltype(bad_elem), const double*>::value));
1458 EXPECT_EQ(bad_elem, nullptr);
1459 }
1460 {
1461 auto* bad_elem = absl::get_if<3>(&const_v);
1462 EXPECT_EQ(bad_elem, nullptr);
1463 EXPECT_TRUE((std::is_same<decltype(bad_elem), const int*>::value));
1464 }
1465 }
1466 }
1467
1468 {
1469 Var v = std::string("Hello");
1470 EXPECT_TRUE(noexcept(absl::get_if<1>(&v)));
1471
1472 {
1473 auto* elem = absl::get_if<1>(&v);
1474 EXPECT_TRUE((std::is_same<decltype(elem), std::string*>::value));
1475 ASSERT_NE(elem, nullptr);
1476 EXPECT_EQ(*elem, "Hello");
1477 {
1478 auto* bad_elem = absl::get_if<0>(&v);
1479 EXPECT_TRUE((std::is_same<decltype(bad_elem), int*>::value));
1480 EXPECT_EQ(bad_elem, nullptr);
1481 }
1482 {
1483 auto* bad_elem = absl::get_if<2>(&v);
1484 EXPECT_TRUE((std::is_same<decltype(bad_elem), double*>::value));
1485 EXPECT_EQ(bad_elem, nullptr);
1486 }
1487 {
1488 auto* bad_elem = absl::get_if<3>(&v);
1489 EXPECT_TRUE((std::is_same<decltype(bad_elem), int*>::value));
1490 EXPECT_EQ(bad_elem, nullptr);
1491 }
1492 }
1493
1494 const Var& const_v = v;
1495 EXPECT_TRUE(noexcept(absl::get_if<1>(&const_v)));
1496
1497 {
1498 auto* elem = absl::get_if<1>(&const_v);
1499 EXPECT_TRUE((std::is_same<decltype(elem), const std::string*>::value));
1500 ASSERT_NE(elem, nullptr);
1501 EXPECT_EQ(*elem, "Hello");
1502 {
1503 auto* bad_elem = absl::get_if<0>(&const_v);
1504 EXPECT_TRUE((std::is_same<decltype(bad_elem), const int*>::value));
1505 EXPECT_EQ(bad_elem, nullptr);
1506 }
1507 {
1508 auto* bad_elem = absl::get_if<2>(&const_v);
1509 EXPECT_TRUE((std::is_same<decltype(bad_elem), const double*>::value));
1510 EXPECT_EQ(bad_elem, nullptr);
1511 }
1512 {
1513 auto* bad_elem = absl::get_if<3>(&const_v);
1514 EXPECT_EQ(bad_elem, nullptr);
1515 EXPECT_TRUE((std::is_same<decltype(bad_elem), const int*>::value));
1516 }
1517 }
1518 }
1519
1520 {
1521 Var v = 2.0;
1522 EXPECT_TRUE(noexcept(absl::get_if<2>(&v)));
1523
1524 {
1525 auto* elem = absl::get_if<2>(&v);
1526 EXPECT_TRUE((std::is_same<decltype(elem), double*>::value));
1527 ASSERT_NE(elem, nullptr);
1528 EXPECT_EQ(*elem, 2.0);
1529 {
1530 auto* bad_elem = absl::get_if<0>(&v);
1531 EXPECT_TRUE((std::is_same<decltype(bad_elem), int*>::value));
1532 EXPECT_EQ(bad_elem, nullptr);
1533 }
1534 {
1535 auto* bad_elem = absl::get_if<1>(&v);
1536 EXPECT_TRUE((std::is_same<decltype(bad_elem), std::string*>::value));
1537 EXPECT_EQ(bad_elem, nullptr);
1538 }
1539 {
1540 auto* bad_elem = absl::get_if<3>(&v);
1541 EXPECT_TRUE((std::is_same<decltype(bad_elem), int*>::value));
1542 EXPECT_EQ(bad_elem, nullptr);
1543 }
1544 }
1545
1546 const Var& const_v = v;
1547 EXPECT_TRUE(noexcept(absl::get_if<2>(&const_v)));
1548
1549 {
1550 auto* elem = absl::get_if<2>(&const_v);
1551 EXPECT_TRUE((std::is_same<decltype(elem), const double*>::value));
1552 ASSERT_NE(elem, nullptr);
1553 EXPECT_EQ(*elem, 2.0);
1554 {
1555 auto* bad_elem = absl::get_if<0>(&const_v);
1556 EXPECT_TRUE((std::is_same<decltype(bad_elem), const int*>::value));
1557 EXPECT_EQ(bad_elem, nullptr);
1558 }
1559 {
1560 auto* bad_elem = absl::get_if<1>(&const_v);
1561 EXPECT_TRUE(
1562 (std::is_same<decltype(bad_elem), const std::string*>::value));
1563 EXPECT_EQ(bad_elem, nullptr);
1564 }
1565 {
1566 auto* bad_elem = absl::get_if<3>(&const_v);
1567 EXPECT_EQ(bad_elem, nullptr);
1568 EXPECT_TRUE((std::is_same<decltype(bad_elem), const int*>::value));
1569 }
1570 }
1571 }
1572
1573 {
1574 Var v(absl::in_place_index<0>, 0);
1575 v.emplace<3>(1);
1576 EXPECT_TRUE(noexcept(absl::get_if<3>(&v)));
1577
1578 {
1579 auto* elem = absl::get_if<3>(&v);
1580 EXPECT_TRUE((std::is_same<decltype(elem), int*>::value));
1581 ASSERT_NE(elem, nullptr);
1582 EXPECT_EQ(*elem, 1);
1583 {
1584 auto* bad_elem = absl::get_if<0>(&v);
1585 EXPECT_TRUE((std::is_same<decltype(bad_elem), int*>::value));
1586 EXPECT_EQ(bad_elem, nullptr);
1587 }
1588 {
1589 auto* bad_elem = absl::get_if<1>(&v);
1590 EXPECT_TRUE((std::is_same<decltype(bad_elem), std::string*>::value));
1591 EXPECT_EQ(bad_elem, nullptr);
1592 }
1593 {
1594 auto* bad_elem = absl::get_if<2>(&v);
1595 EXPECT_TRUE((std::is_same<decltype(bad_elem), double*>::value));
1596 EXPECT_EQ(bad_elem, nullptr);
1597 }
1598 }
1599
1600 const Var& const_v = v;
1601 EXPECT_TRUE(noexcept(absl::get_if<3>(&const_v)));
1602
1603 {
1604 auto* elem = absl::get_if<3>(&const_v);
1605 EXPECT_TRUE((std::is_same<decltype(elem), const int*>::value));
1606 ASSERT_NE(elem, nullptr);
1607 EXPECT_EQ(*elem, 1);
1608 {
1609 auto* bad_elem = absl::get_if<0>(&const_v);
1610 EXPECT_TRUE((std::is_same<decltype(bad_elem), const int*>::value));
1611 EXPECT_EQ(bad_elem, nullptr);
1612 }
1613 {
1614 auto* bad_elem = absl::get_if<1>(&const_v);
1615 EXPECT_TRUE(
1616 (std::is_same<decltype(bad_elem), const std::string*>::value));
1617 EXPECT_EQ(bad_elem, nullptr);
1618 }
1619 {
1620 auto* bad_elem = absl::get_if<2>(&const_v);
1621 EXPECT_EQ(bad_elem, nullptr);
1622 EXPECT_TRUE((std::is_same<decltype(bad_elem), const double*>::value));
1623 }
1624 }
1625 }
1626 }
1627
1628 //////////////////////
1629 // [variant.relops] //
1630 //////////////////////
1631
TEST(VariantTest,OperatorEquals)1632 TEST(VariantTest, OperatorEquals) {
1633 variant<int, std::string> a(1), b(1);
1634 EXPECT_TRUE(a == b);
1635 EXPECT_TRUE(b == a);
1636 EXPECT_FALSE(a != b);
1637 EXPECT_FALSE(b != a);
1638
1639 b = "str";
1640 EXPECT_FALSE(a == b);
1641 EXPECT_FALSE(b == a);
1642 EXPECT_TRUE(a != b);
1643 EXPECT_TRUE(b != a);
1644
1645 b = 0;
1646 EXPECT_FALSE(a == b);
1647 EXPECT_FALSE(b == a);
1648 EXPECT_TRUE(a != b);
1649 EXPECT_TRUE(b != a);
1650
1651 a = b = "foo";
1652 EXPECT_TRUE(a == b);
1653 EXPECT_TRUE(b == a);
1654 EXPECT_FALSE(a != b);
1655 EXPECT_FALSE(b != a);
1656
1657 a = "bar";
1658 EXPECT_FALSE(a == b);
1659 EXPECT_FALSE(b == a);
1660 EXPECT_TRUE(a != b);
1661 EXPECT_TRUE(b != a);
1662 }
1663
TEST(VariantTest,OperatorRelational)1664 TEST(VariantTest, OperatorRelational) {
1665 variant<int, std::string> a(1), b(1);
1666 EXPECT_FALSE(a < b);
1667 EXPECT_FALSE(b < a);
1668 EXPECT_FALSE(a > b);
1669 EXPECT_FALSE(b > a);
1670 EXPECT_TRUE(a <= b);
1671 EXPECT_TRUE(b <= a);
1672 EXPECT_TRUE(a >= b);
1673 EXPECT_TRUE(b >= a);
1674
1675 b = "str";
1676 EXPECT_TRUE(a < b);
1677 EXPECT_FALSE(b < a);
1678 EXPECT_FALSE(a > b);
1679 EXPECT_TRUE(b > a);
1680 EXPECT_TRUE(a <= b);
1681 EXPECT_FALSE(b <= a);
1682 EXPECT_FALSE(a >= b);
1683 EXPECT_TRUE(b >= a);
1684
1685 b = 0;
1686 EXPECT_FALSE(a < b);
1687 EXPECT_TRUE(b < a);
1688 EXPECT_TRUE(a > b);
1689 EXPECT_FALSE(b > a);
1690 EXPECT_FALSE(a <= b);
1691 EXPECT_TRUE(b <= a);
1692 EXPECT_TRUE(a >= b);
1693 EXPECT_FALSE(b >= a);
1694
1695 a = b = "foo";
1696 EXPECT_FALSE(a < b);
1697 EXPECT_FALSE(b < a);
1698 EXPECT_FALSE(a > b);
1699 EXPECT_FALSE(b > a);
1700 EXPECT_TRUE(a <= b);
1701 EXPECT_TRUE(b <= a);
1702 EXPECT_TRUE(a >= b);
1703 EXPECT_TRUE(b >= a);
1704
1705 a = "bar";
1706 EXPECT_TRUE(a < b);
1707 EXPECT_FALSE(b < a);
1708 EXPECT_FALSE(a > b);
1709 EXPECT_TRUE(b > a);
1710 EXPECT_TRUE(a <= b);
1711 EXPECT_FALSE(b <= a);
1712 EXPECT_FALSE(a >= b);
1713 EXPECT_TRUE(b >= a);
1714 }
1715
1716 #ifdef ABSL_HAVE_EXCEPTIONS
1717
TEST(VariantTest,ValuelessOperatorEquals)1718 TEST(VariantTest, ValuelessOperatorEquals) {
1719 variant<MoveCanThrow, std::string> int_v(1), string_v("Hello"),
1720 valueless(absl::in_place_index<0>),
1721 other_valueless(absl::in_place_index<0>);
1722 ToValuelessByException(valueless);
1723 ToValuelessByException(other_valueless);
1724
1725 EXPECT_TRUE(valueless == other_valueless);
1726 EXPECT_TRUE(other_valueless == valueless);
1727 EXPECT_FALSE(valueless == int_v);
1728 EXPECT_FALSE(valueless == string_v);
1729 EXPECT_FALSE(int_v == valueless);
1730 EXPECT_FALSE(string_v == valueless);
1731
1732 EXPECT_FALSE(valueless != other_valueless);
1733 EXPECT_FALSE(other_valueless != valueless);
1734 EXPECT_TRUE(valueless != int_v);
1735 EXPECT_TRUE(valueless != string_v);
1736 EXPECT_TRUE(int_v != valueless);
1737 EXPECT_TRUE(string_v != valueless);
1738 }
1739
TEST(VariantTest,ValuelessOperatorRelational)1740 TEST(VariantTest, ValuelessOperatorRelational) {
1741 variant<MoveCanThrow, std::string> int_v(1), string_v("Hello"),
1742 valueless(absl::in_place_index<0>),
1743 other_valueless(absl::in_place_index<0>);
1744 ToValuelessByException(valueless);
1745 ToValuelessByException(other_valueless);
1746
1747 EXPECT_FALSE(valueless < other_valueless);
1748 EXPECT_FALSE(other_valueless < valueless);
1749 EXPECT_TRUE(valueless < int_v);
1750 EXPECT_TRUE(valueless < string_v);
1751 EXPECT_FALSE(int_v < valueless);
1752 EXPECT_FALSE(string_v < valueless);
1753
1754 EXPECT_TRUE(valueless <= other_valueless);
1755 EXPECT_TRUE(other_valueless <= valueless);
1756 EXPECT_TRUE(valueless <= int_v);
1757 EXPECT_TRUE(valueless <= string_v);
1758 EXPECT_FALSE(int_v <= valueless);
1759 EXPECT_FALSE(string_v <= valueless);
1760
1761 EXPECT_TRUE(valueless >= other_valueless);
1762 EXPECT_TRUE(other_valueless >= valueless);
1763 EXPECT_FALSE(valueless >= int_v);
1764 EXPECT_FALSE(valueless >= string_v);
1765 EXPECT_TRUE(int_v >= valueless);
1766 EXPECT_TRUE(string_v >= valueless);
1767
1768 EXPECT_FALSE(valueless > other_valueless);
1769 EXPECT_FALSE(other_valueless > valueless);
1770 EXPECT_FALSE(valueless > int_v);
1771 EXPECT_FALSE(valueless > string_v);
1772 EXPECT_TRUE(int_v > valueless);
1773 EXPECT_TRUE(string_v > valueless);
1774 }
1775
1776 #endif
1777
1778 /////////////////////
1779 // [variant.visit] //
1780 /////////////////////
1781
1782 template <typename T>
1783 struct ConvertTo {
1784 template <typename U>
operator ()absl::__anon997132050111::ConvertTo1785 T operator()(const U& u) const {
1786 return u;
1787 }
1788 };
1789
TEST(VariantTest,VisitSimple)1790 TEST(VariantTest, VisitSimple) {
1791 variant<std::string, const char*> v = "A";
1792
1793 std::string str = absl::visit(ConvertTo<std::string>{}, v);
1794 EXPECT_EQ("A", str);
1795
1796 v = std::string("B");
1797
1798 absl::string_view piece = absl::visit(ConvertTo<absl::string_view>{}, v);
1799 EXPECT_EQ("B", piece);
1800
1801 struct StrLen {
1802 int operator()(const char* s) const { return strlen(s); }
1803 int operator()(const std::string& s) const { return s.size(); }
1804 };
1805
1806 v = "SomeStr";
1807 EXPECT_EQ(7, absl::visit(StrLen{}, v));
1808 v = std::string("VeryLargeThisTime");
1809 EXPECT_EQ(17, absl::visit(StrLen{}, v));
1810 }
1811
TEST(VariantTest,VisitRValue)1812 TEST(VariantTest, VisitRValue) {
1813 variant<std::string> v = std::string("X");
1814 struct Visitor {
1815 bool operator()(const std::string&) const { return false; }
1816 bool operator()(std::string&&) const { return true; } // NOLINT
1817
1818 int operator()(const std::string&, const std::string&) const { return 0; }
1819 int operator()(const std::string&, std::string&&) const {
1820 return 1;
1821 } // NOLINT
1822 int operator()(std::string&&, const std::string&) const {
1823 return 2;
1824 } // NOLINT
1825 int operator()(std::string&&, std::string&&) const { return 3; } // NOLINT
1826 };
1827 EXPECT_FALSE(absl::visit(Visitor{}, v));
1828 EXPECT_TRUE(absl::visit(Visitor{}, absl::move(v)));
1829
1830 // Also test the variadic overload.
1831 EXPECT_EQ(0, absl::visit(Visitor{}, v, v));
1832 EXPECT_EQ(1, absl::visit(Visitor{}, v, absl::move(v)));
1833 EXPECT_EQ(2, absl::visit(Visitor{}, absl::move(v), v));
1834 EXPECT_EQ(3, absl::visit(Visitor{}, absl::move(v), absl::move(v)));
1835 }
1836
TEST(VariantTest,VisitRValueVisitor)1837 TEST(VariantTest, VisitRValueVisitor) {
1838 variant<std::string> v = std::string("X");
1839 struct Visitor {
1840 bool operator()(const std::string&) const& { return false; }
1841 bool operator()(const std::string&) && { return true; }
1842 };
1843 Visitor visitor;
1844 EXPECT_FALSE(absl::visit(visitor, v));
1845 EXPECT_TRUE(absl::visit(Visitor{}, v));
1846 }
1847
TEST(VariantTest,VisitResultTypeDifferent)1848 TEST(VariantTest, VisitResultTypeDifferent) {
1849 variant<std::string> v = std::string("X");
1850 struct LValue_LValue {};
1851 struct RValue_LValue {};
1852 struct LValue_RValue {};
1853 struct RValue_RValue {};
1854 struct Visitor {
1855 LValue_LValue operator()(const std::string&) const& { return {}; }
1856 RValue_LValue operator()(std::string&&) const& { return {}; } // NOLINT
1857 LValue_RValue operator()(const std::string&) && { return {}; }
1858 RValue_RValue operator()(std::string&&) && { return {}; } // NOLINT
1859 } visitor;
1860
1861 EXPECT_TRUE(
1862 (std::is_same<LValue_LValue, decltype(absl::visit(visitor, v))>::value));
1863 EXPECT_TRUE(
1864 (std::is_same<RValue_LValue,
1865 decltype(absl::visit(visitor, absl::move(v)))>::value));
1866 EXPECT_TRUE((
1867 std::is_same<LValue_RValue, decltype(absl::visit(Visitor{}, v))>::value));
1868 EXPECT_TRUE(
1869 (std::is_same<RValue_RValue,
1870 decltype(absl::visit(Visitor{}, absl::move(v)))>::value));
1871 }
1872
TEST(VariantTest,VisitVariadic)1873 TEST(VariantTest, VisitVariadic) {
1874 using A = variant<int, std::string>;
1875 using B = variant<std::unique_ptr<int>, absl::string_view>;
1876
1877 struct Visitor {
1878 std::pair<int, int> operator()(int a, std::unique_ptr<int> b) const {
1879 return {a, *b};
1880 }
1881 std::pair<int, int> operator()(absl::string_view a,
1882 std::unique_ptr<int> b) const {
1883 return {static_cast<int>(a.size()), static_cast<int>(*b)};
1884 }
1885 std::pair<int, int> operator()(int a, absl::string_view b) const {
1886 return {a, static_cast<int>(b.size())};
1887 }
1888 std::pair<int, int> operator()(absl::string_view a,
1889 absl::string_view b) const {
1890 return {static_cast<int>(a.size()), static_cast<int>(b.size())};
1891 }
1892 };
1893
1894 EXPECT_THAT(absl::visit(Visitor(), A(1), B(std::unique_ptr<int>(new int(7)))),
1895 ::testing::Pair(1, 7));
1896 EXPECT_THAT(absl::visit(Visitor(), A(1), B(absl::string_view("ABC"))),
1897 ::testing::Pair(1, 3));
1898 EXPECT_THAT(absl::visit(Visitor(), A(std::string("BBBBB")),
1899 B(std::unique_ptr<int>(new int(7)))),
1900 ::testing::Pair(5, 7));
1901 EXPECT_THAT(absl::visit(Visitor(), A(std::string("BBBBB")),
1902 B(absl::string_view("ABC"))),
1903 ::testing::Pair(5, 3));
1904 }
1905
TEST(VariantTest,VisitNoArgs)1906 TEST(VariantTest, VisitNoArgs) {
1907 EXPECT_EQ(5, absl::visit([] { return 5; }));
1908 }
1909
1910 struct ConstFunctor {
operator ()absl::__anon997132050111::ConstFunctor1911 int operator()(int a, int b) const { return a - b; }
1912 };
1913
1914 struct MutableFunctor {
operator ()absl::__anon997132050111::MutableFunctor1915 int operator()(int a, int b) { return a - b; }
1916 };
1917
1918 struct Class {
Methodabsl::__anon997132050111::Class1919 int Method(int a, int b) { return a - b; }
ConstMethodabsl::__anon997132050111::Class1920 int ConstMethod(int a, int b) const { return a - b; }
1921
1922 int member;
1923 };
1924
TEST(VariantTest,VisitReferenceWrapper)1925 TEST(VariantTest, VisitReferenceWrapper) {
1926 ConstFunctor cf;
1927 MutableFunctor mf;
1928 absl::variant<int> three = 3;
1929 absl::variant<int> two = 2;
1930
1931 EXPECT_EQ(1, absl::visit(std::cref(cf), three, two));
1932 EXPECT_EQ(1, absl::visit(std::ref(cf), three, two));
1933 EXPECT_EQ(1, absl::visit(std::ref(mf), three, two));
1934 }
1935
1936 // libstdc++ std::variant doesn't support the INVOKE semantics.
1937 #if !(defined(ABSL_USES_STD_VARIANT) && defined(__GLIBCXX__))
TEST(VariantTest,VisitMemberFunction)1938 TEST(VariantTest, VisitMemberFunction) {
1939 absl::variant<std::unique_ptr<Class>> p(absl::make_unique<Class>());
1940 absl::variant<std::unique_ptr<const Class>> cp(
1941 absl::make_unique<const Class>());
1942 absl::variant<int> three = 3;
1943 absl::variant<int> two = 2;
1944
1945 EXPECT_EQ(1, absl::visit(&Class::Method, p, three, two));
1946 EXPECT_EQ(1, absl::visit(&Class::ConstMethod, p, three, two));
1947 EXPECT_EQ(1, absl::visit(&Class::ConstMethod, cp, three, two));
1948 }
1949
TEST(VariantTest,VisitDataMember)1950 TEST(VariantTest, VisitDataMember) {
1951 absl::variant<std::unique_ptr<Class>> p(absl::make_unique<Class>(Class{42}));
1952 absl::variant<std::unique_ptr<const Class>> cp(
1953 absl::make_unique<const Class>(Class{42}));
1954 EXPECT_EQ(42, absl::visit(&Class::member, p));
1955
1956 absl::visit(&Class::member, p) = 5;
1957 EXPECT_EQ(5, absl::visit(&Class::member, p));
1958
1959 EXPECT_EQ(42, absl::visit(&Class::member, cp));
1960 }
1961 #endif // !(defined(ABSL_USES_STD_VARIANT) && defined(__GLIBCXX__))
1962
1963 /////////////////////////
1964 // [variant.monostate] //
1965 /////////////////////////
1966
TEST(VariantTest,MonostateBasic)1967 TEST(VariantTest, MonostateBasic) {
1968 absl::monostate mono;
1969 (void)mono;
1970
1971 // TODO(mattcalabrese) Expose move triviality metafunctions in absl.
1972 EXPECT_TRUE(absl::is_trivially_default_constructible<absl::monostate>::value);
1973 EXPECT_TRUE(is_trivially_move_constructible<absl::monostate>::value);
1974 EXPECT_TRUE(absl::is_trivially_copy_constructible<absl::monostate>::value);
1975 EXPECT_TRUE(is_trivially_move_assignable<absl::monostate>::value);
1976 EXPECT_TRUE(absl::is_trivially_copy_assignable<absl::monostate>::value);
1977 EXPECT_TRUE(absl::is_trivially_destructible<absl::monostate>::value);
1978 }
1979
TEST(VariantTest,VariantMonostateDefaultConstruction)1980 TEST(VariantTest, VariantMonostateDefaultConstruction) {
1981 absl::variant<absl::monostate, NonDefaultConstructible> var;
1982 EXPECT_EQ(var.index(), 0);
1983 }
1984
1985 ////////////////////////////////
1986 // [variant.monostate.relops] //
1987 ////////////////////////////////
1988
TEST(VariantTest,MonostateComparisons)1989 TEST(VariantTest, MonostateComparisons) {
1990 absl::monostate lhs, rhs;
1991
1992 EXPECT_EQ(lhs, lhs);
1993 EXPECT_EQ(lhs, rhs);
1994
1995 EXPECT_FALSE(lhs != lhs);
1996 EXPECT_FALSE(lhs != rhs);
1997 EXPECT_FALSE(lhs < lhs);
1998 EXPECT_FALSE(lhs < rhs);
1999 EXPECT_FALSE(lhs > lhs);
2000 EXPECT_FALSE(lhs > rhs);
2001
2002 EXPECT_LE(lhs, lhs);
2003 EXPECT_LE(lhs, rhs);
2004 EXPECT_GE(lhs, lhs);
2005 EXPECT_GE(lhs, rhs);
2006
2007 EXPECT_TRUE(noexcept(std::declval<absl::monostate>() ==
2008 std::declval<absl::monostate>()));
2009 EXPECT_TRUE(noexcept(std::declval<absl::monostate>() !=
2010 std::declval<absl::monostate>()));
2011 EXPECT_TRUE(noexcept(std::declval<absl::monostate>() <
2012 std::declval<absl::monostate>()));
2013 EXPECT_TRUE(noexcept(std::declval<absl::monostate>() >
2014 std::declval<absl::monostate>()));
2015 EXPECT_TRUE(noexcept(std::declval<absl::monostate>() <=
2016 std::declval<absl::monostate>()));
2017 EXPECT_TRUE(noexcept(std::declval<absl::monostate>() >=
2018 std::declval<absl::monostate>()));
2019 }
2020
2021 ///////////////////////
2022 // [variant.specalg] //
2023 ///////////////////////
2024
TEST(VariantTest,NonmemberSwap)2025 TEST(VariantTest, NonmemberSwap) {
2026 using std::swap;
2027
2028 SpecialSwap v1(3);
2029 SpecialSwap v2(7);
2030
2031 variant<SpecialSwap> a = v1, b = v2;
2032
2033 EXPECT_THAT(a, VariantWith<SpecialSwap>(v1));
2034 EXPECT_THAT(b, VariantWith<SpecialSwap>(v2));
2035
2036 std::swap(a, b);
2037 EXPECT_THAT(a, VariantWith<SpecialSwap>(v2));
2038 EXPECT_THAT(b, VariantWith<SpecialSwap>(v1));
2039 #ifndef ABSL_USES_STD_VARIANT
2040 EXPECT_FALSE(absl::get<SpecialSwap>(a).special_swap);
2041 #endif
2042
2043 swap(a, b);
2044 EXPECT_THAT(a, VariantWith<SpecialSwap>(v1));
2045 EXPECT_THAT(b, VariantWith<SpecialSwap>(v2));
2046 EXPECT_TRUE(absl::get<SpecialSwap>(b).special_swap);
2047 }
2048
2049 //////////////////////////
2050 // [variant.bad.access] //
2051 //////////////////////////
2052
TEST(VariantTest,BadAccess)2053 TEST(VariantTest, BadAccess) {
2054 EXPECT_TRUE(noexcept(absl::bad_variant_access()));
2055 absl::bad_variant_access exception_obj;
2056 std::exception* base = &exception_obj;
2057 (void)base;
2058 }
2059
2060 ////////////////////
2061 // [variant.hash] //
2062 ////////////////////
2063
TEST(VariantTest,MonostateHash)2064 TEST(VariantTest, MonostateHash) {
2065 absl::monostate mono, other_mono;
2066 std::hash<absl::monostate> const hasher{};
2067 static_assert(std::is_same<decltype(hasher(mono)), std::size_t>::value, "");
2068 EXPECT_EQ(hasher(mono), hasher(other_mono));
2069 }
2070
TEST(VariantTest,Hash)2071 TEST(VariantTest, Hash) {
2072 static_assert(type_traits_internal::IsHashable<variant<int>>::value, "");
2073 static_assert(type_traits_internal::IsHashable<variant<Hashable>>::value, "");
2074 static_assert(type_traits_internal::IsHashable<variant<int, Hashable>>::value,
2075 "");
2076
2077 #if ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_
2078 static_assert(!type_traits_internal::IsHashable<variant<NonHashable>>::value,
2079 "");
2080 static_assert(
2081 !type_traits_internal::IsHashable<variant<Hashable, NonHashable>>::value,
2082 "");
2083 #endif
2084
2085 // MSVC std::hash<std::variant> does not use the index, thus produce the same
2086 // result on the same value as different alternative.
2087 #if !(defined(_MSC_VER) && defined(ABSL_USES_STD_VARIANT))
2088 {
2089 // same value as different alternative
2090 variant<int, int> v0(in_place_index<0>, 42);
2091 variant<int, int> v1(in_place_index<1>, 42);
2092 std::hash<variant<int, int>> hash;
2093 EXPECT_NE(hash(v0), hash(v1));
2094 }
2095 #endif // !(defined(_MSC_VER) && defined(ABSL_USES_STD_VARIANT))
2096
2097 {
2098 std::hash<variant<int>> hash;
2099 std::set<size_t> hashcodes;
2100 for (int i = 0; i < 100; ++i) {
2101 hashcodes.insert(hash(i));
2102 }
2103 EXPECT_GT(hashcodes.size(), 90);
2104
2105 // test const-qualified
2106 static_assert(type_traits_internal::IsHashable<variant<const int>>::value,
2107 "");
2108 static_assert(
2109 type_traits_internal::IsHashable<variant<const Hashable>>::value, "");
2110 std::hash<absl::variant<const int>> c_hash;
2111 for (int i = 0; i < 100; ++i) {
2112 EXPECT_EQ(hash(i), c_hash(i));
2113 }
2114 }
2115 }
2116
2117 ////////////////////////////////////////
2118 // Miscellaneous and deprecated tests //
2119 ////////////////////////////////////////
2120
2121 // Test that a set requiring a basic type conversion works correctly
2122 #if !defined(ABSL_USES_STD_VARIANT)
TEST(VariantTest,TestConvertingSet)2123 TEST(VariantTest, TestConvertingSet) {
2124 typedef variant<double> Variant;
2125 Variant v(1.0);
2126 const int two = 2;
2127 v = two;
2128 EXPECT_TRUE(absl::holds_alternative<double>(v));
2129 ASSERT_TRUE(nullptr != absl::get_if<double>(&v));
2130 EXPECT_DOUBLE_EQ(2, absl::get<double>(v));
2131 }
2132 #endif // ABSL_USES_STD_VARIANT
2133
2134 // Test that a vector of variants behaves reasonably.
TEST(VariantTest,Container)2135 TEST(VariantTest, Container) {
2136 typedef variant<int, float> Variant;
2137
2138 // Creation of vector should work
2139 std::vector<Variant> vec;
2140 vec.push_back(Variant(10));
2141 vec.push_back(Variant(20.0f));
2142
2143 // Vector resizing should work if we supply a value for new slots
2144 vec.resize(10, Variant(0));
2145 }
2146
2147 // Test that a variant with a non-copyable type can be constructed and
2148 // manipulated to some degree.
TEST(VariantTest,TestVariantWithNonCopyableType)2149 TEST(VariantTest, TestVariantWithNonCopyableType) {
2150 typedef variant<int, NonCopyable> Variant;
2151 const int kValue = 1;
2152 Variant v(kValue);
2153 ASSERT_TRUE(absl::holds_alternative<int>(v));
2154 EXPECT_EQ(kValue, absl::get<int>(v));
2155 }
2156
2157 // Test that a variant with a non-copyable type can be transformed to
2158 // the non-copyable type with a call to `emplace` for different numbers
2159 // of arguments. We do not need to test this for each of T1 ... T8
2160 // because `emplace` does not overload on T1 ... to T8, so if this
2161 // works for any one of T1 ... T8, then it works for all of them. We
2162 // do need to test that it works with varying numbers of parameters
2163 // though.
TEST(VariantTest,TestEmplace)2164 TEST(VariantTest, TestEmplace) {
2165 typedef variant<int, NonCopyable> Variant;
2166 const int kValue = 1;
2167 Variant v(kValue);
2168 ASSERT_TRUE(absl::holds_alternative<int>(v));
2169 EXPECT_EQ(kValue, absl::get<int>(v));
2170
2171 // emplace with zero arguments, then back to 'int'
2172 v.emplace<NonCopyable>();
2173 ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v));
2174 EXPECT_EQ(0, absl::get<NonCopyable>(v).value);
2175 v = kValue;
2176 ASSERT_TRUE(absl::holds_alternative<int>(v));
2177
2178 // emplace with one argument:
2179 v.emplace<NonCopyable>(1);
2180 ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v));
2181 EXPECT_EQ(1, absl::get<NonCopyable>(v).value);
2182 v = kValue;
2183 ASSERT_TRUE(absl::holds_alternative<int>(v));
2184
2185 // emplace with two arguments:
2186 v.emplace<NonCopyable>(1, 2);
2187 ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v));
2188 EXPECT_EQ(3, absl::get<NonCopyable>(v).value);
2189 v = kValue;
2190 ASSERT_TRUE(absl::holds_alternative<int>(v));
2191
2192 // emplace with three arguments
2193 v.emplace<NonCopyable>(1, 2, 3);
2194 ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v));
2195 EXPECT_EQ(6, absl::get<NonCopyable>(v).value);
2196 v = kValue;
2197 ASSERT_TRUE(absl::holds_alternative<int>(v));
2198
2199 // emplace with four arguments
2200 v.emplace<NonCopyable>(1, 2, 3, 4);
2201 ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v));
2202 EXPECT_EQ(10, absl::get<NonCopyable>(v).value);
2203 v = kValue;
2204 ASSERT_TRUE(absl::holds_alternative<int>(v));
2205 }
2206
TEST(VariantTest,TestEmplaceDestroysCurrentValue)2207 TEST(VariantTest, TestEmplaceDestroysCurrentValue) {
2208 typedef variant<int, IncrementInDtor, NonCopyable> Variant;
2209 int counter = 0;
2210 Variant v(0);
2211 ASSERT_TRUE(absl::holds_alternative<int>(v));
2212 v.emplace<IncrementInDtor>(&counter);
2213 ASSERT_TRUE(absl::holds_alternative<IncrementInDtor>(v));
2214 ASSERT_EQ(0, counter);
2215 v.emplace<NonCopyable>();
2216 ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v));
2217 EXPECT_EQ(1, counter);
2218 }
2219
TEST(VariantTest,TestMoveSemantics)2220 TEST(VariantTest, TestMoveSemantics) {
2221 typedef variant<std::unique_ptr<int>, std::unique_ptr<std::string>> Variant;
2222
2223 // Construct a variant by moving from an element value.
2224 Variant v(absl::WrapUnique(new int(10)));
2225 EXPECT_TRUE(absl::holds_alternative<std::unique_ptr<int>>(v));
2226
2227 // Construct a variant by moving from another variant.
2228 Variant v2(absl::move(v));
2229 ASSERT_TRUE(absl::holds_alternative<std::unique_ptr<int>>(v2));
2230 ASSERT_NE(nullptr, absl::get<std::unique_ptr<int>>(v2));
2231 EXPECT_EQ(10, *absl::get<std::unique_ptr<int>>(v2));
2232
2233 // Moving from a variant object leaves it holding moved-from value of the
2234 // same element type.
2235 EXPECT_TRUE(absl::holds_alternative<std::unique_ptr<int>>(v));
2236 ASSERT_NE(nullptr, absl::get_if<std::unique_ptr<int>>(&v));
2237 EXPECT_EQ(nullptr, absl::get<std::unique_ptr<int>>(v));
2238
2239 // Assign a variant from an element value by move.
2240 v = absl::make_unique<std::string>("foo");
2241 ASSERT_TRUE(absl::holds_alternative<std::unique_ptr<std::string>>(v));
2242 EXPECT_EQ("foo", *absl::get<std::unique_ptr<std::string>>(v));
2243
2244 // Move-assign a variant.
2245 v2 = absl::move(v);
2246 ASSERT_TRUE(absl::holds_alternative<std::unique_ptr<std::string>>(v2));
2247 EXPECT_EQ("foo", *absl::get<std::unique_ptr<std::string>>(v2));
2248 EXPECT_TRUE(absl::holds_alternative<std::unique_ptr<std::string>>(v));
2249 }
2250
PassThrough(const variant<int,std::string> & arg)2251 variant<int, std::string> PassThrough(const variant<int, std::string>& arg) {
2252 return arg;
2253 }
2254
TEST(VariantTest,TestImplicitConversion)2255 TEST(VariantTest, TestImplicitConversion) {
2256 EXPECT_TRUE(absl::holds_alternative<int>(PassThrough(0)));
2257
2258 // We still need the explicit cast for std::string, because C++ won't apply
2259 // two user-defined implicit conversions in a row.
2260 EXPECT_TRUE(
2261 absl::holds_alternative<std::string>(PassThrough(std::string("foo"))));
2262 }
2263
2264 struct Convertible2;
2265 struct Convertible1 {
Convertible1absl::__anon997132050111::Convertible12266 Convertible1() {}
Convertible1absl::__anon997132050111::Convertible12267 Convertible1(const Convertible1&) {}
operator =absl::__anon997132050111::Convertible12268 Convertible1& operator=(const Convertible1&) { return *this; }
2269
2270 // implicit conversion from Convertible2
Convertible1absl::__anon997132050111::Convertible12271 Convertible1(const Convertible2&) {} // NOLINT(runtime/explicit)
2272 };
2273
2274 struct Convertible2 {
Convertible2absl::__anon997132050111::Convertible22275 Convertible2() {}
Convertible2absl::__anon997132050111::Convertible22276 Convertible2(const Convertible2&) {}
operator =absl::__anon997132050111::Convertible22277 Convertible2& operator=(const Convertible2&) { return *this; }
2278
2279 // implicit conversion from Convertible1
Convertible2absl::__anon997132050111::Convertible22280 Convertible2(const Convertible1&) {} // NOLINT(runtime/explicit)
2281 };
2282
TEST(VariantTest,TestRvalueConversion)2283 TEST(VariantTest, TestRvalueConversion) {
2284 #if !defined(ABSL_USES_STD_VARIANT)
2285 variant<double, std::string> var(
2286 ConvertVariantTo<variant<double, std::string>>(
2287 variant<std::string, int>(0)));
2288 ASSERT_TRUE(absl::holds_alternative<double>(var));
2289 EXPECT_EQ(0.0, absl::get<double>(var));
2290
2291 var = ConvertVariantTo<variant<double, std::string>>(
2292 variant<const char*, float>("foo"));
2293 ASSERT_TRUE(absl::holds_alternative<std::string>(var));
2294 EXPECT_EQ("foo", absl::get<std::string>(var));
2295
2296 variant<double> singleton(
2297 ConvertVariantTo<variant<double>>(variant<int, float>(42)));
2298 ASSERT_TRUE(absl::holds_alternative<double>(singleton));
2299 EXPECT_EQ(42.0, absl::get<double>(singleton));
2300
2301 singleton = ConvertVariantTo<variant<double>>(variant<int, float>(3.14f));
2302 ASSERT_TRUE(absl::holds_alternative<double>(singleton));
2303 EXPECT_FLOAT_EQ(3.14f, static_cast<float>(absl::get<double>(singleton)));
2304
2305 singleton = ConvertVariantTo<variant<double>>(variant<int>(0));
2306 ASSERT_TRUE(absl::holds_alternative<double>(singleton));
2307 EXPECT_EQ(0.0, absl::get<double>(singleton));
2308
2309 variant<int32_t, uint32_t> variant2(
2310 ConvertVariantTo<variant<int32_t, uint32_t>>(variant<int32_t>(42)));
2311 ASSERT_TRUE(absl::holds_alternative<int32_t>(variant2));
2312 EXPECT_EQ(42, absl::get<int32_t>(variant2));
2313
2314 variant2 =
2315 ConvertVariantTo<variant<int32_t, uint32_t>>(variant<uint32_t>(42));
2316 ASSERT_TRUE(absl::holds_alternative<uint32_t>(variant2));
2317 EXPECT_EQ(42, absl::get<uint32_t>(variant2));
2318 #endif // !ABSL_USES_STD_VARIANT
2319
2320 variant<Convertible1, Convertible2> variant3(
2321 ConvertVariantTo<variant<Convertible1, Convertible2>>(
2322 (variant<Convertible2, Convertible1>(Convertible1()))));
2323 ASSERT_TRUE(absl::holds_alternative<Convertible1>(variant3));
2324
2325 variant3 = ConvertVariantTo<variant<Convertible1, Convertible2>>(
2326 variant<Convertible2, Convertible1>(Convertible2()));
2327 ASSERT_TRUE(absl::holds_alternative<Convertible2>(variant3));
2328 }
2329
TEST(VariantTest,TestLvalueConversion)2330 TEST(VariantTest, TestLvalueConversion) {
2331 #if !defined(ABSL_USES_STD_VARIANT)
2332 variant<std::string, int> source1 = 0;
2333 variant<double, std::string> destination(
2334 ConvertVariantTo<variant<double, std::string>>(source1));
2335 ASSERT_TRUE(absl::holds_alternative<double>(destination));
2336 EXPECT_EQ(0.0, absl::get<double>(destination));
2337
2338 variant<const char*, float> source2 = "foo";
2339 destination = ConvertVariantTo<variant<double, std::string>>(source2);
2340 ASSERT_TRUE(absl::holds_alternative<std::string>(destination));
2341 EXPECT_EQ("foo", absl::get<std::string>(destination));
2342
2343 variant<int, float> source3(42);
2344 variant<double> singleton(ConvertVariantTo<variant<double>>(source3));
2345 ASSERT_TRUE(absl::holds_alternative<double>(singleton));
2346 EXPECT_EQ(42.0, absl::get<double>(singleton));
2347
2348 source3 = 3.14f;
2349 singleton = ConvertVariantTo<variant<double>>(source3);
2350 ASSERT_TRUE(absl::holds_alternative<double>(singleton));
2351 EXPECT_FLOAT_EQ(3.14f, static_cast<float>(absl::get<double>(singleton)));
2352
2353 variant<int> source4(0);
2354 singleton = ConvertVariantTo<variant<double>>(source4);
2355 ASSERT_TRUE(absl::holds_alternative<double>(singleton));
2356 EXPECT_EQ(0.0, absl::get<double>(singleton));
2357
2358 variant<int32_t> source5(42);
2359 variant<int32_t, uint32_t> variant2(
2360 ConvertVariantTo<variant<int32_t, uint32_t>>(source5));
2361 ASSERT_TRUE(absl::holds_alternative<int32_t>(variant2));
2362 EXPECT_EQ(42, absl::get<int32_t>(variant2));
2363
2364 variant<uint32_t> source6(42);
2365 variant2 = ConvertVariantTo<variant<int32_t, uint32_t>>(source6);
2366 ASSERT_TRUE(absl::holds_alternative<uint32_t>(variant2));
2367 EXPECT_EQ(42, absl::get<uint32_t>(variant2));
2368 #endif
2369
2370 variant<Convertible2, Convertible1> source7((Convertible1()));
2371 variant<Convertible1, Convertible2> variant3(
2372 ConvertVariantTo<variant<Convertible1, Convertible2>>(source7));
2373 ASSERT_TRUE(absl::holds_alternative<Convertible1>(variant3));
2374
2375 source7 = Convertible2();
2376 variant3 = ConvertVariantTo<variant<Convertible1, Convertible2>>(source7);
2377 ASSERT_TRUE(absl::holds_alternative<Convertible2>(variant3));
2378 }
2379
TEST(VariantTest,TestMoveConversion)2380 TEST(VariantTest, TestMoveConversion) {
2381 using Variant =
2382 variant<std::unique_ptr<const int>, std::unique_ptr<const std::string>>;
2383 using OtherVariant =
2384 variant<std::unique_ptr<int>, std::unique_ptr<std::string>>;
2385
2386 Variant var(
2387 ConvertVariantTo<Variant>(OtherVariant{absl::make_unique<int>(0)}));
2388 ASSERT_TRUE(absl::holds_alternative<std::unique_ptr<const int>>(var));
2389 ASSERT_NE(absl::get<std::unique_ptr<const int>>(var), nullptr);
2390 EXPECT_EQ(0, *absl::get<std::unique_ptr<const int>>(var));
2391
2392 var = ConvertVariantTo<Variant>(
2393 OtherVariant(absl::make_unique<std::string>("foo")));
2394 ASSERT_TRUE(absl::holds_alternative<std::unique_ptr<const std::string>>(var));
2395 EXPECT_EQ("foo", *absl::get<std::unique_ptr<const std::string>>(var));
2396 }
2397
TEST(VariantTest,DoesNotMoveFromLvalues)2398 TEST(VariantTest, DoesNotMoveFromLvalues) {
2399 // We use shared_ptr here because it's both copyable and movable, and
2400 // a moved-from shared_ptr is guaranteed to be null, so we can detect
2401 // whether moving or copying has occurred.
2402 using Variant =
2403 variant<std::shared_ptr<const int>, std::shared_ptr<const std::string>>;
2404 using OtherVariant =
2405 variant<std::shared_ptr<int>, std::shared_ptr<std::string>>;
2406
2407 Variant v1(std::make_shared<const int>(0));
2408
2409 // Test copy constructor
2410 Variant v2(v1);
2411 EXPECT_EQ(absl::get<std::shared_ptr<const int>>(v1),
2412 absl::get<std::shared_ptr<const int>>(v2));
2413
2414 // Test copy-assignment operator
2415 v1 = std::make_shared<const std::string>("foo");
2416 v2 = v1;
2417 EXPECT_EQ(absl::get<std::shared_ptr<const std::string>>(v1),
2418 absl::get<std::shared_ptr<const std::string>>(v2));
2419
2420 // Test converting copy constructor
2421 OtherVariant other(std::make_shared<int>(0));
2422 Variant v3(ConvertVariantTo<Variant>(other));
2423 EXPECT_EQ(absl::get<std::shared_ptr<int>>(other),
2424 absl::get<std::shared_ptr<const int>>(v3));
2425
2426 other = std::make_shared<std::string>("foo");
2427 v3 = ConvertVariantTo<Variant>(other);
2428 EXPECT_EQ(absl::get<std::shared_ptr<std::string>>(other),
2429 absl::get<std::shared_ptr<const std::string>>(v3));
2430 }
2431
TEST(VariantTest,TestRvalueConversionViaConvertVariantTo)2432 TEST(VariantTest, TestRvalueConversionViaConvertVariantTo) {
2433 #if !defined(ABSL_USES_STD_VARIANT)
2434 variant<double, std::string> var(
2435 ConvertVariantTo<variant<double, std::string>>(
2436 variant<std::string, int>(3)));
2437 EXPECT_THAT(absl::get_if<double>(&var), Pointee(3.0));
2438
2439 var = ConvertVariantTo<variant<double, std::string>>(
2440 variant<const char*, float>("foo"));
2441 EXPECT_THAT(absl::get_if<std::string>(&var), Pointee(std::string("foo")));
2442
2443 variant<double> singleton(
2444 ConvertVariantTo<variant<double>>(variant<int, float>(42)));
2445 EXPECT_THAT(absl::get_if<double>(&singleton), Pointee(42.0));
2446
2447 singleton = ConvertVariantTo<variant<double>>(variant<int, float>(3.14f));
2448 EXPECT_THAT(absl::get_if<double>(&singleton), Pointee(DoubleEq(3.14f)));
2449
2450 singleton = ConvertVariantTo<variant<double>>(variant<int>(3));
2451 EXPECT_THAT(absl::get_if<double>(&singleton), Pointee(3.0));
2452
2453 variant<int32_t, uint32_t> variant2(
2454 ConvertVariantTo<variant<int32_t, uint32_t>>(variant<int32_t>(42)));
2455 EXPECT_THAT(absl::get_if<int32_t>(&variant2), Pointee(42));
2456
2457 variant2 =
2458 ConvertVariantTo<variant<int32_t, uint32_t>>(variant<uint32_t>(42));
2459 EXPECT_THAT(absl::get_if<uint32_t>(&variant2), Pointee(42));
2460 #endif
2461
2462 variant<Convertible1, Convertible2> variant3(
2463 ConvertVariantTo<variant<Convertible1, Convertible2>>(
2464 (variant<Convertible2, Convertible1>(Convertible1()))));
2465 ASSERT_TRUE(absl::holds_alternative<Convertible1>(variant3));
2466
2467 variant3 = ConvertVariantTo<variant<Convertible1, Convertible2>>(
2468 variant<Convertible2, Convertible1>(Convertible2()));
2469 ASSERT_TRUE(absl::holds_alternative<Convertible2>(variant3));
2470 }
2471
TEST(VariantTest,TestLvalueConversionViaConvertVariantTo)2472 TEST(VariantTest, TestLvalueConversionViaConvertVariantTo) {
2473 #if !defined(ABSL_USES_STD_VARIANT)
2474 variant<std::string, int> source1 = 3;
2475 variant<double, std::string> destination(
2476 ConvertVariantTo<variant<double, std::string>>(source1));
2477 EXPECT_THAT(absl::get_if<double>(&destination), Pointee(3.0));
2478
2479 variant<const char*, float> source2 = "foo";
2480 destination = ConvertVariantTo<variant<double, std::string>>(source2);
2481 EXPECT_THAT(absl::get_if<std::string>(&destination),
2482 Pointee(std::string("foo")));
2483
2484 variant<int, float> source3(42);
2485 variant<double> singleton(ConvertVariantTo<variant<double>>(source3));
2486 EXPECT_THAT(absl::get_if<double>(&singleton), Pointee(42.0));
2487
2488 source3 = 3.14f;
2489 singleton = ConvertVariantTo<variant<double>>(source3);
2490 EXPECT_FLOAT_EQ(3.14f, static_cast<float>(absl::get<double>(singleton)));
2491 EXPECT_THAT(absl::get_if<double>(&singleton), Pointee(DoubleEq(3.14f)));
2492
2493 variant<int> source4(3);
2494 singleton = ConvertVariantTo<variant<double>>(source4);
2495 EXPECT_THAT(absl::get_if<double>(&singleton), Pointee(3.0));
2496
2497 variant<int32_t> source5(42);
2498 variant<int32_t, uint32_t> variant2(
2499 ConvertVariantTo<variant<int32_t, uint32_t>>(source5));
2500 EXPECT_THAT(absl::get_if<int32_t>(&variant2), Pointee(42));
2501
2502 variant<uint32_t> source6(42);
2503 variant2 = ConvertVariantTo<variant<int32_t, uint32_t>>(source6);
2504 EXPECT_THAT(absl::get_if<uint32_t>(&variant2), Pointee(42));
2505 #endif // !ABSL_USES_STD_VARIANT
2506
2507 variant<Convertible2, Convertible1> source7((Convertible1()));
2508 variant<Convertible1, Convertible2> variant3(
2509 ConvertVariantTo<variant<Convertible1, Convertible2>>(source7));
2510 ASSERT_TRUE(absl::holds_alternative<Convertible1>(variant3));
2511
2512 source7 = Convertible2();
2513 variant3 = ConvertVariantTo<variant<Convertible1, Convertible2>>(source7);
2514 ASSERT_TRUE(absl::holds_alternative<Convertible2>(variant3));
2515 }
2516
TEST(VariantTest,TestMoveConversionViaConvertVariantTo)2517 TEST(VariantTest, TestMoveConversionViaConvertVariantTo) {
2518 using Variant =
2519 variant<std::unique_ptr<const int>, std::unique_ptr<const std::string>>;
2520 using OtherVariant =
2521 variant<std::unique_ptr<int>, std::unique_ptr<std::string>>;
2522
2523 Variant var(
2524 ConvertVariantTo<Variant>(OtherVariant{absl::make_unique<int>(3)}));
2525 EXPECT_THAT(absl::get_if<std::unique_ptr<const int>>(&var),
2526 Pointee(Pointee(3)));
2527
2528 var = ConvertVariantTo<Variant>(
2529 OtherVariant(absl::make_unique<std::string>("foo")));
2530 EXPECT_THAT(absl::get_if<std::unique_ptr<const std::string>>(&var),
2531 Pointee(Pointee(std::string("foo"))));
2532 }
2533
2534 // If all alternatives are trivially copy/move constructible, variant should
2535 // also be trivially copy/move constructible. This is not required by the
2536 // standard and we know that libstdc++ variant doesn't have this feature.
2537 // For more details see the paper:
2538 // http://open-std.org/JTC1/SC22/WG21/docs/papers/2017/p0602r0.html
2539 #if !(defined(ABSL_USES_STD_VARIANT) && defined(__GLIBCXX__))
2540 #define ABSL_VARIANT_PROPAGATE_COPY_MOVE_TRIVIALITY 1
2541 #endif
2542
TEST(VariantTest,TestCopyAndMoveTypeTraits)2543 TEST(VariantTest, TestCopyAndMoveTypeTraits) {
2544 EXPECT_TRUE(std::is_copy_constructible<variant<std::string>>::value);
2545 EXPECT_TRUE(absl::is_copy_assignable<variant<std::string>>::value);
2546 EXPECT_TRUE(std::is_move_constructible<variant<std::string>>::value);
2547 EXPECT_TRUE(absl::is_move_assignable<variant<std::string>>::value);
2548 EXPECT_TRUE(std::is_move_constructible<variant<std::unique_ptr<int>>>::value);
2549 EXPECT_TRUE(absl::is_move_assignable<variant<std::unique_ptr<int>>>::value);
2550 EXPECT_FALSE(
2551 std::is_copy_constructible<variant<std::unique_ptr<int>>>::value);
2552 EXPECT_FALSE(absl::is_copy_assignable<variant<std::unique_ptr<int>>>::value);
2553
2554 EXPECT_FALSE(
2555 absl::is_trivially_copy_constructible<variant<std::string>>::value);
2556 EXPECT_FALSE(absl::is_trivially_copy_assignable<variant<std::string>>::value);
2557 #if ABSL_VARIANT_PROPAGATE_COPY_MOVE_TRIVIALITY
2558 EXPECT_TRUE(absl::is_trivially_copy_constructible<variant<int>>::value);
2559 EXPECT_TRUE(absl::is_trivially_copy_assignable<variant<int>>::value);
2560 EXPECT_TRUE(is_trivially_move_constructible<variant<int>>::value);
2561 EXPECT_TRUE(is_trivially_move_assignable<variant<int>>::value);
2562 #endif // ABSL_VARIANT_PROPAGATE_COPY_MOVE_TRIVIALITY
2563 }
2564
TEST(VariantTest,TestVectorOfMoveonlyVariant)2565 TEST(VariantTest, TestVectorOfMoveonlyVariant) {
2566 // Verify that variant<MoveonlyType> works correctly as a std::vector element.
2567 std::vector<variant<std::unique_ptr<int>, std::string>> vec;
2568 vec.push_back(absl::make_unique<int>(42));
2569 vec.emplace_back("Hello");
2570 vec.reserve(3);
2571 auto another_vec = absl::move(vec);
2572 // As a sanity check, verify vector contents.
2573 ASSERT_EQ(2, another_vec.size());
2574 EXPECT_EQ(42, *absl::get<std::unique_ptr<int>>(another_vec[0]));
2575 EXPECT_EQ("Hello", absl::get<std::string>(another_vec[1]));
2576 }
2577
TEST(VariantTest,NestedVariant)2578 TEST(VariantTest, NestedVariant) {
2579 #if ABSL_VARIANT_PROPAGATE_COPY_MOVE_TRIVIALITY
2580 static_assert(absl::is_trivially_copy_constructible<variant<int>>(), "");
2581 static_assert(absl::is_trivially_copy_assignable<variant<int>>(), "");
2582 static_assert(is_trivially_move_constructible<variant<int>>(), "");
2583 static_assert(is_trivially_move_assignable<variant<int>>(), "");
2584
2585 static_assert(absl::is_trivially_copy_constructible<variant<variant<int>>>(),
2586 "");
2587 static_assert(absl::is_trivially_copy_assignable<variant<variant<int>>>(),
2588 "");
2589 static_assert(is_trivially_move_constructible<variant<variant<int>>>(), "");
2590 static_assert(is_trivially_move_assignable<variant<variant<int>>>(), "");
2591 #endif // ABSL_VARIANT_PROPAGATE_COPY_MOVE_TRIVIALITY
2592
2593 variant<int> x(42);
2594 variant<variant<int>> y(x);
2595 variant<variant<int>> z(y);
2596 EXPECT_TRUE(absl::holds_alternative<variant<int>>(z));
2597 EXPECT_EQ(x, absl::get<variant<int>>(z));
2598 }
2599
2600 struct TriviallyDestructible {
TriviallyDestructibleabsl::__anon997132050111::TriviallyDestructible2601 TriviallyDestructible(TriviallyDestructible&&) {}
TriviallyDestructibleabsl::__anon997132050111::TriviallyDestructible2602 TriviallyDestructible(const TriviallyDestructible&) {}
operator =absl::__anon997132050111::TriviallyDestructible2603 TriviallyDestructible& operator=(TriviallyDestructible&&) { return *this; }
operator =absl::__anon997132050111::TriviallyDestructible2604 TriviallyDestructible& operator=(const TriviallyDestructible&) {
2605 return *this;
2606 }
2607 };
2608
2609 struct TriviallyMovable {
2610 TriviallyMovable(TriviallyMovable&&) = default;
TriviallyMovableabsl::__anon997132050111::TriviallyMovable2611 TriviallyMovable(TriviallyMovable const&) {}
operator =absl::__anon997132050111::TriviallyMovable2612 TriviallyMovable& operator=(const TriviallyMovable&) { return *this; }
2613 };
2614
2615 struct TriviallyCopyable {
2616 TriviallyCopyable(const TriviallyCopyable&) = default;
operator =absl::__anon997132050111::TriviallyCopyable2617 TriviallyCopyable& operator=(const TriviallyCopyable&) { return *this; }
2618 };
2619
2620 struct TriviallyMoveAssignable {
2621 TriviallyMoveAssignable(TriviallyMoveAssignable&&) = default;
TriviallyMoveAssignableabsl::__anon997132050111::TriviallyMoveAssignable2622 TriviallyMoveAssignable(const TriviallyMoveAssignable&) {}
2623 TriviallyMoveAssignable& operator=(TriviallyMoveAssignable&&) = default;
operator =absl::__anon997132050111::TriviallyMoveAssignable2624 TriviallyMoveAssignable& operator=(const TriviallyMoveAssignable&) {
2625 return *this;
2626 }
2627 };
2628
2629 struct TriviallyCopyAssignable {};
2630
2631 #if ABSL_VARIANT_PROPAGATE_COPY_MOVE_TRIVIALITY
TEST(VariantTest,TestTriviality)2632 TEST(VariantTest, TestTriviality) {
2633 {
2634 using TrivDestVar = absl::variant<TriviallyDestructible>;
2635
2636 EXPECT_FALSE(is_trivially_move_constructible<TrivDestVar>::value);
2637 EXPECT_FALSE(absl::is_trivially_copy_constructible<TrivDestVar>::value);
2638 EXPECT_FALSE(is_trivially_move_assignable<TrivDestVar>::value);
2639 EXPECT_FALSE(absl::is_trivially_copy_assignable<TrivDestVar>::value);
2640 EXPECT_TRUE(absl::is_trivially_destructible<TrivDestVar>::value);
2641 }
2642
2643 {
2644 using TrivMoveVar = absl::variant<TriviallyMovable>;
2645
2646 EXPECT_TRUE(is_trivially_move_constructible<TrivMoveVar>::value);
2647 EXPECT_FALSE(absl::is_trivially_copy_constructible<TrivMoveVar>::value);
2648 EXPECT_FALSE(is_trivially_move_assignable<TrivMoveVar>::value);
2649 EXPECT_FALSE(absl::is_trivially_copy_assignable<TrivMoveVar>::value);
2650 EXPECT_TRUE(absl::is_trivially_destructible<TrivMoveVar>::value);
2651 }
2652
2653 {
2654 using TrivCopyVar = absl::variant<TriviallyCopyable>;
2655
2656 EXPECT_TRUE(is_trivially_move_constructible<TrivCopyVar>::value);
2657 EXPECT_TRUE(absl::is_trivially_copy_constructible<TrivCopyVar>::value);
2658 EXPECT_FALSE(is_trivially_move_assignable<TrivCopyVar>::value);
2659 EXPECT_FALSE(absl::is_trivially_copy_assignable<TrivCopyVar>::value);
2660 EXPECT_TRUE(absl::is_trivially_destructible<TrivCopyVar>::value);
2661 }
2662
2663 {
2664 using TrivMoveAssignVar = absl::variant<TriviallyMoveAssignable>;
2665
2666 EXPECT_TRUE(is_trivially_move_constructible<TrivMoveAssignVar>::value);
2667 EXPECT_FALSE(
2668 absl::is_trivially_copy_constructible<TrivMoveAssignVar>::value);
2669 EXPECT_TRUE(is_trivially_move_assignable<TrivMoveAssignVar>::value);
2670 EXPECT_FALSE(absl::is_trivially_copy_assignable<TrivMoveAssignVar>::value);
2671 EXPECT_TRUE(absl::is_trivially_destructible<TrivMoveAssignVar>::value);
2672 }
2673
2674 {
2675 using TrivCopyAssignVar = absl::variant<TriviallyCopyAssignable>;
2676
2677 EXPECT_TRUE(is_trivially_move_constructible<TrivCopyAssignVar>::value);
2678 EXPECT_TRUE(
2679 absl::is_trivially_copy_constructible<TrivCopyAssignVar>::value);
2680 EXPECT_TRUE(is_trivially_move_assignable<TrivCopyAssignVar>::value);
2681 EXPECT_TRUE(absl::is_trivially_copy_assignable<TrivCopyAssignVar>::value);
2682 EXPECT_TRUE(absl::is_trivially_destructible<TrivCopyAssignVar>::value);
2683 }
2684 }
2685 #endif // ABSL_VARIANT_PROPAGATE_COPY_MOVE_TRIVIALITY
2686
2687 // To verify that absl::variant correctly use the nontrivial move ctor of its
2688 // member rather than use the trivial copy constructor.
TEST(VariantTest,MoveCtorBug)2689 TEST(VariantTest, MoveCtorBug) {
2690 // To simulate std::tuple in libstdc++.
2691 struct TrivialCopyNontrivialMove {
2692 TrivialCopyNontrivialMove() = default;
2693 TrivialCopyNontrivialMove(const TrivialCopyNontrivialMove&) = default;
2694 TrivialCopyNontrivialMove(TrivialCopyNontrivialMove&&) { called = true; }
2695 bool called = false;
2696 };
2697 {
2698 using V = absl::variant<TrivialCopyNontrivialMove, int>;
2699 V v1(absl::in_place_index<0>);
2700 // this should invoke the move ctor, rather than the trivial copy ctor.
2701 V v2(std::move(v1));
2702 EXPECT_TRUE(absl::get<0>(v2).called);
2703 }
2704 {
2705 // this case failed to compile before our fix due to a GCC bug.
2706 using V = absl::variant<int, TrivialCopyNontrivialMove>;
2707 V v1(absl::in_place_index<1>);
2708 // this should invoke the move ctor, rather than the trivial copy ctor.
2709 V v2(std::move(v1));
2710 EXPECT_TRUE(absl::get<1>(v2).called);
2711 }
2712 }
2713
2714 } // namespace
2715 ABSL_NAMESPACE_END
2716 } // namespace absl
2717
2718 #endif // #if !defined(ABSL_USES_STD_VARIANT)
2719