1// Copyright 2016 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "base/optional.h" 6 7#include <set> 8 9#include "testing/gtest/include/gtest/gtest.h" 10 11namespace base { 12 13namespace { 14 15// Object used to test complex object with Optional<T> in addition of the move 16// semantics. 17class TestObject { 18 public: 19 enum class State { 20 DEFAULT_CONSTRUCTED, 21 VALUE_CONSTRUCTED, 22 COPY_CONSTRUCTED, 23 MOVE_CONSTRUCTED, 24 MOVED_FROM, 25 COPY_ASSIGNED, 26 MOVE_ASSIGNED, 27 SWAPPED, 28 }; 29 30 TestObject() : foo_(0), bar_(0.0), state_(State::DEFAULT_CONSTRUCTED) {} 31 32 TestObject(int foo, double bar) 33 : foo_(foo), bar_(bar), state_(State::VALUE_CONSTRUCTED) {} 34 35 TestObject(const TestObject& other) 36 : foo_(other.foo_), bar_(other.bar_), state_(State::COPY_CONSTRUCTED) {} 37 38 TestObject(TestObject&& other) 39 : foo_(std::move(other.foo_)), 40 bar_(std::move(other.bar_)), 41 state_(State::MOVE_CONSTRUCTED) { 42 other.state_ = State::MOVED_FROM; 43 } 44 45 TestObject& operator=(const TestObject& other) { 46 foo_ = other.foo_; 47 bar_ = other.bar_; 48 state_ = State::COPY_ASSIGNED; 49 return *this; 50 } 51 52 TestObject& operator=(TestObject&& other) { 53 foo_ = other.foo_; 54 bar_ = other.bar_; 55 state_ = State::MOVE_ASSIGNED; 56 other.state_ = State::MOVED_FROM; 57 return *this; 58 } 59 60 void Swap(TestObject* other) { 61 using std::swap; 62 swap(foo_, other->foo_); 63 swap(bar_, other->bar_); 64 state_ = State::SWAPPED; 65 other->state_ = State::SWAPPED; 66 } 67 68 bool operator==(const TestObject& other) const { 69 return foo_ == other.foo_ && bar_ == other.bar_; 70 } 71 72 int foo() const { return foo_; } 73 State state() const { return state_; } 74 75 private: 76 int foo_; 77 double bar_; 78 State state_; 79}; 80 81// Implementing Swappable concept. 82void swap(TestObject& lhs, TestObject& rhs) { 83 lhs.Swap(&rhs); 84} 85 86class NonTriviallyDestructible { 87 ~NonTriviallyDestructible() {} 88}; 89 90} // anonymous namespace 91 92static_assert(is_trivially_destructible<Optional<int>>::value, 93 "OptionalIsTriviallyDestructible"); 94 95static_assert( 96 !is_trivially_destructible<Optional<NonTriviallyDestructible>>::value, 97 "OptionalIsTriviallyDestructible"); 98 99TEST(OptionalTest, DefaultConstructor) { 100 { 101 Optional<float> o; 102 EXPECT_FALSE(o); 103 } 104 105 { 106 Optional<std::string> o; 107 EXPECT_FALSE(o); 108 } 109 110 { 111 Optional<TestObject> o; 112 EXPECT_FALSE(o); 113 } 114} 115 116TEST(OptionalTest, CopyConstructor) { 117 { 118 Optional<float> first(0.1f); 119 Optional<float> other(first); 120 121 EXPECT_TRUE(other); 122 EXPECT_EQ(other.value(), 0.1f); 123 EXPECT_EQ(first, other); 124 } 125 126 { 127 Optional<std::string> first("foo"); 128 Optional<std::string> other(first); 129 130 EXPECT_TRUE(other); 131 EXPECT_EQ(other.value(), "foo"); 132 EXPECT_EQ(first, other); 133 } 134 135 { 136 Optional<TestObject> first(TestObject(3, 0.1)); 137 Optional<TestObject> other(first); 138 139 EXPECT_TRUE(!!other); 140 EXPECT_TRUE(other.value() == TestObject(3, 0.1)); 141 EXPECT_TRUE(first == other); 142 } 143} 144 145TEST(OptionalTest, ValueConstructor) { 146 { 147 Optional<float> o(0.1f); 148 EXPECT_TRUE(o); 149 EXPECT_EQ(o.value(), 0.1f); 150 } 151 152 { 153 Optional<std::string> o("foo"); 154 EXPECT_TRUE(o); 155 EXPECT_EQ(o.value(), "foo"); 156 } 157 158 { 159 Optional<TestObject> o(TestObject(3, 0.1)); 160 EXPECT_TRUE(!!o); 161 EXPECT_TRUE(o.value() == TestObject(3, 0.1)); 162 } 163} 164 165TEST(OptionalTest, MoveConstructor) { 166 { 167 Optional<float> first(0.1f); 168 Optional<float> second(std::move(first)); 169 170 EXPECT_TRUE(second); 171 EXPECT_EQ(second.value(), 0.1f); 172 173 EXPECT_TRUE(first); 174 } 175 176 { 177 Optional<std::string> first("foo"); 178 Optional<std::string> second(std::move(first)); 179 180 EXPECT_TRUE(second); 181 EXPECT_EQ("foo", second.value()); 182 183 EXPECT_TRUE(first); 184 } 185 186 { 187 Optional<TestObject> first(TestObject(3, 0.1)); 188 Optional<TestObject> second(std::move(first)); 189 190 EXPECT_TRUE(!!second); 191 EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, second->state()); 192 EXPECT_TRUE(TestObject(3, 0.1) == second.value()); 193 194 EXPECT_TRUE(!!first); 195 EXPECT_EQ(TestObject::State::MOVED_FROM, first->state()); 196 } 197} 198 199TEST(OptionalTest, MoveValueConstructor) { 200 { 201 Optional<float> first(0.1f); 202 Optional<float> second(std::move(first.value())); 203 204 EXPECT_TRUE(second); 205 EXPECT_EQ(second.value(), 0.1f); 206 207 EXPECT_TRUE(first); 208 } 209 210 { 211 Optional<std::string> first("foo"); 212 Optional<std::string> second(std::move(first.value())); 213 214 EXPECT_TRUE(second); 215 EXPECT_EQ("foo", second.value()); 216 217 EXPECT_TRUE(first); 218 } 219 220 { 221 Optional<TestObject> first(TestObject(3, 0.1)); 222 Optional<TestObject> second(std::move(first.value())); 223 224 EXPECT_TRUE(!!second); 225 EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, second->state()); 226 EXPECT_TRUE(TestObject(3, 0.1) == second.value()); 227 228 EXPECT_TRUE(!!first); 229 EXPECT_EQ(TestObject::State::MOVED_FROM, first->state()); 230 } 231} 232 233TEST(OptionalTest, ConstructorForwardArguments) { 234 { 235 Optional<float> a(base::in_place, 0.1f); 236 EXPECT_TRUE(a); 237 EXPECT_EQ(0.1f, a.value()); 238 } 239 240 { 241 Optional<std::string> a(base::in_place, "foo"); 242 EXPECT_TRUE(a); 243 EXPECT_EQ("foo", a.value()); 244 } 245 246 { 247 Optional<TestObject> a(base::in_place, 0, 0.1); 248 EXPECT_TRUE(!!a); 249 EXPECT_TRUE(TestObject(0, 0.1) == a.value()); 250 } 251} 252 253TEST(OptionalTest, NulloptConstructor) { 254 Optional<int> a = base::nullopt; 255 EXPECT_FALSE(a); 256} 257 258TEST(OptionalTest, AssignValue) { 259 { 260 Optional<float> a; 261 EXPECT_FALSE(a); 262 a = 0.1f; 263 EXPECT_TRUE(a); 264 265 Optional<float> b(0.1f); 266 EXPECT_TRUE(a == b); 267 } 268 269 { 270 Optional<std::string> a; 271 EXPECT_FALSE(a); 272 a = std::string("foo"); 273 EXPECT_TRUE(a); 274 275 Optional<std::string> b(std::string("foo")); 276 EXPECT_EQ(a, b); 277 } 278 279 { 280 Optional<TestObject> a; 281 EXPECT_FALSE(!!a); 282 a = TestObject(3, 0.1); 283 EXPECT_TRUE(!!a); 284 285 Optional<TestObject> b(TestObject(3, 0.1)); 286 EXPECT_TRUE(a == b); 287 } 288 289 { 290 Optional<TestObject> a = TestObject(4, 1.0); 291 EXPECT_TRUE(!!a); 292 a = TestObject(3, 0.1); 293 EXPECT_TRUE(!!a); 294 295 Optional<TestObject> b(TestObject(3, 0.1)); 296 EXPECT_TRUE(a == b); 297 } 298} 299 300TEST(OptionalTest, AssignObject) { 301 { 302 Optional<float> a; 303 Optional<float> b(0.1f); 304 a = b; 305 306 EXPECT_TRUE(a); 307 EXPECT_EQ(a.value(), 0.1f); 308 EXPECT_EQ(a, b); 309 } 310 311 { 312 Optional<std::string> a; 313 Optional<std::string> b("foo"); 314 a = b; 315 316 EXPECT_TRUE(a); 317 EXPECT_EQ(a.value(), "foo"); 318 EXPECT_EQ(a, b); 319 } 320 321 { 322 Optional<TestObject> a; 323 Optional<TestObject> b(TestObject(3, 0.1)); 324 a = b; 325 326 EXPECT_TRUE(!!a); 327 EXPECT_TRUE(a.value() == TestObject(3, 0.1)); 328 EXPECT_TRUE(a == b); 329 } 330 331 { 332 Optional<TestObject> a(TestObject(4, 1.0)); 333 Optional<TestObject> b(TestObject(3, 0.1)); 334 a = b; 335 336 EXPECT_TRUE(!!a); 337 EXPECT_TRUE(a.value() == TestObject(3, 0.1)); 338 EXPECT_TRUE(a == b); 339 } 340} 341 342TEST(OptionalTest, AssignObject_rvalue) { 343 { 344 Optional<float> a; 345 Optional<float> b(0.1f); 346 a = std::move(b); 347 348 EXPECT_TRUE(a); 349 EXPECT_TRUE(b); 350 EXPECT_EQ(0.1f, a.value()); 351 } 352 353 { 354 Optional<std::string> a; 355 Optional<std::string> b("foo"); 356 a = std::move(b); 357 358 EXPECT_TRUE(a); 359 EXPECT_TRUE(b); 360 EXPECT_EQ("foo", a.value()); 361 } 362 363 { 364 Optional<TestObject> a; 365 Optional<TestObject> b(TestObject(3, 0.1)); 366 a = std::move(b); 367 368 EXPECT_TRUE(!!a); 369 EXPECT_TRUE(!!b); 370 EXPECT_TRUE(TestObject(3, 0.1) == a.value()); 371 372 EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, a->state()); 373 EXPECT_EQ(TestObject::State::MOVED_FROM, b->state()); 374 } 375 376 { 377 Optional<TestObject> a(TestObject(4, 1.0)); 378 Optional<TestObject> b(TestObject(3, 0.1)); 379 a = std::move(b); 380 381 EXPECT_TRUE(!!a); 382 EXPECT_TRUE(!!b); 383 EXPECT_TRUE(TestObject(3, 0.1) == a.value()); 384 385 EXPECT_EQ(TestObject::State::MOVE_ASSIGNED, a->state()); 386 EXPECT_EQ(TestObject::State::MOVED_FROM, b->state()); 387 } 388} 389 390TEST(OptionalTest, AssignNull) { 391 { 392 Optional<float> a(0.1f); 393 Optional<float> b(0.2f); 394 a = base::nullopt; 395 b = base::nullopt; 396 EXPECT_EQ(a, b); 397 } 398 399 { 400 Optional<std::string> a("foo"); 401 Optional<std::string> b("bar"); 402 a = base::nullopt; 403 b = base::nullopt; 404 EXPECT_EQ(a, b); 405 } 406 407 { 408 Optional<TestObject> a(TestObject(3, 0.1)); 409 Optional<TestObject> b(TestObject(4, 1.0)); 410 a = base::nullopt; 411 b = base::nullopt; 412 EXPECT_TRUE(a == b); 413 } 414} 415 416TEST(OptionalTest, OperatorStar) { 417 { 418 Optional<float> a(0.1f); 419 EXPECT_EQ(a.value(), *a); 420 } 421 422 { 423 Optional<std::string> a("foo"); 424 EXPECT_EQ(a.value(), *a); 425 } 426 427 { 428 Optional<TestObject> a(TestObject(3, 0.1)); 429 EXPECT_EQ(a.value(), *a); 430 } 431} 432 433TEST(OptionalTest, OperatorStar_rvalue) { 434 EXPECT_EQ(0.1f, *Optional<float>(0.1f)); 435 EXPECT_EQ(std::string("foo"), *Optional<std::string>("foo")); 436 EXPECT_TRUE(TestObject(3, 0.1) == *Optional<TestObject>(TestObject(3, 0.1))); 437} 438 439TEST(OptionalTest, OperatorArrow) { 440 Optional<TestObject> a(TestObject(3, 0.1)); 441 EXPECT_EQ(a->foo(), 3); 442} 443 444TEST(OptionalTest, Value_rvalue) { 445 EXPECT_EQ(0.1f, Optional<float>(0.1f).value()); 446 EXPECT_EQ(std::string("foo"), Optional<std::string>("foo").value()); 447 EXPECT_TRUE(TestObject(3, 0.1) == 448 Optional<TestObject>(TestObject(3, 0.1)).value()); 449} 450 451TEST(OptionalTest, ValueOr) { 452 { 453 Optional<float> a; 454 EXPECT_EQ(0.0f, a.value_or(0.0f)); 455 456 a = 0.1f; 457 EXPECT_EQ(0.1f, a.value_or(0.0f)); 458 459 a = base::nullopt; 460 EXPECT_EQ(0.0f, a.value_or(0.0f)); 461 } 462 463 { 464 Optional<std::string> a; 465 EXPECT_EQ("bar", a.value_or("bar")); 466 467 a = std::string("foo"); 468 EXPECT_EQ(std::string("foo"), a.value_or("bar")); 469 470 a = base::nullopt; 471 EXPECT_EQ(std::string("bar"), a.value_or("bar")); 472 } 473 474 { 475 Optional<TestObject> a; 476 EXPECT_TRUE(a.value_or(TestObject(1, 0.3)) == TestObject(1, 0.3)); 477 478 a = TestObject(3, 0.1); 479 EXPECT_TRUE(a.value_or(TestObject(1, 0.3)) == TestObject(3, 0.1)); 480 481 a = base::nullopt; 482 EXPECT_TRUE(a.value_or(TestObject(1, 0.3)) == TestObject(1, 0.3)); 483 } 484} 485 486TEST(OptionalTest, Swap_bothNoValue) { 487 Optional<TestObject> a, b; 488 a.swap(b); 489 490 EXPECT_FALSE(a); 491 EXPECT_FALSE(b); 492 EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42))); 493 EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42))); 494} 495 496TEST(OptionalTest, Swap_inHasValue) { 497 Optional<TestObject> a(TestObject(1, 0.3)); 498 Optional<TestObject> b; 499 a.swap(b); 500 501 EXPECT_FALSE(a); 502 503 EXPECT_TRUE(!!b); 504 EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42))); 505 EXPECT_TRUE(TestObject(1, 0.3) == b.value_or(TestObject(42, 0.42))); 506} 507 508TEST(OptionalTest, Swap_outHasValue) { 509 Optional<TestObject> a; 510 Optional<TestObject> b(TestObject(1, 0.3)); 511 a.swap(b); 512 513 EXPECT_TRUE(!!a); 514 EXPECT_FALSE(!!b); 515 EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42))); 516 EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42))); 517} 518 519TEST(OptionalTest, Swap_bothValue) { 520 Optional<TestObject> a(TestObject(0, 0.1)); 521 Optional<TestObject> b(TestObject(1, 0.3)); 522 a.swap(b); 523 524 EXPECT_TRUE(!!a); 525 EXPECT_TRUE(!!b); 526 EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42))); 527 EXPECT_TRUE(TestObject(0, 0.1) == b.value_or(TestObject(42, 0.42))); 528 EXPECT_EQ(TestObject::State::SWAPPED, a->state()); 529 EXPECT_EQ(TestObject::State::SWAPPED, b->state()); 530} 531 532TEST(OptionalTest, Emplace) { 533 { 534 Optional<float> a(0.1f); 535 a.emplace(0.3f); 536 537 EXPECT_TRUE(a); 538 EXPECT_EQ(0.3f, a.value()); 539 } 540 541 { 542 Optional<std::string> a("foo"); 543 a.emplace("bar"); 544 545 EXPECT_TRUE(a); 546 EXPECT_EQ("bar", a.value()); 547 } 548 549 { 550 Optional<TestObject> a(TestObject(0, 0.1)); 551 a.emplace(TestObject(1, 0.2)); 552 553 EXPECT_TRUE(!!a); 554 EXPECT_TRUE(TestObject(1, 0.2) == a.value()); 555 } 556} 557 558TEST(OptionalTest, Equals_TwoEmpty) { 559 Optional<int> a; 560 Optional<int> b; 561 562 EXPECT_TRUE(a == b); 563} 564 565TEST(OptionalTest, Equals_TwoEquals) { 566 Optional<int> a(1); 567 Optional<int> b(1); 568 569 EXPECT_TRUE(a == b); 570} 571 572TEST(OptionalTest, Equals_OneEmpty) { 573 Optional<int> a; 574 Optional<int> b(1); 575 576 EXPECT_FALSE(a == b); 577} 578 579TEST(OptionalTest, Equals_TwoDifferent) { 580 Optional<int> a(0); 581 Optional<int> b(1); 582 583 EXPECT_FALSE(a == b); 584} 585 586TEST(OptionalTest, NotEquals_TwoEmpty) { 587 Optional<int> a; 588 Optional<int> b; 589 590 EXPECT_FALSE(a != b); 591} 592 593TEST(OptionalTest, NotEquals_TwoEquals) { 594 Optional<int> a(1); 595 Optional<int> b(1); 596 597 EXPECT_FALSE(a != b); 598} 599 600TEST(OptionalTest, NotEquals_OneEmpty) { 601 Optional<int> a; 602 Optional<int> b(1); 603 604 EXPECT_TRUE(a != b); 605} 606 607TEST(OptionalTest, NotEquals_TwoDifferent) { 608 Optional<int> a(0); 609 Optional<int> b(1); 610 611 EXPECT_TRUE(a != b); 612} 613 614TEST(OptionalTest, Less_LeftEmpty) { 615 Optional<int> l; 616 Optional<int> r(1); 617 618 EXPECT_TRUE(l < r); 619} 620 621TEST(OptionalTest, Less_RightEmpty) { 622 Optional<int> l(1); 623 Optional<int> r; 624 625 EXPECT_FALSE(l < r); 626} 627 628TEST(OptionalTest, Less_BothEmpty) { 629 Optional<int> l; 630 Optional<int> r; 631 632 EXPECT_FALSE(l < r); 633} 634 635TEST(OptionalTest, Less_BothValues) { 636 { 637 Optional<int> l(1); 638 Optional<int> r(2); 639 640 EXPECT_TRUE(l < r); 641 } 642 { 643 Optional<int> l(2); 644 Optional<int> r(1); 645 646 EXPECT_FALSE(l < r); 647 } 648 { 649 Optional<int> l(1); 650 Optional<int> r(1); 651 652 EXPECT_FALSE(l < r); 653 } 654} 655 656TEST(OptionalTest, LessEq_LeftEmpty) { 657 Optional<int> l; 658 Optional<int> r(1); 659 660 EXPECT_TRUE(l <= r); 661} 662 663TEST(OptionalTest, LessEq_RightEmpty) { 664 Optional<int> l(1); 665 Optional<int> r; 666 667 EXPECT_FALSE(l <= r); 668} 669 670TEST(OptionalTest, LessEq_BothEmpty) { 671 Optional<int> l; 672 Optional<int> r; 673 674 EXPECT_TRUE(l <= r); 675} 676 677TEST(OptionalTest, LessEq_BothValues) { 678 { 679 Optional<int> l(1); 680 Optional<int> r(2); 681 682 EXPECT_TRUE(l <= r); 683 } 684 { 685 Optional<int> l(2); 686 Optional<int> r(1); 687 688 EXPECT_FALSE(l <= r); 689 } 690 { 691 Optional<int> l(1); 692 Optional<int> r(1); 693 694 EXPECT_TRUE(l <= r); 695 } 696} 697 698TEST(OptionalTest, Greater_BothEmpty) { 699 Optional<int> l; 700 Optional<int> r; 701 702 EXPECT_FALSE(l > r); 703} 704 705TEST(OptionalTest, Greater_LeftEmpty) { 706 Optional<int> l; 707 Optional<int> r(1); 708 709 EXPECT_FALSE(l > r); 710} 711 712TEST(OptionalTest, Greater_RightEmpty) { 713 Optional<int> l(1); 714 Optional<int> r; 715 716 EXPECT_TRUE(l > r); 717} 718 719TEST(OptionalTest, Greater_BothValue) { 720 { 721 Optional<int> l(1); 722 Optional<int> r(2); 723 724 EXPECT_FALSE(l > r); 725 } 726 { 727 Optional<int> l(2); 728 Optional<int> r(1); 729 730 EXPECT_TRUE(l > r); 731 } 732 { 733 Optional<int> l(1); 734 Optional<int> r(1); 735 736 EXPECT_FALSE(l > r); 737 } 738} 739 740TEST(OptionalTest, GreaterEq_BothEmpty) { 741 Optional<int> l; 742 Optional<int> r; 743 744 EXPECT_TRUE(l >= r); 745} 746 747TEST(OptionalTest, GreaterEq_LeftEmpty) { 748 Optional<int> l; 749 Optional<int> r(1); 750 751 EXPECT_FALSE(l >= r); 752} 753 754TEST(OptionalTest, GreaterEq_RightEmpty) { 755 Optional<int> l(1); 756 Optional<int> r; 757 758 EXPECT_TRUE(l >= r); 759} 760 761TEST(OptionalTest, GreaterEq_BothValue) { 762 { 763 Optional<int> l(1); 764 Optional<int> r(2); 765 766 EXPECT_FALSE(l >= r); 767 } 768 { 769 Optional<int> l(2); 770 Optional<int> r(1); 771 772 EXPECT_TRUE(l >= r); 773 } 774 { 775 Optional<int> l(1); 776 Optional<int> r(1); 777 778 EXPECT_TRUE(l >= r); 779 } 780} 781 782TEST(OptionalTest, OptNullEq) { 783 { 784 Optional<int> opt; 785 EXPECT_TRUE(opt == base::nullopt); 786 } 787 { 788 Optional<int> opt(1); 789 EXPECT_FALSE(opt == base::nullopt); 790 } 791} 792 793TEST(OptionalTest, NullOptEq) { 794 { 795 Optional<int> opt; 796 EXPECT_TRUE(base::nullopt == opt); 797 } 798 { 799 Optional<int> opt(1); 800 EXPECT_FALSE(base::nullopt == opt); 801 } 802} 803 804TEST(OptionalTest, OptNullNotEq) { 805 { 806 Optional<int> opt; 807 EXPECT_FALSE(opt != base::nullopt); 808 } 809 { 810 Optional<int> opt(1); 811 EXPECT_TRUE(opt != base::nullopt); 812 } 813} 814 815TEST(OptionalTest, NullOptNotEq) { 816 { 817 Optional<int> opt; 818 EXPECT_FALSE(base::nullopt != opt); 819 } 820 { 821 Optional<int> opt(1); 822 EXPECT_TRUE(base::nullopt != opt); 823 } 824} 825 826TEST(OptionalTest, OptNullLower) { 827 { 828 Optional<int> opt; 829 EXPECT_FALSE(opt < base::nullopt); 830 } 831 { 832 Optional<int> opt(1); 833 EXPECT_FALSE(opt < base::nullopt); 834 } 835} 836 837TEST(OptionalTest, NullOptLower) { 838 { 839 Optional<int> opt; 840 EXPECT_FALSE(base::nullopt < opt); 841 } 842 { 843 Optional<int> opt(1); 844 EXPECT_TRUE(base::nullopt < opt); 845 } 846} 847 848TEST(OptionalTest, OptNullLowerEq) { 849 { 850 Optional<int> opt; 851 EXPECT_TRUE(opt <= base::nullopt); 852 } 853 { 854 Optional<int> opt(1); 855 EXPECT_FALSE(opt <= base::nullopt); 856 } 857} 858 859TEST(OptionalTest, NullOptLowerEq) { 860 { 861 Optional<int> opt; 862 EXPECT_TRUE(base::nullopt <= opt); 863 } 864 { 865 Optional<int> opt(1); 866 EXPECT_TRUE(base::nullopt <= opt); 867 } 868} 869 870TEST(OptionalTest, OptNullGreater) { 871 { 872 Optional<int> opt; 873 EXPECT_FALSE(opt > base::nullopt); 874 } 875 { 876 Optional<int> opt(1); 877 EXPECT_TRUE(opt > base::nullopt); 878 } 879} 880 881TEST(OptionalTest, NullOptGreater) { 882 { 883 Optional<int> opt; 884 EXPECT_FALSE(base::nullopt > opt); 885 } 886 { 887 Optional<int> opt(1); 888 EXPECT_FALSE(base::nullopt > opt); 889 } 890} 891 892TEST(OptionalTest, OptNullGreaterEq) { 893 { 894 Optional<int> opt; 895 EXPECT_TRUE(opt >= base::nullopt); 896 } 897 { 898 Optional<int> opt(1); 899 EXPECT_TRUE(opt >= base::nullopt); 900 } 901} 902 903TEST(OptionalTest, NullOptGreaterEq) { 904 { 905 Optional<int> opt; 906 EXPECT_TRUE(base::nullopt >= opt); 907 } 908 { 909 Optional<int> opt(1); 910 EXPECT_FALSE(base::nullopt >= opt); 911 } 912} 913 914TEST(OptionalTest, ValueEq_Empty) { 915 Optional<int> opt; 916 EXPECT_FALSE(opt == 1); 917} 918 919TEST(OptionalTest, ValueEq_NotEmpty) { 920 { 921 Optional<int> opt(0); 922 EXPECT_FALSE(opt == 1); 923 } 924 { 925 Optional<int> opt(1); 926 EXPECT_TRUE(opt == 1); 927 } 928} 929 930TEST(OptionalTest, EqValue_Empty) { 931 Optional<int> opt; 932 EXPECT_FALSE(1 == opt); 933} 934 935TEST(OptionalTest, EqValue_NotEmpty) { 936 { 937 Optional<int> opt(0); 938 EXPECT_FALSE(1 == opt); 939 } 940 { 941 Optional<int> opt(1); 942 EXPECT_TRUE(1 == opt); 943 } 944} 945 946TEST(OptionalTest, ValueNotEq_Empty) { 947 Optional<int> opt; 948 EXPECT_TRUE(opt != 1); 949} 950 951TEST(OptionalTest, ValueNotEq_NotEmpty) { 952 { 953 Optional<int> opt(0); 954 EXPECT_TRUE(opt != 1); 955 } 956 { 957 Optional<int> opt(1); 958 EXPECT_FALSE(opt != 1); 959 } 960} 961 962TEST(OptionalTest, NotEqValue_Empty) { 963 Optional<int> opt; 964 EXPECT_TRUE(1 != opt); 965} 966 967TEST(OptionalTest, NotEqValue_NotEmpty) { 968 { 969 Optional<int> opt(0); 970 EXPECT_TRUE(1 != opt); 971 } 972 { 973 Optional<int> opt(1); 974 EXPECT_FALSE(1 != opt); 975 } 976} 977 978TEST(OptionalTest, ValueLess_Empty) { 979 Optional<int> opt; 980 EXPECT_TRUE(opt < 1); 981} 982 983TEST(OptionalTest, ValueLess_NotEmpty) { 984 { 985 Optional<int> opt(0); 986 EXPECT_TRUE(opt < 1); 987 } 988 { 989 Optional<int> opt(1); 990 EXPECT_FALSE(opt < 1); 991 } 992 { 993 Optional<int> opt(2); 994 EXPECT_FALSE(opt < 1); 995 } 996} 997 998TEST(OptionalTest, LessValue_Empty) { 999 Optional<int> opt; 1000 EXPECT_FALSE(1 < opt); 1001} 1002 1003TEST(OptionalTest, LessValue_NotEmpty) { 1004 { 1005 Optional<int> opt(0); 1006 EXPECT_FALSE(1 < opt); 1007 } 1008 { 1009 Optional<int> opt(1); 1010 EXPECT_FALSE(1 < opt); 1011 } 1012 { 1013 Optional<int> opt(2); 1014 EXPECT_TRUE(1 < opt); 1015 } 1016} 1017 1018TEST(OptionalTest, ValueLessEq_Empty) { 1019 Optional<int> opt; 1020 EXPECT_TRUE(opt <= 1); 1021} 1022 1023TEST(OptionalTest, ValueLessEq_NotEmpty) { 1024 { 1025 Optional<int> opt(0); 1026 EXPECT_TRUE(opt <= 1); 1027 } 1028 { 1029 Optional<int> opt(1); 1030 EXPECT_TRUE(opt <= 1); 1031 } 1032 { 1033 Optional<int> opt(2); 1034 EXPECT_FALSE(opt <= 1); 1035 } 1036} 1037 1038TEST(OptionalTest, LessEqValue_Empty) { 1039 Optional<int> opt; 1040 EXPECT_FALSE(1 <= opt); 1041} 1042 1043TEST(OptionalTest, LessEqValue_NotEmpty) { 1044 { 1045 Optional<int> opt(0); 1046 EXPECT_FALSE(1 <= opt); 1047 } 1048 { 1049 Optional<int> opt(1); 1050 EXPECT_TRUE(1 <= opt); 1051 } 1052 { 1053 Optional<int> opt(2); 1054 EXPECT_TRUE(1 <= opt); 1055 } 1056} 1057 1058TEST(OptionalTest, ValueGreater_Empty) { 1059 Optional<int> opt; 1060 EXPECT_FALSE(opt > 1); 1061} 1062 1063TEST(OptionalTest, ValueGreater_NotEmpty) { 1064 { 1065 Optional<int> opt(0); 1066 EXPECT_FALSE(opt > 1); 1067 } 1068 { 1069 Optional<int> opt(1); 1070 EXPECT_FALSE(opt > 1); 1071 } 1072 { 1073 Optional<int> opt(2); 1074 EXPECT_TRUE(opt > 1); 1075 } 1076} 1077 1078TEST(OptionalTest, GreaterValue_Empty) { 1079 Optional<int> opt; 1080 EXPECT_TRUE(1 > opt); 1081} 1082 1083TEST(OptionalTest, GreaterValue_NotEmpty) { 1084 { 1085 Optional<int> opt(0); 1086 EXPECT_TRUE(1 > opt); 1087 } 1088 { 1089 Optional<int> opt(1); 1090 EXPECT_FALSE(1 > opt); 1091 } 1092 { 1093 Optional<int> opt(2); 1094 EXPECT_FALSE(1 > opt); 1095 } 1096} 1097 1098TEST(OptionalTest, ValueGreaterEq_Empty) { 1099 Optional<int> opt; 1100 EXPECT_FALSE(opt >= 1); 1101} 1102 1103TEST(OptionalTest, ValueGreaterEq_NotEmpty) { 1104 { 1105 Optional<int> opt(0); 1106 EXPECT_FALSE(opt >= 1); 1107 } 1108 { 1109 Optional<int> opt(1); 1110 EXPECT_TRUE(opt >= 1); 1111 } 1112 { 1113 Optional<int> opt(2); 1114 EXPECT_TRUE(opt >= 1); 1115 } 1116} 1117 1118TEST(OptionalTest, GreaterEqValue_Empty) { 1119 Optional<int> opt; 1120 EXPECT_TRUE(1 >= opt); 1121} 1122 1123TEST(OptionalTest, GreaterEqValue_NotEmpty) { 1124 { 1125 Optional<int> opt(0); 1126 EXPECT_TRUE(1 >= opt); 1127 } 1128 { 1129 Optional<int> opt(1); 1130 EXPECT_TRUE(1 >= opt); 1131 } 1132 { 1133 Optional<int> opt(2); 1134 EXPECT_FALSE(1 >= opt); 1135 } 1136} 1137 1138TEST(OptionalTest, NotEquals) { 1139 { 1140 Optional<float> a(0.1f); 1141 Optional<float> b(0.2f); 1142 EXPECT_NE(a, b); 1143 } 1144 1145 { 1146 Optional<std::string> a("foo"); 1147 Optional<std::string> b("bar"); 1148 EXPECT_NE(a, b); 1149 } 1150 1151 { 1152 Optional<TestObject> a(TestObject(3, 0.1)); 1153 Optional<TestObject> b(TestObject(4, 1.0)); 1154 EXPECT_TRUE(a != b); 1155 } 1156} 1157 1158TEST(OptionalTest, NotEqualsNull) { 1159 { 1160 Optional<float> a(0.1f); 1161 Optional<float> b(0.1f); 1162 b = base::nullopt; 1163 EXPECT_NE(a, b); 1164 } 1165 1166 { 1167 Optional<std::string> a("foo"); 1168 Optional<std::string> b("foo"); 1169 b = base::nullopt; 1170 EXPECT_NE(a, b); 1171 } 1172 1173 { 1174 Optional<TestObject> a(TestObject(3, 0.1)); 1175 Optional<TestObject> b(TestObject(3, 0.1)); 1176 b = base::nullopt; 1177 EXPECT_TRUE(a != b); 1178 } 1179} 1180 1181TEST(OptionalTest, MakeOptional) { 1182 { 1183 Optional<float> o = base::make_optional(32.f); 1184 EXPECT_TRUE(o); 1185 EXPECT_EQ(32.f, *o); 1186 1187 float value = 3.f; 1188 o = base::make_optional(std::move(value)); 1189 EXPECT_TRUE(o); 1190 EXPECT_EQ(3.f, *o); 1191 } 1192 1193 { 1194 Optional<std::string> o = base::make_optional(std::string("foo")); 1195 EXPECT_TRUE(o); 1196 EXPECT_EQ("foo", *o); 1197 1198 std::string value = "bar"; 1199 o = base::make_optional(std::move(value)); 1200 EXPECT_TRUE(o); 1201 EXPECT_EQ(std::string("bar"), *o); 1202 } 1203 1204 { 1205 Optional<TestObject> o = base::make_optional(TestObject(3, 0.1)); 1206 EXPECT_TRUE(!!o); 1207 EXPECT_TRUE(TestObject(3, 0.1) == *o); 1208 1209 TestObject value = TestObject(0, 0.42); 1210 o = base::make_optional(std::move(value)); 1211 EXPECT_TRUE(!!o); 1212 EXPECT_TRUE(TestObject(0, 0.42) == *o); 1213 EXPECT_EQ(TestObject::State::MOVED_FROM, value.state()); 1214 EXPECT_EQ(TestObject::State::MOVE_ASSIGNED, o->state()); 1215 1216 EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, 1217 base::make_optional(std::move(value))->state()); 1218 } 1219} 1220 1221TEST(OptionalTest, NonMemberSwap_bothNoValue) { 1222 Optional<TestObject> a, b; 1223 base::swap(a, b); 1224 1225 EXPECT_FALSE(!!a); 1226 EXPECT_FALSE(!!b); 1227 EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42))); 1228 EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42))); 1229} 1230 1231TEST(OptionalTest, NonMemberSwap_inHasValue) { 1232 Optional<TestObject> a(TestObject(1, 0.3)); 1233 Optional<TestObject> b; 1234 base::swap(a, b); 1235 1236 EXPECT_FALSE(!!a); 1237 EXPECT_TRUE(!!b); 1238 EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42))); 1239 EXPECT_TRUE(TestObject(1, 0.3) == b.value_or(TestObject(42, 0.42))); 1240} 1241 1242TEST(OptionalTest, NonMemberSwap_outHasValue) { 1243 Optional<TestObject> a; 1244 Optional<TestObject> b(TestObject(1, 0.3)); 1245 base::swap(a, b); 1246 1247 EXPECT_TRUE(!!a); 1248 EXPECT_FALSE(!!b); 1249 EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42))); 1250 EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42))); 1251} 1252 1253TEST(OptionalTest, NonMemberSwap_bothValue) { 1254 Optional<TestObject> a(TestObject(0, 0.1)); 1255 Optional<TestObject> b(TestObject(1, 0.3)); 1256 base::swap(a, b); 1257 1258 EXPECT_TRUE(!!a); 1259 EXPECT_TRUE(!!b); 1260 EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42))); 1261 EXPECT_TRUE(TestObject(0, 0.1) == b.value_or(TestObject(42, 0.42))); 1262 EXPECT_EQ(TestObject::State::SWAPPED, a->state()); 1263 EXPECT_EQ(TestObject::State::SWAPPED, b->state()); 1264} 1265 1266TEST(OptionalTest, Hash_OptionalReflectsInternal) { 1267 { 1268 std::hash<int> int_hash; 1269 std::hash<Optional<int>> opt_int_hash; 1270 1271 EXPECT_EQ(int_hash(1), opt_int_hash(Optional<int>(1))); 1272 } 1273 1274 { 1275 std::hash<std::string> str_hash; 1276 std::hash<Optional<std::string>> opt_str_hash; 1277 1278 EXPECT_EQ(str_hash(std::string("foobar")), 1279 opt_str_hash(Optional<std::string>(std::string("foobar")))); 1280 } 1281} 1282 1283TEST(OptionalTest, Hash_NullOptEqualsNullOpt) { 1284 std::hash<Optional<int>> opt_int_hash; 1285 std::hash<Optional<std::string>> opt_str_hash; 1286 1287 EXPECT_EQ(opt_str_hash(Optional<std::string>()), 1288 opt_int_hash(Optional<int>())); 1289} 1290 1291TEST(OptionalTest, Hash_UseInSet) { 1292 std::set<Optional<int>> setOptInt; 1293 1294 EXPECT_EQ(setOptInt.end(), setOptInt.find(42)); 1295 1296 setOptInt.insert(Optional<int>(3)); 1297 EXPECT_EQ(setOptInt.end(), setOptInt.find(42)); 1298 EXPECT_NE(setOptInt.end(), setOptInt.find(3)); 1299} 1300 1301} // namespace base 1302