1 #include <array>
2 #include <cstdint>
3 #include <functional>
4 #include <memory>
5 #include <string>
6 #include <type_traits>
7 
8 #include <gtest/gtest.h>
9 #include <pdx/rpc/variant.h>
10 
11 using namespace android::pdx;
12 using namespace android::pdx::rpc;
13 
14 namespace {
15 
16 struct BaseType {
BaseType__anon1fde347f0111::BaseType17   BaseType(int value) : value(value) {}
18   int value;
19 };
20 
21 struct DerivedType : BaseType {
DerivedType__anon1fde347f0111::DerivedType22   DerivedType(int value) : BaseType{value} {};
23 };
24 
25 template <typename T>
26 class TestType {
27  public:
TestType(const T & value)28   TestType(const T& value) : value_(value) {}
TestType(T && value)29   TestType(T&& value) : value_(std::move(value)) {}
30   TestType(const TestType&) = default;
31   TestType(TestType&&) = default;
32 
33   TestType& operator=(const TestType&) = default;
34   TestType& operator=(TestType&&) = default;
35 
get() const36   const T& get() const { return value_; }
take()37   T&& take() { return std::move(value_); }
38 
39  private:
40   T value_;
41 };
42 
43 template <typename T>
44 class InstrumentType {
45  public:
InstrumentType(const T & value)46   InstrumentType(const T& value) : value_(value) { constructor_count_++; }
InstrumentType(T && value)47   InstrumentType(T&& value) : value_(std::move(value)) { constructor_count_++; }
InstrumentType(const InstrumentType & other)48   InstrumentType(const InstrumentType& other) : value_(other.value_) {
49     constructor_count_++;
50   }
InstrumentType(InstrumentType && other)51   InstrumentType(InstrumentType&& other) : value_(std::move(other.value_)) {
52     constructor_count_++;
53   }
InstrumentType(const TestType<T> & other)54   InstrumentType(const TestType<T>& other) : value_(other.get()) {
55     constructor_count_++;
56   }
InstrumentType(TestType<T> && other)57   InstrumentType(TestType<T>&& other) : value_(other.take()) {
58     constructor_count_++;
59   }
~InstrumentType()60   ~InstrumentType() { destructor_count_++; }
61 
operator =(const InstrumentType & other)62   InstrumentType& operator=(const InstrumentType& other) {
63     copy_assignment_count_++;
64     value_ = other.value_;
65     return *this;
66   }
operator =(InstrumentType && other)67   InstrumentType& operator=(InstrumentType&& other) {
68     move_assignment_count_++;
69     value_ = std::move(other.value_);
70     return *this;
71   }
72 
operator =(const TestType<T> & other)73   InstrumentType& operator=(const TestType<T>& other) {
74     copy_assignment_count_++;
75     value_ = other.get();
76     return *this;
77   }
operator =(TestType<T> && other)78   InstrumentType& operator=(TestType<T>&& other) {
79     move_assignment_count_++;
80     value_ = other.take();
81     return *this;
82   }
83 
constructor_count()84   static std::size_t constructor_count() { return constructor_count_; }
destructor_count()85   static std::size_t destructor_count() { return destructor_count_; }
move_assignment_count()86   static std::size_t move_assignment_count() { return move_assignment_count_; }
copy_assignment_count()87   static std::size_t copy_assignment_count() { return copy_assignment_count_; }
88 
get() const89   const T& get() const { return value_; }
take()90   T&& take() { return std::move(value_); }
91 
clear()92   static void clear() {
93     constructor_count_ = 0;
94     destructor_count_ = 0;
95     move_assignment_count_ = 0;
96     copy_assignment_count_ = 0;
97   }
98 
99  private:
100   T value_;
101 
102   static std::size_t constructor_count_;
103   static std::size_t destructor_count_;
104   static std::size_t move_assignment_count_;
105   static std::size_t copy_assignment_count_;
106 };
107 
108 template <typename T>
109 std::size_t InstrumentType<T>::constructor_count_ = 0;
110 template <typename T>
111 std::size_t InstrumentType<T>::destructor_count_ = 0;
112 template <typename T>
113 std::size_t InstrumentType<T>::move_assignment_count_ = 0;
114 template <typename T>
115 std::size_t InstrumentType<T>::copy_assignment_count_ = 0;
116 
117 }  // anonymous namespace
118 
TEST(Variant,Assignment)119 TEST(Variant, Assignment) {
120   // Assert basic type properties.
121   {
122     Variant<int, bool, float> v;
123     ASSERT_EQ(-1, v.index());
124     ASSERT_FALSE(v.is<int>());
125     ASSERT_FALSE(v.is<bool>());
126     ASSERT_FALSE(v.is<float>());
127   }
128 
129   {
130     Variant<int, bool, float> v;
131     v = 10;
132     ASSERT_EQ(0, v.index());
133     ASSERT_TRUE(v.is<int>());
134     ASSERT_FALSE(v.is<bool>());
135     ASSERT_FALSE(v.is<float>());
136     EXPECT_EQ(10, std::get<int>(v));
137   }
138 
139   {
140     Variant<int, bool, float> v;
141     v = false;
142     ASSERT_EQ(1, v.index());
143     ASSERT_FALSE(v.is<int>());
144     ASSERT_TRUE(v.is<bool>());
145     ASSERT_FALSE(v.is<float>());
146     EXPECT_EQ(false, std::get<bool>(v));
147   }
148 
149   {
150     Variant<int, bool, float> v;
151     v = 1.0f;
152     ASSERT_EQ(2, v.index());
153     ASSERT_FALSE(v.is<int>());
154     ASSERT_FALSE(v.is<bool>());
155     ASSERT_TRUE(v.is<float>());
156     EXPECT_FLOAT_EQ(1.0f, std::get<float>(v));
157   }
158 
159   {
160     Variant<int, bool, float> v;
161     // ERROR: More than one type is implicitly convertible from double.
162     // v = 1.0;
163     v = static_cast<float>(1.0);
164   }
165 
166   {
167     Variant<int, bool, float> v;
168 
169     double x = 1.1;
170     v = static_cast<float>(x);
171     ASSERT_EQ(2, v.index());
172     ASSERT_FALSE(v.is<int>());
173     ASSERT_FALSE(v.is<bool>());
174     ASSERT_TRUE(v.is<float>());
175     EXPECT_FLOAT_EQ(1.1, std::get<float>(v));
176   }
177 
178   {
179     Variant<int, std::string> v;
180     ASSERT_EQ(-1, v.index());
181     ASSERT_FALSE(v.is<int>());
182     ASSERT_FALSE(v.is<std::string>());
183   }
184 
185   {
186     Variant<int, std::string> v;
187     v = 20;
188     ASSERT_EQ(0, v.index());
189     ASSERT_TRUE(v.is<int>());
190     ASSERT_FALSE(v.is<std::string>());
191     EXPECT_EQ(20, std::get<int>(v));
192   }
193 
194   {
195     Variant<int, std::string> v;
196     v = std::string("test");
197     ASSERT_EQ(1, v.index());
198     ASSERT_FALSE(v.is<int>());
199     ASSERT_TRUE(v.is<std::string>());
200     EXPECT_EQ("test", std::get<std::string>(v));
201   }
202 
203   {
204     Variant<int, std::string> v;
205     v = "test";
206     ASSERT_EQ(1, v.index());
207     ASSERT_FALSE(v.is<int>());
208     ASSERT_TRUE(v.is<std::string>());
209     EXPECT_EQ("test", std::get<std::string>(v));
210   }
211 
212   {
213     Variant<const char*> v1;
214     Variant<std::string> v2;
215 
216     v1 = "test";
217     ASSERT_TRUE(v1.is<const char*>());
218     v2 = v1;
219     ASSERT_TRUE(v2.is<std::string>());
220     EXPECT_EQ("test", std::get<std::string>(v2));
221   }
222 
223   {
224     Variant<int> a(1);
225     Variant<int> b;
226     ASSERT_TRUE(!a.empty());
227     ASSERT_TRUE(b.empty());
228 
229     a = b;
230     ASSERT_TRUE(a.empty());
231     ASSERT_TRUE(b.empty());
232   }
233 
234   {
235     Variant<int*, char*> v;
236 
237     // ERROR: More than one type is implicitly convertible from nullptr.
238     // v = nullptr;
239 
240     v = static_cast<int*>(nullptr);
241     EXPECT_TRUE(v.is<int*>());
242 
243     v = static_cast<char*>(nullptr);
244     EXPECT_TRUE(v.is<char*>());
245   }
246 
247   {
248     Variant<int*, char*> v;
249     int a = 10;
250     char b = 20;
251 
252     v = &b;
253     ASSERT_TRUE(v.is<char*>());
254     EXPECT_EQ(&b, std::get<char*>(v));
255     EXPECT_EQ(b, *std::get<char*>(v));
256 
257     v = &a;
258     ASSERT_TRUE(v.is<int*>());
259     EXPECT_EQ(&a, std::get<int*>(v));
260     EXPECT_EQ(a, *std::get<int*>(v));
261   }
262 
263   {
264     using IntRef = std::reference_wrapper<int>;
265     Variant<IntRef> v;
266     int a = 10;
267 
268     v = a;
269     ASSERT_TRUE(v.is<IntRef>());
270     EXPECT_EQ(a, std::get<IntRef>(v));
271 
272     a = 20;
273     EXPECT_EQ(a, std::get<IntRef>(v));
274   }
275 }
276 
TEST(Variant,MoveAssignment)277 TEST(Variant, MoveAssignment) {
278   {
279     Variant<std::string> v;
280     std::string s = "test";
281     v = std::move(s);
282 
283     EXPECT_TRUE(s.empty());
284     ASSERT_TRUE(v.is<std::string>());
285     EXPECT_EQ("test", std::get<std::string>(v));
286   }
287 
288   {
289     Variant<std::string> v("test");
290     std::string s = "fizz";
291     s = std::move(std::get<std::string>(v));
292 
293     ASSERT_TRUE(v.is<std::string>());
294     EXPECT_TRUE(std::get<std::string>(v).empty());
295     EXPECT_EQ("test", s);
296   }
297 
298   {
299     Variant<std::string> a("test");
300     Variant<std::string> b;
301 
302     b = std::move(a);
303     ASSERT_TRUE(a.is<std::string>());
304     ASSERT_TRUE(b.is<std::string>());
305     EXPECT_TRUE(std::get<std::string>(a).empty());
306     EXPECT_EQ("test", std::get<std::string>(b));
307   }
308 
309   {
310     Variant<std::string> a("test");
311     Variant<std::string> b("fizz");
312 
313     b = std::move(a);
314     ASSERT_TRUE(a.is<std::string>());
315     ASSERT_TRUE(b.is<std::string>());
316     EXPECT_TRUE(std::get<std::string>(a).empty());
317     EXPECT_EQ("test", std::get<std::string>(b));
318   }
319 
320   {
321     Variant<int, std::string> a("test");
322     Variant<int, std::string> b(10);
323 
324     b = std::move(a);
325     ASSERT_TRUE(a.is<std::string>());
326     ASSERT_TRUE(b.is<std::string>());
327     EXPECT_TRUE(std::get<std::string>(a).empty());
328     EXPECT_EQ("test", std::get<std::string>(b));
329   }
330 
331   {
332     Variant<int, std::string> a(10);
333     Variant<int, std::string> b("test");
334 
335     b = std::move(a);
336     ASSERT_TRUE(a.is<int>());
337     ASSERT_TRUE(b.is<int>());
338     EXPECT_EQ(10, std::get<int>(a));
339     EXPECT_EQ(10, std::get<int>(b));
340   }
341 }
342 
TEST(Variant,Constructor)343 TEST(Variant, Constructor) {
344   {
345     Variant<int, bool, float> v(true);
346     EXPECT_TRUE(v.is<bool>());
347   }
348 
349   {
350     Variant<int, bool, float> v(10);
351     EXPECT_TRUE(v.is<int>());
352   }
353 
354   {
355     Variant<int, bool, float> v(10.1f);
356     EXPECT_TRUE(v.is<float>());
357   }
358 
359   {
360     Variant<float, std::string> v(10.);
361     EXPECT_TRUE(v.is<float>());
362   }
363 
364   {
365     TestType<int> i(1);
366     Variant<int, bool, float> v(i.take());
367     ASSERT_TRUE(v.is<int>());
368     EXPECT_EQ(1, std::get<int>(v));
369   }
370 
371   {
372     TestType<int> i(1);
373     Variant<int, bool, float> v(i.get());
374     ASSERT_TRUE(v.is<int>());
375     EXPECT_EQ(1, std::get<int>(v));
376   }
377 
378   {
379     TestType<bool> b(true);
380     Variant<int, bool, float> v(b.take());
381     ASSERT_TRUE(v.is<bool>());
382     EXPECT_EQ(true, std::get<bool>(v));
383   }
384 
385   {
386     TestType<bool> b(true);
387     Variant<int, bool, float> v(b.get());
388     ASSERT_TRUE(v.is<bool>());
389     EXPECT_EQ(true, std::get<bool>(v));
390   }
391 
392   {
393     Variant<const char*> c("test");
394     Variant<std::string> s(c);
395     ASSERT_TRUE(s.is<std::string>());
396     EXPECT_EQ("test", std::get<std::string>(s));
397   }
398 
399   {
400     Variant<int, bool, float> a(true);
401     Variant<int, bool, float> b(a);
402 
403     ASSERT_TRUE(b.is<bool>());
404   }
405 
406   {
407     using IntRef = std::reference_wrapper<int>;
408     int a = 10;
409     Variant<IntRef> v(a);
410     TestType<IntRef> t(a);
411 
412     ASSERT_TRUE(v.is<IntRef>());
413     EXPECT_EQ(a, std::get<IntRef>(v));
414     EXPECT_EQ(a, t.get());
415 
416     a = 20;
417     EXPECT_EQ(a, std::get<IntRef>(v));
418     EXPECT_EQ(a, t.get());
419   }
420 }
421 
422 // Verify correct ctor/dtor and assignment behavior used an instrumented type.
TEST(Variant,CopyMoveConstructAssign)423 TEST(Variant, CopyMoveConstructAssign) {
424   {
425     InstrumentType<int>::clear();
426 
427     // Default construct to empty, no InstrumentType activity.
428     Variant<int, InstrumentType<int>> v;
429     ASSERT_EQ(0u, InstrumentType<int>::constructor_count());
430     ASSERT_EQ(0u, InstrumentType<int>::destructor_count());
431     ASSERT_EQ(0u, InstrumentType<int>::move_assignment_count());
432     ASSERT_EQ(0u, InstrumentType<int>::copy_assignment_count());
433   }
434 
435   {
436     InstrumentType<int>::clear();
437 
438     // Construct from int type, no InstrumentType activity.
439     Variant<int, InstrumentType<int>> v;
440     v = 10;
441     EXPECT_EQ(0u, InstrumentType<int>::constructor_count());
442     EXPECT_EQ(0u, InstrumentType<int>::destructor_count());
443     EXPECT_EQ(0u, InstrumentType<int>::move_assignment_count());
444     EXPECT_EQ(0u, InstrumentType<int>::copy_assignment_count());
445   }
446 
447   {
448     InstrumentType<int>::clear();
449 
450     // Construct from int type, no InstrumentType activity.
451     Variant<int, InstrumentType<int>> v(10);
452     EXPECT_EQ(0u, InstrumentType<int>::constructor_count());
453     EXPECT_EQ(0u, InstrumentType<int>::destructor_count());
454     EXPECT_EQ(0u, InstrumentType<int>::move_assignment_count());
455     EXPECT_EQ(0u, InstrumentType<int>::copy_assignment_count());
456   }
457 
458   {
459     InstrumentType<int>::clear();
460 
461     // Construct from temporary, temporary ctor/dtor.
462     Variant<int, InstrumentType<int>> v;
463     v = InstrumentType<int>(25);
464     EXPECT_EQ(2u, InstrumentType<int>::constructor_count());
465     EXPECT_EQ(1u, InstrumentType<int>::destructor_count());
466     EXPECT_EQ(0u, InstrumentType<int>::move_assignment_count());
467     EXPECT_EQ(0u, InstrumentType<int>::copy_assignment_count());
468   }
469 
470   {
471     InstrumentType<int>::clear();
472 
473     // Construct from temporary, temporary ctor/dtor.
474     Variant<int, InstrumentType<int>> v(InstrumentType<int>(25));
475     EXPECT_EQ(2u, InstrumentType<int>::constructor_count());
476     EXPECT_EQ(1u, InstrumentType<int>::destructor_count());
477     EXPECT_EQ(0u, InstrumentType<int>::move_assignment_count());
478     EXPECT_EQ(0u, InstrumentType<int>::copy_assignment_count());
479   }
480 
481   {
482     InstrumentType<int>::clear();
483 
484     // Construct from temporary, temporary ctor/dtor.
485     Variant<int, InstrumentType<int>> v(InstrumentType<int>(25));
486 
487     // Assign from temporary, temporary ctor/dtor.
488     v = InstrumentType<int>(35);
489     EXPECT_EQ(3u, InstrumentType<int>::constructor_count());
490     EXPECT_EQ(2u, InstrumentType<int>::destructor_count());
491     EXPECT_EQ(1u, InstrumentType<int>::move_assignment_count());
492     EXPECT_EQ(0u, InstrumentType<int>::copy_assignment_count());
493   }
494 
495   {
496     InstrumentType<int>::clear();
497 
498     // Construct from temporary, temporary ctor/dtor.
499     Variant<int, InstrumentType<int>> v(InstrumentType<int>(25));
500 
501     // dtor.
502     v = 10;
503     EXPECT_EQ(2u, InstrumentType<int>::constructor_count());
504     EXPECT_EQ(2u, InstrumentType<int>::destructor_count());
505     EXPECT_EQ(0u, InstrumentType<int>::move_assignment_count());
506     EXPECT_EQ(0u, InstrumentType<int>::copy_assignment_count());
507   }
508 
509   {
510     InstrumentType<int>::clear();
511 
512     // Construct from temporary, temporary ctor/dtor.
513     Variant<int, InstrumentType<int>> v(InstrumentType<int>(25));
514 
515     EXPECT_EQ(2u, InstrumentType<int>::constructor_count());
516     EXPECT_EQ(1u, InstrumentType<int>::destructor_count());
517     EXPECT_EQ(0u, InstrumentType<int>::move_assignment_count());
518     EXPECT_EQ(0u, InstrumentType<int>::copy_assignment_count());
519   }
520   EXPECT_EQ(2u, InstrumentType<int>::constructor_count());
521   EXPECT_EQ(2u, InstrumentType<int>::destructor_count());
522   EXPECT_EQ(0u, InstrumentType<int>::move_assignment_count());
523   EXPECT_EQ(0u, InstrumentType<int>::copy_assignment_count());
524 
525   {
526     InstrumentType<int>::clear();
527 
528     // Construct from other temporary.
529     Variant<int, InstrumentType<int>> v(TestType<int>(10));
530     EXPECT_EQ(1u, InstrumentType<int>::constructor_count());
531     EXPECT_EQ(0u, InstrumentType<int>::destructor_count());
532     EXPECT_EQ(0u, InstrumentType<int>::move_assignment_count());
533     EXPECT_EQ(0u, InstrumentType<int>::copy_assignment_count());
534   }
535 
536   {
537     InstrumentType<int>::clear();
538 
539     // Construct from other temporary.
540     Variant<int, InstrumentType<int>> v(TestType<int>(10));
541     // Assign from other temporary.
542     v = TestType<int>(11);
543     EXPECT_EQ(1u, InstrumentType<int>::constructor_count());
544     EXPECT_EQ(0u, InstrumentType<int>::destructor_count());
545     EXPECT_EQ(1u, InstrumentType<int>::move_assignment_count());
546     EXPECT_EQ(0u, InstrumentType<int>::copy_assignment_count());
547   }
548 
549   {
550     InstrumentType<int>::clear();
551 
552     // Construct from other temporary.
553     Variant<int, InstrumentType<int>> v(TestType<int>(10));
554     // Assign from empty Variant.
555     v = Variant<int, InstrumentType<int>>();
556     EXPECT_EQ(1u, InstrumentType<int>::constructor_count());
557     EXPECT_EQ(1u, InstrumentType<int>::destructor_count());
558     EXPECT_EQ(0u, InstrumentType<int>::move_assignment_count());
559     EXPECT_EQ(0u, InstrumentType<int>::copy_assignment_count());
560   }
561 
562   {
563     InstrumentType<int>::clear();
564 
565     TestType<int> other(10);
566     // Construct from other.
567     Variant<int, InstrumentType<int>> v(other);
568 
569     EXPECT_EQ(1u, InstrumentType<int>::constructor_count());
570     EXPECT_EQ(0u, InstrumentType<int>::destructor_count());
571     EXPECT_EQ(0u, InstrumentType<int>::move_assignment_count());
572     EXPECT_EQ(0u, InstrumentType<int>::copy_assignment_count());
573   }
574 
575   {
576     InstrumentType<int>::clear();
577 
578     // Construct from other temporary.
579     Variant<int, InstrumentType<int>> v(TestType<int>(0));
580     TestType<int> other(10);
581     // Assign from other.
582     v = other;
583     EXPECT_EQ(1u, InstrumentType<int>::constructor_count());
584     EXPECT_EQ(0u, InstrumentType<int>::destructor_count());
585     EXPECT_EQ(0u, InstrumentType<int>::move_assignment_count());
586     EXPECT_EQ(1u, InstrumentType<int>::copy_assignment_count());
587   }
588 
589   {
590     InstrumentType<int>::clear();
591 
592     // Construct from temporary, temporary ctor/dtor.
593     Variant<int, InstrumentType<int>> v(InstrumentType<int>(25));
594 
595     // Assign EmptyVariant.
596     v = EmptyVariant{};
597 
598     EXPECT_EQ(2u, InstrumentType<int>::constructor_count());
599     EXPECT_EQ(2u, InstrumentType<int>::destructor_count());
600     EXPECT_EQ(0u, InstrumentType<int>::move_assignment_count());
601     EXPECT_EQ(0u, InstrumentType<int>::copy_assignment_count());
602   }
603   EXPECT_EQ(2u, InstrumentType<int>::constructor_count());
604   EXPECT_EQ(2u, InstrumentType<int>::destructor_count());
605   EXPECT_EQ(0u, InstrumentType<int>::move_assignment_count());
606   EXPECT_EQ(0u, InstrumentType<int>::copy_assignment_count());
607 }
608 
TEST(Variant,MoveConstructor)609 TEST(Variant, MoveConstructor) {
610   {
611     std::unique_ptr<int> pointer = std::make_unique<int>(10);
612     Variant<std::unique_ptr<int>> v(std::move(pointer));
613     ASSERT_TRUE(v.is<std::unique_ptr<int>>());
614     EXPECT_TRUE(std::get<std::unique_ptr<int>>(v) != nullptr);
615     EXPECT_TRUE(pointer == nullptr);
616   }
617 
618   {
619     Variant<std::unique_ptr<int>> a(std::make_unique<int>(10));
620     Variant<std::unique_ptr<int>> b(std::move(a));
621 
622     ASSERT_TRUE(a.is<std::unique_ptr<int>>());
623     ASSERT_TRUE(b.is<std::unique_ptr<int>>());
624     EXPECT_TRUE(std::get<std::unique_ptr<int>>(a) == nullptr);
625     EXPECT_TRUE(std::get<std::unique_ptr<int>>(b) != nullptr);
626   }
627 }
628 
TEST(Variant,IndexOf)629 TEST(Variant, IndexOf) {
630   Variant<int, bool, float> v1;
631 
632   EXPECT_EQ(0, v1.index_of<int>());
633   EXPECT_EQ(1, v1.index_of<bool>());
634   EXPECT_EQ(2, v1.index_of<float>());
635 
636   Variant<int, bool, float, int> v2;
637 
638   EXPECT_EQ(0, v2.index_of<int>());
639   EXPECT_EQ(1, v2.index_of<bool>());
640   EXPECT_EQ(2, v2.index_of<float>());
641 }
642 
643 struct Visitor {
644   int int_value = 0;
645   bool bool_value = false;
646   float float_value = 0.0;
647   bool empty_value = false;
648 
VisitVisitor649   void Visit(int value) { int_value = value; }
VisitVisitor650   void Visit(bool value) { bool_value = value; }
VisitVisitor651   void Visit(float value) { float_value = value; }
VisitVisitor652   void Visit(EmptyVariant) { empty_value = true; }
653 };
654 
TEST(Variant,Visit)655 TEST(Variant, Visit) {
656   {
657     Variant<int, bool, float> v(10);
658     EXPECT_TRUE(v.is<int>());
659 
660     Visitor visitor;
661     v.Visit([&visitor](const auto& value) { visitor.Visit(value); });
662     EXPECT_EQ(10, visitor.int_value);
663 
664     visitor = {};
665     v = true;
666     v.Visit([&visitor](const auto& value) { visitor.Visit(value); });
667     EXPECT_EQ(true, visitor.bool_value);
668   }
669 
670   {
671     Variant<int, bool, float> v;
672     EXPECT_EQ(-1, v.index());
673 
674     Visitor visitor;
675     v.Visit([&visitor](const auto& value) { visitor.Visit(value); });
676     EXPECT_TRUE(visitor.empty_value);
677   }
678 
679   {
680     Variant<std::string> v("test");
681     ASSERT_TRUE(v.is<std::string>());
682     EXPECT_FALSE(std::get<std::string>(v).empty());
683 
684     v.Visit([](auto&& value) {
685       std::remove_reference_t<decltype(value)> empty;
686       std::swap(empty, value);
687     });
688     ASSERT_TRUE(v.is<std::string>());
689     EXPECT_TRUE(std::get<std::string>(v).empty());
690   }
691 }
692 
TEST(Variant,Become)693 TEST(Variant, Become) {
694   {
695     Variant<int, bool, float> v;
696 
697     v.Become(0);
698     EXPECT_TRUE(v.is<int>());
699 
700     v.Become(1);
701     EXPECT_TRUE(v.is<bool>());
702 
703     v.Become(2);
704     EXPECT_TRUE(v.is<float>());
705 
706     v.Become(3);
707     EXPECT_TRUE(v.empty());
708 
709     v.Become(-1);
710     EXPECT_TRUE(v.empty());
711 
712     v.Become(-2);
713     EXPECT_TRUE(v.empty());
714   }
715 
716   {
717     Variant<int, bool, float> v;
718 
719     v.Become(0, 10);
720     ASSERT_TRUE(v.is<int>());
721     EXPECT_EQ(10, std::get<int>(v));
722 
723     v.Become(1, true);
724     ASSERT_TRUE(v.is<bool>());
725     EXPECT_EQ(true, std::get<bool>(v));
726 
727     v.Become(2, 2.0f);
728     ASSERT_TRUE(v.is<float>());
729     EXPECT_FLOAT_EQ(2.0f, std::get<float>(v));
730 
731     v.Become(3, 10);
732     EXPECT_TRUE(v.empty());
733 
734     v.Become(-1, 10);
735     EXPECT_TRUE(v.empty());
736 
737     v.Become(-2, 20);
738     EXPECT_TRUE(v.empty());
739   }
740 
741   {
742     Variant<std::string> v;
743 
744     v.Become(0);
745     ASSERT_TRUE(v.is<std::string>());
746     EXPECT_TRUE(std::get<std::string>(v).empty());
747   }
748 
749   {
750     Variant<std::string> v;
751 
752     v.Become(0, "test");
753     ASSERT_TRUE(v.is<std::string>());
754     EXPECT_EQ("test", std::get<std::string>(v));
755   }
756 
757   {
758     Variant<std::string> v("foo");
759 
760     v.Become(0, "bar");
761     ASSERT_TRUE(v.is<std::string>());
762     EXPECT_EQ("foo", std::get<std::string>(v));
763   }
764 }
765 
TEST(Variant,Swap)766 TEST(Variant, Swap) {
767   {
768     Variant<std::string> a;
769     Variant<std::string> b;
770 
771     std::swap(a, b);
772     EXPECT_TRUE(a.empty());
773     EXPECT_TRUE(b.empty());
774   }
775 
776   {
777     Variant<std::string> a("1");
778     Variant<std::string> b;
779 
780     std::swap(a, b);
781     EXPECT_TRUE(a.empty());
782     EXPECT_TRUE(!b.empty());
783     ASSERT_TRUE(b.is<std::string>());
784     EXPECT_EQ("1", std::get<std::string>(b));
785   }
786 
787   {
788     Variant<std::string> a;
789     Variant<std::string> b("1");
790 
791     std::swap(a, b);
792     EXPECT_TRUE(!a.empty());
793     EXPECT_TRUE(b.empty());
794     ASSERT_TRUE(a.is<std::string>());
795     EXPECT_EQ("1", std::get<std::string>(a));
796   }
797 
798   {
799     Variant<std::string> a("1");
800     Variant<std::string> b("2");
801 
802     std::swap(a, b);
803     ASSERT_TRUE(a.is<std::string>());
804     ASSERT_TRUE(b.is<std::string>());
805     EXPECT_EQ("2", std::get<std::string>(a));
806     EXPECT_EQ("1", std::get<std::string>(b));
807   }
808 
809   {
810     Variant<int, std::string> a(10);
811     Variant<int, std::string> b("1");
812 
813     std::swap(a, b);
814     ASSERT_TRUE(a.is<std::string>());
815     ASSERT_TRUE(b.is<int>());
816     EXPECT_EQ("1", std::get<std::string>(a));
817     EXPECT_EQ(10, std::get<int>(b));
818   }
819 
820   {
821     Variant<int, std::string> a("1");
822     Variant<int, std::string> b(10);
823 
824     std::swap(a, b);
825     ASSERT_TRUE(a.is<int>());
826     ASSERT_TRUE(b.is<std::string>());
827     EXPECT_EQ(10, std::get<int>(a));
828     EXPECT_EQ("1", std::get<std::string>(b));
829   }
830 }
831 
TEST(Variant,Get)832 TEST(Variant, Get) {
833   {
834     Variant<int, bool, float, int> v;
835 
836     EXPECT_EQ(nullptr, &std::get<int>(v));
837     EXPECT_EQ(nullptr, &std::get<bool>(v));
838     EXPECT_EQ(nullptr, &std::get<float>(v));
839     EXPECT_EQ(nullptr, &std::get<0>(v));
840     EXPECT_EQ(nullptr, &std::get<1>(v));
841     EXPECT_EQ(nullptr, &std::get<2>(v));
842     EXPECT_EQ(nullptr, &std::get<3>(v));
843   }
844 
845   {
846     Variant<int, bool, float, int> v;
847     v = 9;
848     ASSERT_TRUE(v.is<int>())
849         << "Expected type " << v.index_of<int>() << " got type " << v.index();
850     EXPECT_EQ(9, std::get<int>(v));
851     EXPECT_EQ(9, std::get<0>(v));
852 
853     std::get<int>(v) = 10;
854     EXPECT_EQ(10, std::get<int>(v));
855     EXPECT_EQ(10, std::get<0>(v));
856 
857     std::get<0>(v) = 11;
858     EXPECT_EQ(11, std::get<int>(v));
859     EXPECT_EQ(11, std::get<0>(v));
860 
861     std::get<3>(v) = 12;
862     EXPECT_EQ(12, std::get<int>(v));
863     EXPECT_EQ(12, std::get<3>(v));
864   }
865 
866   {
867     Variant<int, bool, float, int> v;
868     v = false;
869     ASSERT_TRUE(v.is<bool>())
870         << "Expected type " << v.index_of<bool>() << " got type " << v.index();
871     EXPECT_EQ(false, std::get<bool>(v));
872     EXPECT_EQ(false, std::get<1>(v));
873 
874     std::get<bool>(v) = true;
875     EXPECT_EQ(true, std::get<bool>(v));
876     EXPECT_EQ(true, std::get<1>(v));
877 
878     std::get<bool>(v) = false;
879     EXPECT_EQ(false, std::get<bool>(v));
880     EXPECT_EQ(false, std::get<1>(v));
881 
882     std::get<1>(v) = true;
883     EXPECT_EQ(true, std::get<bool>(v));
884     EXPECT_EQ(true, std::get<1>(v));
885 
886     std::get<1>(v) = false;
887     EXPECT_EQ(false, std::get<bool>(v));
888     EXPECT_EQ(false, std::get<1>(v));
889   }
890 
891   {
892     Variant<int, bool, float, int> v;
893     v = 1.0f;
894     ASSERT_TRUE(v.is<float>())
895         << "Expected type " << v.index_of<float>() << " got type " << v.index();
896     EXPECT_EQ(2, v.index());
897     EXPECT_FLOAT_EQ(1.0, std::get<float>(v));
898     EXPECT_FLOAT_EQ(1.0, std::get<2>(v));
899 
900     std::get<float>(v) = 1.1;
901     EXPECT_FLOAT_EQ(1.1, std::get<float>(v));
902     EXPECT_FLOAT_EQ(1.1, std::get<2>(v));
903 
904     std::get<float>(v) = -3.0;
905     EXPECT_FLOAT_EQ(-3.0, std::get<float>(v));
906     EXPECT_FLOAT_EQ(-3.0, std::get<2>(v));
907 
908     std::get<2>(v) = 1.1;
909     EXPECT_FLOAT_EQ(1.1, std::get<float>(v));
910     EXPECT_FLOAT_EQ(1.1, std::get<2>(v));
911 
912     std::get<2>(v) = -3.0;
913     EXPECT_FLOAT_EQ(-3.0, std::get<float>(v));
914     EXPECT_FLOAT_EQ(-3.0, std::get<2>(v));
915   }
916 
917   {
918     Variant<std::unique_ptr<int>> v(std::make_unique<int>(10));
919     std::unique_ptr<int> pointer = std::move(std::get<std::unique_ptr<int>>(v));
920     ASSERT_FALSE(v.empty());
921     EXPECT_TRUE(pointer != nullptr);
922     EXPECT_TRUE(std::get<std::unique_ptr<int>>(v) == nullptr);
923   }
924 
925   {
926     Variant<std::string> v("test");
927     std::string s = std::get<std::string>(std::move(v));
928     EXPECT_EQ("test", s);
929   }
930 }
931 
TEST(Variant,IfAnyOf)932 TEST(Variant, IfAnyOf) {
933   {
934     Variant<int, float> v(10);
935     ASSERT_TRUE(v.is<int>());
936 
937     bool b = false;
938     EXPECT_TRUE(IfAnyOf<int>::Get(&v, &b));
939     EXPECT_TRUE(b);
940 
941     float f = 0.0f;
942     EXPECT_TRUE((IfAnyOf<int, float>::Get(&v, &f)));
943     EXPECT_FLOAT_EQ(10.f, f);
944   }
945 
946   {
947     const Variant<int, float> v(10);
948     ASSERT_TRUE(v.is<int>());
949 
950     bool b = false;
951     EXPECT_TRUE(IfAnyOf<int>::Get(&v, &b));
952     EXPECT_TRUE(b);
953 
954     float f = 0.0f;
955     EXPECT_TRUE((IfAnyOf<int, float>::Get(&v, &f)));
956     EXPECT_FLOAT_EQ(10.f, f);
957   }
958 
959   {
960     Variant<int, float> v(10);
961     ASSERT_TRUE(v.is<int>());
962 
963     bool b = false;
964     EXPECT_TRUE(IfAnyOf<int>::Call(&v, [&b](const auto& value) { b = value; }));
965     EXPECT_TRUE(b);
966 
967     float f = 0.0f;
968     EXPECT_TRUE((
969         IfAnyOf<int, float>::Call(&v, [&f](const auto& value) { f = value; })));
970     EXPECT_FLOAT_EQ(10.f, f);
971   }
972 
973   {
974     Variant<std::unique_ptr<int>, int> v(std::make_unique<int>(10));
975     ASSERT_TRUE(v.is<std::unique_ptr<int>>());
976     const int* original_v = std::get<std::unique_ptr<int>>(v).get();
977 
978     std::unique_ptr<int> u(std::make_unique<int>(20));
979 
980     EXPECT_TRUE(IfAnyOf<std::unique_ptr<int>>::Take(&v, &u));
981     ASSERT_TRUE(v.is<std::unique_ptr<int>>());
982     EXPECT_TRUE(std::get<std::unique_ptr<int>>(v) == nullptr);
983     EXPECT_EQ(u.get(), original_v);
984   }
985 
986   {
987     Variant<std::unique_ptr<DerivedType>, int> v(
988         std::make_unique<DerivedType>(10));
989     ASSERT_TRUE(v.is<std::unique_ptr<DerivedType>>());
990     const DerivedType* original_v =
991         std::get<std::unique_ptr<DerivedType>>(v).get();
992 
993     std::unique_ptr<BaseType> u(std::make_unique<BaseType>(20));
994 
995     EXPECT_TRUE(IfAnyOf<std::unique_ptr<DerivedType>>::Take(&v, &u));
996     ASSERT_TRUE(v.is<std::unique_ptr<DerivedType>>());
997     EXPECT_TRUE(std::get<std::unique_ptr<DerivedType>>(v) == nullptr);
998     EXPECT_EQ(u.get(), original_v);
999   }
1000 
1001   {
1002     Variant<std::unique_ptr<int>, int> v(std::make_unique<int>(10));
1003     ASSERT_TRUE(v.is<std::unique_ptr<int>>());
1004     const int* original_v = std::get<std::unique_ptr<int>>(v).get();
1005 
1006     std::unique_ptr<int> u(std::make_unique<int>(20));
1007 
1008     EXPECT_TRUE(IfAnyOf<std::unique_ptr<int>>::Call(
1009         &v, [&u](auto&& value) { u = std::move(value); }));
1010     ASSERT_TRUE(v.is<std::unique_ptr<int>>());
1011     EXPECT_TRUE(std::get<std::unique_ptr<int>>(v) == nullptr);
1012     EXPECT_EQ(u.get(), original_v);
1013   }
1014 
1015   {
1016     Variant<int, bool, float> v(true);
1017     ASSERT_TRUE(v.is<bool>());
1018 
1019     float f = 0.f;
1020     EXPECT_FALSE((IfAnyOf<int, float>::Get(&v, &f)));
1021     EXPECT_FLOAT_EQ(0.f, f);
1022   }
1023 
1024   {
1025     Variant<std::string, int> v("foo");
1026     ASSERT_TRUE(v.is<std::string>());
1027 
1028     std::string s = "bar";
1029     EXPECT_TRUE(IfAnyOf<std::string>::Swap(&v, &s));
1030     ASSERT_TRUE(v.is<std::string>());
1031     EXPECT_EQ("bar", std::get<std::string>(v));
1032     EXPECT_EQ("foo", s);
1033   }
1034 
1035   {
1036     Variant<std::string, const char*> v(static_cast<const char*>("foo"));
1037     ASSERT_TRUE(v.is<const char*>());
1038 
1039     std::string s = "bar";
1040     EXPECT_TRUE((IfAnyOf<std::string, const char*>::Take(&v, &s)));
1041     ASSERT_TRUE(v.is<const char*>());
1042     EXPECT_EQ("foo", std::get<const char*>(v));
1043     EXPECT_EQ("foo", s);
1044 
1045     v = std::string("bar");
1046     ASSERT_TRUE(v.is<std::string>());
1047 
1048     EXPECT_TRUE((IfAnyOf<std::string, const char*>::Take(&v, &s)));
1049     ASSERT_TRUE(v.is<std::string>());
1050     EXPECT_EQ("bar", s);
1051   }
1052 
1053   {
1054     Variant<std::string, const char*> v;
1055     ASSERT_TRUE(v.empty());
1056 
1057     std::string s = "bar";
1058     EXPECT_FALSE((IfAnyOf<std::string, const char*>::Take(&v, &s)));
1059     EXPECT_EQ("bar", s);
1060   }
1061 
1062   {
1063     Variant<std::string, const char*> v(static_cast<const char*>("test"));
1064     ASSERT_TRUE(v.is<const char*>());
1065 
1066     std::string s;
1067     EXPECT_FALSE(IfAnyOf<>::Take(&v, &s));
1068     EXPECT_TRUE(s.empty());
1069   }
1070 }
1071 
TEST(Variant,ConstVolatile)1072 TEST(Variant, ConstVolatile) {
1073   {
1074     Variant<const int> v(10);
1075     ASSERT_TRUE(v.is<const int>());
1076     EXPECT_EQ(10, std::get<const int>(v));
1077   }
1078 
1079   {
1080     Variant<const std::string> v("test");
1081     ASSERT_TRUE(v.is<const std::string>());
1082     EXPECT_EQ("test", std::get<const std::string>(v));
1083   }
1084 
1085   {
1086     Variant<volatile int, std::string> v(10);
1087     ASSERT_TRUE(v.is<volatile int>());
1088     EXPECT_EQ(10, std::get<volatile int>(v));
1089   }
1090 }
1091 
TEST(Variant,HasType)1092 TEST(Variant, HasType) {
1093   EXPECT_TRUE((detail::HasType<int, int, float, bool>::value));
1094   EXPECT_FALSE((detail::HasType<char, int, float, bool>::value));
1095   EXPECT_FALSE(detail::HasType<>::value);
1096 
1097   EXPECT_TRUE((detail::HasType<int&, int, float, bool>::value));
1098   EXPECT_FALSE((detail::HasType<char&, int, float, bool>::value));
1099 }
1100 
TEST(Variant,IsConstructible)1101 TEST(Variant, IsConstructible) {
1102   using ArrayType = const float[3];
1103   struct ImplicitBool {
1104     operator bool() const { return true; }
1105   };
1106   struct ExplicitBool {
1107     explicit operator bool() const { return true; }
1108   };
1109   struct NonBool {};
1110   struct TwoArgs {
1111     TwoArgs(int, bool) {}
1112   };
1113 
1114   EXPECT_FALSE((detail::IsConstructible<bool, ArrayType>::value));
1115   EXPECT_TRUE((detail::IsConstructible<bool, int>::value));
1116   EXPECT_TRUE((detail::IsConstructible<bool, ImplicitBool>::value));
1117   EXPECT_TRUE((detail::IsConstructible<bool, ExplicitBool>::value));
1118   EXPECT_FALSE((detail::IsConstructible<bool, NonBool>::value));
1119   EXPECT_TRUE((detail::IsConstructible<TwoArgs, int, bool>::value));
1120   EXPECT_FALSE((detail::IsConstructible<TwoArgs, int, std::string>::value));
1121   EXPECT_FALSE((detail::IsConstructible<TwoArgs, int>::value));
1122 }
1123 
TEST(Variant,Set)1124 TEST(Variant, Set) {
1125   EXPECT_TRUE((detail::Set<int, bool, float>::template IsSubset<int, bool,
1126                                                                 float>::value));
1127   EXPECT_TRUE(
1128       (detail::Set<int, bool, float>::template IsSubset<bool, float>::value));
1129   EXPECT_TRUE((detail::Set<int, bool, float>::template IsSubset<float>::value));
1130   EXPECT_TRUE((detail::Set<int, bool, float>::template IsSubset<>::value));
1131 
1132   EXPECT_FALSE(
1133       (detail::Set<int, bool, float>::template IsSubset<int, bool, float,
1134                                                         char>::value));
1135   EXPECT_FALSE((detail::Set<int, bool, float>::template IsSubset<bool, float,
1136                                                                  char>::value));
1137   EXPECT_FALSE(
1138       (detail::Set<int, bool, float>::template IsSubset<float, char>::value));
1139   EXPECT_FALSE((detail::Set<int, bool, float>::template IsSubset<char>::value));
1140 
1141   EXPECT_TRUE(detail::Set<>::template IsSubset<>::value);
1142   EXPECT_FALSE(detail::Set<>::template IsSubset<int>::value);
1143   EXPECT_FALSE((detail::Set<>::template IsSubset<int, float>::value));
1144 }
1145