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