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