base/optional_unittest.cc

   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 <memory>
   6 #include <set>
   7 #include <string>
   8 #include <type_traits>
   9 #include <vector>
  10
  11 #include "base/macros.h"
  12 #include "base/test/gtest_util.h"
  13 #include "testing/gmock/include/gmock/gmock.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15 #include "third_party/abseil-cpp/absl/types/optional.h"
  16
  17 using ::testing::ElementsAre;
  18
  19 namespace base {
  20
  21 namespace {
  22
  23 // Object used to test complex object with absl::optional<T> in addition of the
  24 // move semantics.
  25 class TestObject {
  26  public:
  27   enum class State {
  28     DEFAULT_CONSTRUCTED,
  29     VALUE_CONSTRUCTED,
  30     COPY_CONSTRUCTED,
  31     MOVE_CONSTRUCTED,
  32     MOVED_FROM,
  33     COPY_ASSIGNED,
  34     MOVE_ASSIGNED,
  35     SWAPPED,
  36   };
  37
  38   TestObject() : foo_(0), bar_(0.0), state_(State::DEFAULT_CONSTRUCTED) {}
  39
  40   TestObject(int foo, double bar)
  41       : foo_(foo), bar_(bar), state_(State::VALUE_CONSTRUCTED) {}
  42
  43   TestObject(const TestObject& other)
  44       : foo_(other.foo_),
  45         bar_(other.bar_),
  46         state_(State::COPY_CONSTRUCTED),
  47         move_ctors_count_(other.move_ctors_count_) {}
  48
  49   TestObject(TestObject&& other)
  50       : foo_(std::move(other.foo_)),
  51         bar_(std::move(other.bar_)),
  52         state_(State::MOVE_CONSTRUCTED),
  53         move_ctors_count_(other.move_ctors_count_ + 1) {
  54     other.state_ = State::MOVED_FROM;
  55   }
  56
  57   TestObject& operator=(const TestObject& other) {
  58     foo_ = other.foo_;
  59     bar_ = other.bar_;
  60     state_ = State::COPY_ASSIGNED;
  61     move_ctors_count_ = other.move_ctors_count_;
  62     return *this;
  63   }
  64
  65   TestObject& operator=(TestObject&& other) {
  66     foo_ = other.foo_;
  67     bar_ = other.bar_;
  68     state_ = State::MOVE_ASSIGNED;
  69     move_ctors_count_ = other.move_ctors_count_;
  70     other.state_ = State::MOVED_FROM;
  71     return *this;
  72   }
  73
  74   void Swap(TestObject* other) {
  75     using std::swap;
  76     swap(foo_, other->foo_);
  77     swap(bar_, other->bar_);
  78     swap(move_ctors_count_, other->move_ctors_count_);
  79     state_ = State::SWAPPED;
  80     other->state_ = State::SWAPPED;
  81   }
  82
  83   bool operator==(const TestObject& other) const {
  84     return std::tie(foo_, bar_) == std::tie(other.foo_, other.bar_);
  85   }
  86
  87   bool operator!=(const TestObject& other) const { return !(*this == other); }
  88
  89   int foo() const { return foo_; }
  90   State state() const { return state_; }
  91   int move_ctors_count() const { return move_ctors_count_; }
  92
  93  private:
  94   int foo_;
  95   double bar_;
  96   State state_;
  97   int move_ctors_count_ = 0;
  98 };
  99
 100 // Implementing Swappable concept.
 101 void swap(TestObject& lhs, TestObject& rhs) {
 102   lhs.Swap(&rhs);
 103 }
 104
 105 class NonTriviallyDestructible {
 106  public:
 107   ~NonTriviallyDestructible() {}
 108 };
 109
 110 class DeletedDefaultConstructor {
 111  public:
 112   DeletedDefaultConstructor() = delete;
 113   DeletedDefaultConstructor(int foo) : foo_(foo) {}
 114
 115   int foo() const { return foo_; }
 116
 117  private:
 118   int foo_;
 119 };
 120
 121 class DeletedCopy {
 122  public:
 123   explicit DeletedCopy(int foo) : foo_(foo) {}
 124   DeletedCopy(const DeletedCopy&) = delete;
 125   DeletedCopy(DeletedCopy&&) = default;
 126
 127   DeletedCopy& operator=(const DeletedCopy&) = delete;
 128   DeletedCopy& operator=(DeletedCopy&&) = default;
 129
 130   int foo() const { return foo_; }
 131
 132  private:
 133   int foo_;
 134 };
 135
 136 class DeletedMove {
 137  public:
 138   explicit DeletedMove(int foo) : foo_(foo) {}
 139   DeletedMove(const DeletedMove&) = default;
 140   DeletedMove(DeletedMove&&) = delete;
 141
 142   DeletedMove& operator=(const DeletedMove&) = default;
 143   DeletedMove& operator=(DeletedMove&&) = delete;
 144
 145   int foo() const { return foo_; }
 146
 147  private:
 148   int foo_;
 149 };
 150
 151 class NonTriviallyDestructibleDeletedCopyConstructor {
 152  public:
 153   explicit NonTriviallyDestructibleDeletedCopyConstructor(int foo)
 154       : foo_(foo) {}
 155   NonTriviallyDestructibleDeletedCopyConstructor(
 156       const NonTriviallyDestructibleDeletedCopyConstructor&) = delete;
 157   NonTriviallyDestructibleDeletedCopyConstructor(
 158       NonTriviallyDestructibleDeletedCopyConstructor&&) = default;
 159
 160   ~NonTriviallyDestructibleDeletedCopyConstructor() {}
 161
 162   int foo() const { return foo_; }
 163
 164  private:
 165   int foo_;
 166 };
 167
 168 class DeleteNewOperators {
 169  public:
 170   void* operator new(size_t) = delete;
 171   void* operator new(size_t, void*) = delete;
 172   void* operator new[](size_t) = delete;
 173   void* operator new[](size_t, void*) = delete;
 174 };
 175
 176 class TriviallyDestructibleOverloadAddressOf {
 177  public:
 178   // Unfortunately, since this can be called as part of placement-new (if it
 179   // forgets to call std::addressof), we're uninitialized.  So, about the best
 180   // we can do is signal a test failure here if either operator& is called.
 181   TriviallyDestructibleOverloadAddressOf* operator&() {
 182     EXPECT_TRUE(false);
 183     return this;
 184   }
 185
 186   // So we can test the const version of operator->.
 187   const TriviallyDestructibleOverloadAddressOf* operator&() const {
 188     EXPECT_TRUE(false);
 189     return this;
 190   }
 191
 192   void const_method() const {}
 193   void nonconst_method() {}
 194 };
 195
 196 class NonTriviallyDestructibleOverloadAddressOf {
 197  public:
 198   ~NonTriviallyDestructibleOverloadAddressOf() {}
 199   NonTriviallyDestructibleOverloadAddressOf* operator&() {
 200     EXPECT_TRUE(false);
 201     return this;
 202   }
 203 };
 204
 205 }  // anonymous namespace
 206
 207 static_assert(std::is_trivially_destructible<absl::optional<int>>::value,
 208               "OptionalIsTriviallyDestructible");
 209
 210 static_assert(!std::is_trivially_destructible<
 211                   absl::optional<NonTriviallyDestructible>>::value,
 212               "OptionalIsTriviallyDestructible");
 213
 214 TEST(OptionalTest, DefaultConstructor) {
 215   {
 216     constexpr absl::optional<float> o;
 217     EXPECT_FALSE(o);
 218   }
 219
 220   {
 221     absl::optional<std::string> o;
 222     EXPECT_FALSE(o);
 223   }
 224
 225   {
 226     absl::optional<TestObject> o;
 227     EXPECT_FALSE(o);
 228   }
 229 }
 230
 231 TEST(OptionalTest, CopyConstructor) {
 232   {
 233     constexpr absl::optional<float> first(0.1f);
 234     constexpr absl::optional<float> other(first);
 235
 236     EXPECT_TRUE(other);
 237     EXPECT_EQ(other.value(), 0.1f);
 238     EXPECT_EQ(first, other);
 239   }
 240
 241   {
 242     absl::optional<std::string> first("foo");
 243     absl::optional<std::string> other(first);
 244
 245     EXPECT_TRUE(other);
 246     EXPECT_EQ(other.value(), "foo");
 247     EXPECT_EQ(first, other);
 248   }
 249
 250   {
 251     const absl::optional<std::string> first("foo");
 252     absl::optional<std::string> other(first);
 253
 254     EXPECT_TRUE(other);
 255     EXPECT_EQ(other.value(), "foo");
 256     EXPECT_EQ(first, other);
 257   }
 258
 259   {
 260     absl::optional<TestObject> first(TestObject(3, 0.1));
 261     absl::optional<TestObject> other(first);
 262
 263     EXPECT_TRUE(!!other);
 264     EXPECT_TRUE(other.value() == TestObject(3, 0.1));
 265     EXPECT_TRUE(first == other);
 266   }
 267 }
 268
 269 TEST(OptionalTest, ValueConstructor) {
 270   {
 271     constexpr float value = 0.1f;
 272     constexpr absl::optional<float> o(value);
 273
 274     EXPECT_TRUE(o);
 275     EXPECT_EQ(value, o.value());
 276   }
 277
 278   {
 279     std::string value("foo");
 280     absl::optional<std::string> o(value);
 281
 282     EXPECT_TRUE(o);
 283     EXPECT_EQ(value, o.value());
 284   }
 285
 286   {
 287     TestObject value(3, 0.1);
 288     absl::optional<TestObject> o(value);
 289
 290     EXPECT_TRUE(o);
 291     EXPECT_EQ(TestObject::State::COPY_CONSTRUCTED, o->state());
 292     EXPECT_EQ(value, o.value());
 293   }
 294 }
 295
 296 TEST(OptionalTest, MoveConstructor) {
 297   {
 298     constexpr absl::optional<float> first(0.1f);
 299     constexpr absl::optional<float> second(std::move(first));
 300
 301     EXPECT_TRUE(second.has_value());
 302     EXPECT_EQ(second.value(), 0.1f);
 303
 304     EXPECT_TRUE(first.has_value());
 305   }
 306
 307   {
 308     absl::optional<std::string> first("foo");
 309     absl::optional<std::string> second(std::move(first));
 310
 311     EXPECT_TRUE(second.has_value());
 312     EXPECT_EQ("foo", second.value());
 313
 314     EXPECT_TRUE(first.has_value());
 315   }
 316
 317   {
 318     absl::optional<TestObject> first(TestObject(3, 0.1));
 319     absl::optional<TestObject> second(std::move(first));
 320
 321     EXPECT_TRUE(second.has_value());
 322     EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, second->state());
 323     EXPECT_TRUE(TestObject(3, 0.1) == second.value());
 324
 325     EXPECT_TRUE(first.has_value());
 326     EXPECT_EQ(TestObject::State::MOVED_FROM, first->state());
 327   }
 328
 329   // Even if copy constructor is deleted, move constructor needs to work.
 330   // Note that it couldn't be constexpr.
 331   {
 332     absl::optional<DeletedCopy> first(absl::in_place, 42);
 333     absl::optional<DeletedCopy> second(std::move(first));
 334
 335     EXPECT_TRUE(second.has_value());
 336     EXPECT_EQ(42, second->foo());
 337
 338     EXPECT_TRUE(first.has_value());
 339   }
 340
 341   {
 342     absl::optional<DeletedMove> first(absl::in_place, 42);
 343     absl::optional<DeletedMove> second(std::move(first));
 344
 345     EXPECT_TRUE(second.has_value());
 346     EXPECT_EQ(42, second->foo());
 347
 348     EXPECT_TRUE(first.has_value());
 349   }
 350
 351   {
 352     absl::optional<NonTriviallyDestructibleDeletedCopyConstructor> first(
 353         absl::in_place, 42);
 354     absl::optional<NonTriviallyDestructibleDeletedCopyConstructor> second(
 355         std::move(first));
 356
 357     EXPECT_TRUE(second.has_value());
 358     EXPECT_EQ(42, second->foo());
 359
 360     EXPECT_TRUE(first.has_value());
 361   }
 362 }
 363
 364 TEST(OptionalTest, MoveValueConstructor) {
 365   {
 366     constexpr float value = 0.1f;
 367     constexpr absl::optional<float> o(std::move(value));
 368
 369     EXPECT_TRUE(o);
 370     EXPECT_EQ(0.1f, o.value());
 371   }
 372
 373   {
 374     float value = 0.1f;
 375     absl::optional<float> o(std::move(value));
 376
 377     EXPECT_TRUE(o);
 378     EXPECT_EQ(0.1f, o.value());
 379   }
 380
 381   {
 382     std::string value("foo");
 383     absl::optional<std::string> o(std::move(value));
 384
 385     EXPECT_TRUE(o);
 386     EXPECT_EQ("foo", o.value());
 387   }
 388
 389   {
 390     TestObject value(3, 0.1);
 391     absl::optional<TestObject> o(std::move(value));
 392
 393     EXPECT_TRUE(o);
 394     EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, o->state());
 395     EXPECT_EQ(TestObject(3, 0.1), o.value());
 396   }
 397 }
 398
 399 TEST(OptionalTest, ConvertingCopyConstructor) {
 400   {
 401     absl::optional<int> first(1);
 402     absl::optional<double> second(first);
 403     EXPECT_TRUE(second.has_value());
 404     EXPECT_EQ(1.0, second.value());
 405   }
 406
 407   // Make sure explicit is not marked for convertible case.
 408   {
 409     absl::optional<int> o(1);
 410     ignore_result<absl::optional<double>>(o);
 411   }
 412 }
 413
 414 TEST(OptionalTest, ConvertingMoveConstructor) {
 415   {
 416     absl::optional<int> first(1);
 417     absl::optional<double> second(std::move(first));
 418     EXPECT_TRUE(second.has_value());
 419     EXPECT_EQ(1.0, second.value());
 420   }
 421
 422   // Make sure explicit is not marked for convertible case.
 423   {
 424     absl::optional<int> o(1);
 425     ignore_result<absl::optional<double>>(std::move(o));
 426   }
 427
 428   {
 429     class Test1 {
 430      public:
 431       explicit Test1(int foo) : foo_(foo) {}
 432
 433       int foo() const { return foo_; }
 434
 435      private:
 436       int foo_;
 437     };
 438
 439     // Not copyable but convertible from Test1.
 440     class Test2 {
 441      public:
 442       Test2(const Test2&) = delete;
 443       explicit Test2(Test1&& other) : bar_(other.foo()) {}
 444
 445       double bar() const { return bar_; }
 446
 447      private:
 448       double bar_;
 449     };
 450
 451     absl::optional<Test1> first(absl::in_place, 42);
 452     absl::optional<Test2> second(std::move(first));
 453     EXPECT_TRUE(second.has_value());
 454     EXPECT_EQ(42.0, second->bar());
 455   }
 456 }
 457
 458 TEST(OptionalTest, ConstructorForwardArguments) {
 459   {
 460     constexpr absl::optional<float> a(absl::in_place, 0.1f);
 461     EXPECT_TRUE(a);
 462     EXPECT_EQ(0.1f, a.value());
 463   }
 464
 465   {
 466     absl::optional<float> a(absl::in_place, 0.1f);
 467     EXPECT_TRUE(a);
 468     EXPECT_EQ(0.1f, a.value());
 469   }
 470
 471   {
 472     absl::optional<std::string> a(absl::in_place, "foo");
 473     EXPECT_TRUE(a);
 474     EXPECT_EQ("foo", a.value());
 475   }
 476
 477   {
 478     absl::optional<TestObject> a(absl::in_place, 0, 0.1);
 479     EXPECT_TRUE(!!a);
 480     EXPECT_TRUE(TestObject(0, 0.1) == a.value());
 481   }
 482 }
 483
 484 TEST(OptionalTest, ConstructorForwardInitListAndArguments) {
 485   {
 486     absl::optional<std::vector<int>> opt(absl::in_place, {3, 1});
 487     EXPECT_TRUE(opt);
 488     EXPECT_THAT(*opt, ElementsAre(3, 1));
 489     EXPECT_EQ(2u, opt->size());
 490   }
 491
 492   {
 493     absl::optional<std::vector<int>> opt(absl::in_place, {3, 1},
 494                                          std::allocator<int>());
 495     EXPECT_TRUE(opt);
 496     EXPECT_THAT(*opt, ElementsAre(3, 1));
 497     EXPECT_EQ(2u, opt->size());
 498   }
 499 }
 500
 501 TEST(OptionalTest, ForwardConstructor) {
 502   {
 503     absl::optional<double> a(1);
 504     EXPECT_TRUE(a.has_value());
 505     EXPECT_EQ(1.0, a.value());
 506   }
 507
 508   // Test that default type of 'U' is value_type.
 509   {
 510     struct TestData {
 511       int a;
 512       double b;
 513       bool c;
 514     };
 515
 516     absl::optional<TestData> a({1, 2.0, true});
 517     EXPECT_TRUE(a.has_value());
 518     EXPECT_EQ(1, a->a);
 519     EXPECT_EQ(2.0, a->b);
 520     EXPECT_TRUE(a->c);
 521   }
 522
 523   // If T has a constructor with a param absl::optional<U>, and another ctor
 524   // with a param U, then T(absl::optional<U>) should be used for
 525   // absl::optional<T>(absl::optional<U>) constructor.
 526   {
 527     enum class ParamType {
 528       DEFAULT_CONSTRUCTED,
 529       COPY_CONSTRUCTED,
 530       MOVE_CONSTRUCTED,
 531       INT,
 532       IN_PLACE,
 533       OPTIONAL_INT,
 534     };
 535     struct Test {
 536       Test() : param_type(ParamType::DEFAULT_CONSTRUCTED) {}
 537       Test(const Test& param) : param_type(ParamType::COPY_CONSTRUCTED) {}
 538       Test(Test&& param) : param_type(ParamType::MOVE_CONSTRUCTED) {}
 539       explicit Test(int param) : param_type(ParamType::INT) {}
 540       explicit Test(in_place_t param) : param_type(ParamType::IN_PLACE) {}
 541       explicit Test(absl::optional<int> param)
 542           : param_type(ParamType::OPTIONAL_INT) {}
 543
 544       ParamType param_type;
 545     };
 546
 547     // Overload resolution with copy-conversion constructor.
 548     {
 549       const absl::optional<int> arg(absl::in_place, 1);
 550       absl::optional<Test> testee(arg);
 551       EXPECT_EQ(ParamType::OPTIONAL_INT, testee->param_type);
 552     }
 553
 554     // Overload resolution with move conversion constructor.
 555     {
 556       absl::optional<Test> testee(absl::optional<int>(absl::in_place, 1));
 557       EXPECT_EQ(ParamType::OPTIONAL_INT, testee->param_type);
 558     }
 559
 560     // Default constructor should be used.
 561     {
 562       absl::optional<Test> testee(absl::in_place);
 563       EXPECT_EQ(ParamType::DEFAULT_CONSTRUCTED, testee->param_type);
 564     }
 565   }
 566
 567   {
 568     struct Test {
 569       Test(int a) {}  // NOLINT(runtime/explicit)
 570     };
 571     // If T is convertible from U, it is not marked as explicit.
 572     static_assert(std::is_convertible<int, Test>::value,
 573                   "Int should be convertible to Test.");
 574     ([](absl::optional<Test> param) {})(1);
 575   }
 576 }
 577
 578 TEST(OptionalTest, NulloptConstructor) {
 579   constexpr absl::optional<int> a(absl::nullopt);
 580   EXPECT_FALSE(a);
 581 }
 582
 583 TEST(OptionalTest, AssignValue) {
 584   {
 585     absl::optional<float> a;
 586     EXPECT_FALSE(a);
 587     a = 0.1f;
 588     EXPECT_TRUE(a);
 589
 590     absl::optional<float> b(0.1f);
 591     EXPECT_TRUE(a == b);
 592   }
 593
 594   {
 595     absl::optional<std::string> a;
 596     EXPECT_FALSE(a);
 597     a = std::string("foo");
 598     EXPECT_TRUE(a);
 599
 600     absl::optional<std::string> b(std::string("foo"));
 601     EXPECT_EQ(a, b);
 602   }
 603
 604   {
 605     absl::optional<TestObject> a;
 606     EXPECT_FALSE(!!a);
 607     a = TestObject(3, 0.1);
 608     EXPECT_TRUE(!!a);
 609
 610     absl::optional<TestObject> b(TestObject(3, 0.1));
 611     EXPECT_TRUE(a == b);
 612   }
 613
 614   {
 615     absl::optional<TestObject> a = TestObject(4, 1.0);
 616     EXPECT_TRUE(!!a);
 617     a = TestObject(3, 0.1);
 618     EXPECT_TRUE(!!a);
 619
 620     absl::optional<TestObject> b(TestObject(3, 0.1));
 621     EXPECT_TRUE(a == b);
 622   }
 623 }
 624
 625 TEST(OptionalTest, AssignObject) {
 626   {
 627     absl::optional<float> a;
 628     absl::optional<float> b(0.1f);
 629     a = b;
 630
 631     EXPECT_TRUE(a);
 632     EXPECT_EQ(a.value(), 0.1f);
 633     EXPECT_EQ(a, b);
 634   }
 635
 636   {
 637     absl::optional<std::string> a;
 638     absl::optional<std::string> b("foo");
 639     a = b;
 640
 641     EXPECT_TRUE(a);
 642     EXPECT_EQ(a.value(), "foo");
 643     EXPECT_EQ(a, b);
 644   }
 645
 646   {
 647     absl::optional<TestObject> a;
 648     absl::optional<TestObject> b(TestObject(3, 0.1));
 649     a = b;
 650
 651     EXPECT_TRUE(!!a);
 652     EXPECT_TRUE(a.value() == TestObject(3, 0.1));
 653     EXPECT_TRUE(a == b);
 654   }
 655
 656   {
 657     absl::optional<TestObject> a(TestObject(4, 1.0));
 658     absl::optional<TestObject> b(TestObject(3, 0.1));
 659     a = b;
 660
 661     EXPECT_TRUE(!!a);
 662     EXPECT_TRUE(a.value() == TestObject(3, 0.1));
 663     EXPECT_TRUE(a == b);
 664   }
 665
 666   {
 667     absl::optional<DeletedMove> a(absl::in_place, 42);
 668     absl::optional<DeletedMove> b;
 669     b = a;
 670
 671     EXPECT_TRUE(!!a);
 672     EXPECT_TRUE(!!b);
 673     EXPECT_EQ(a->foo(), b->foo());
 674   }
 675
 676   {
 677     absl::optional<DeletedMove> a(absl::in_place, 42);
 678     absl::optional<DeletedMove> b(absl::in_place, 1);
 679     b = a;
 680
 681     EXPECT_TRUE(!!a);
 682     EXPECT_TRUE(!!b);
 683     EXPECT_EQ(a->foo(), b->foo());
 684   }
 685
 686   // Converting assignment.
 687   {
 688     absl::optional<int> a(absl::in_place, 1);
 689     absl::optional<double> b;
 690     b = a;
 691
 692     EXPECT_TRUE(!!a);
 693     EXPECT_TRUE(!!b);
 694     EXPECT_EQ(1, a.value());
 695     EXPECT_EQ(1.0, b.value());
 696   }
 697
 698   {
 699     absl::optional<int> a(absl::in_place, 42);
 700     absl::optional<double> b(absl::in_place, 1);
 701     b = a;
 702
 703     EXPECT_TRUE(!!a);
 704     EXPECT_TRUE(!!b);
 705     EXPECT_EQ(42, a.value());
 706     EXPECT_EQ(42.0, b.value());
 707   }
 708
 709   {
 710     absl::optional<int> a;
 711     absl::optional<double> b(absl::in_place, 1);
 712     b = a;
 713     EXPECT_FALSE(!!a);
 714     EXPECT_FALSE(!!b);
 715   }
 716 }
 717
 718 TEST(OptionalTest, AssignObject_rvalue) {
 719   {
 720     absl::optional<float> a;
 721     absl::optional<float> b(0.1f);
 722     a = std::move(b);
 723
 724     EXPECT_TRUE(a);
 725     EXPECT_TRUE(b);
 726     EXPECT_EQ(0.1f, a.value());
 727   }
 728
 729   {
 730     absl::optional<std::string> a;
 731     absl::optional<std::string> b("foo");
 732     a = std::move(b);
 733
 734     EXPECT_TRUE(a);
 735     EXPECT_TRUE(b);
 736     EXPECT_EQ("foo", a.value());
 737   }
 738
 739   {
 740     absl::optional<TestObject> a;
 741     absl::optional<TestObject> b(TestObject(3, 0.1));
 742     a = std::move(b);
 743
 744     EXPECT_TRUE(!!a);
 745     EXPECT_TRUE(!!b);
 746     EXPECT_TRUE(TestObject(3, 0.1) == a.value());
 747
 748     EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, a->state());
 749     EXPECT_EQ(TestObject::State::MOVED_FROM, b->state());
 750   }
 751
 752   {
 753     absl::optional<TestObject> a(TestObject(4, 1.0));
 754     absl::optional<TestObject> b(TestObject(3, 0.1));
 755     a = std::move(b);
 756
 757     EXPECT_TRUE(!!a);
 758     EXPECT_TRUE(!!b);
 759     EXPECT_TRUE(TestObject(3, 0.1) == a.value());
 760
 761     EXPECT_EQ(TestObject::State::MOVE_ASSIGNED, a->state());
 762     EXPECT_EQ(TestObject::State::MOVED_FROM, b->state());
 763   }
 764
 765   {
 766     absl::optional<DeletedMove> a(absl::in_place, 42);
 767     absl::optional<DeletedMove> b;
 768     b = std::move(a);
 769
 770     EXPECT_TRUE(!!a);
 771     EXPECT_TRUE(!!b);
 772     EXPECT_EQ(42, b->foo());
 773   }
 774
 775   {
 776     absl::optional<DeletedMove> a(absl::in_place, 42);
 777     absl::optional<DeletedMove> b(absl::in_place, 1);
 778     b = std::move(a);
 779
 780     EXPECT_TRUE(!!a);
 781     EXPECT_TRUE(!!b);
 782     EXPECT_EQ(42, b->foo());
 783   }
 784
 785   // Converting assignment.
 786   {
 787     absl::optional<int> a(absl::in_place, 1);
 788     absl::optional<double> b;
 789     b = std::move(a);
 790
 791     EXPECT_TRUE(!!a);
 792     EXPECT_TRUE(!!b);
 793     EXPECT_EQ(1.0, b.value());
 794   }
 795
 796   {
 797     absl::optional<int> a(absl::in_place, 42);
 798     absl::optional<double> b(absl::in_place, 1);
 799     b = std::move(a);
 800
 801     EXPECT_TRUE(!!a);
 802     EXPECT_TRUE(!!b);
 803     EXPECT_EQ(42.0, b.value());
 804   }
 805
 806   {
 807     absl::optional<int> a;
 808     absl::optional<double> b(absl::in_place, 1);
 809     b = std::move(a);
 810
 811     EXPECT_FALSE(!!a);
 812     EXPECT_FALSE(!!b);
 813   }
 814 }
 815
 816 TEST(OptionalTest, AssignNull) {
 817   {
 818     absl::optional<float> a(0.1f);
 819     absl::optional<float> b(0.2f);
 820     a = absl::nullopt;
 821     b = absl::nullopt;
 822     EXPECT_EQ(a, b);
 823   }
 824
 825   {
 826     absl::optional<std::string> a("foo");
 827     absl::optional<std::string> b("bar");
 828     a = absl::nullopt;
 829     b = absl::nullopt;
 830     EXPECT_EQ(a, b);
 831   }
 832
 833   {
 834     absl::optional<TestObject> a(TestObject(3, 0.1));
 835     absl::optional<TestObject> b(TestObject(4, 1.0));
 836     a = absl::nullopt;
 837     b = absl::nullopt;
 838     EXPECT_TRUE(a == b);
 839   }
 840 }
 841
 842 TEST(OptionalTest, AssignOverload) {
 843   struct Test1 {
 844     enum class State {
 845       CONSTRUCTED,
 846       MOVED,
 847     };
 848     State state = State::CONSTRUCTED;
 849   };
 850
 851   // Here, absl::optional<Test2> can be assigned from absl::optional<Test1>.  In
 852   // case of move, marks MOVED to Test1 instance.
 853   struct Test2 {
 854     enum class State {
 855       DEFAULT_CONSTRUCTED,
 856       COPY_CONSTRUCTED_FROM_TEST1,
 857       MOVE_CONSTRUCTED_FROM_TEST1,
 858       COPY_ASSIGNED_FROM_TEST1,
 859       MOVE_ASSIGNED_FROM_TEST1,
 860     };
 861
 862     Test2() = default;
 863     explicit Test2(const Test1& test1)
 864         : state(State::COPY_CONSTRUCTED_FROM_TEST1) {}
 865     explicit Test2(Test1&& test1) : state(State::MOVE_CONSTRUCTED_FROM_TEST1) {
 866       test1.state = Test1::State::MOVED;
 867     }
 868     Test2& operator=(const Test1& test1) {
 869       state = State::COPY_ASSIGNED_FROM_TEST1;
 870       return *this;
 871     }
 872     Test2& operator=(Test1&& test1) {
 873       state = State::MOVE_ASSIGNED_FROM_TEST1;
 874       test1.state = Test1::State::MOVED;
 875       return *this;
 876     }
 877
 878     State state = State::DEFAULT_CONSTRUCTED;
 879   };
 880
 881   {
 882     absl::optional<Test1> a(absl::in_place);
 883     absl::optional<Test2> b;
 884
 885     b = a;
 886     EXPECT_TRUE(!!a);
 887     EXPECT_TRUE(!!b);
 888     EXPECT_EQ(Test1::State::CONSTRUCTED, a->state);
 889     EXPECT_EQ(Test2::State::COPY_CONSTRUCTED_FROM_TEST1, b->state);
 890   }
 891
 892   {
 893     absl::optional<Test1> a(absl::in_place);
 894     absl::optional<Test2> b(absl::in_place);
 895
 896     b = a;
 897     EXPECT_TRUE(!!a);
 898     EXPECT_TRUE(!!b);
 899     EXPECT_EQ(Test1::State::CONSTRUCTED, a->state);
 900     EXPECT_EQ(Test2::State::COPY_ASSIGNED_FROM_TEST1, b->state);
 901   }
 902
 903   {
 904     absl::optional<Test1> a(absl::in_place);
 905     absl::optional<Test2> b;
 906
 907     b = std::move(a);
 908     EXPECT_TRUE(!!a);
 909     EXPECT_TRUE(!!b);
 910     EXPECT_EQ(Test1::State::MOVED, a->state);
 911     EXPECT_EQ(Test2::State::MOVE_CONSTRUCTED_FROM_TEST1, b->state);
 912   }
 913
 914   {
 915     absl::optional<Test1> a(absl::in_place);
 916     absl::optional<Test2> b(absl::in_place);
 917
 918     b = std::move(a);
 919     EXPECT_TRUE(!!a);
 920     EXPECT_TRUE(!!b);
 921     EXPECT_EQ(Test1::State::MOVED, a->state);
 922     EXPECT_EQ(Test2::State::MOVE_ASSIGNED_FROM_TEST1, b->state);
 923   }
 924
 925   // Similar to Test2, but Test3 also has copy/move ctor and assign operators
 926   // from absl::optional<Test1>, too. In this case, for a = b where a is
 927   // absl::optional<Test3> and b is absl::optional<Test1>,
 928   // absl::optional<T>::operator=(U&&) where U is absl::optional<Test1> should
 929   // be used rather than absl::optional<T>::operator=(absl::optional<U>&&) where
 930   // U is Test1.
 931   struct Test3 {
 932     enum class State {
 933       DEFAULT_CONSTRUCTED,
 934       COPY_CONSTRUCTED_FROM_TEST1,
 935       MOVE_CONSTRUCTED_FROM_TEST1,
 936       COPY_CONSTRUCTED_FROM_OPTIONAL_TEST1,
 937       MOVE_CONSTRUCTED_FROM_OPTIONAL_TEST1,
 938       COPY_ASSIGNED_FROM_TEST1,
 939       MOVE_ASSIGNED_FROM_TEST1,
 940       COPY_ASSIGNED_FROM_OPTIONAL_TEST1,
 941       MOVE_ASSIGNED_FROM_OPTIONAL_TEST1,
 942     };
 943
 944     Test3() = default;
 945     explicit Test3(const Test1& test1)
 946         : state(State::COPY_CONSTRUCTED_FROM_TEST1) {}
 947     explicit Test3(Test1&& test1) : state(State::MOVE_CONSTRUCTED_FROM_TEST1) {
 948       test1.state = Test1::State::MOVED;
 949     }
 950     explicit Test3(const absl::optional<Test1>& test1)
 951         : state(State::COPY_CONSTRUCTED_FROM_OPTIONAL_TEST1) {}
 952     explicit Test3(absl::optional<Test1>&& test1)
 953         : state(State::MOVE_CONSTRUCTED_FROM_OPTIONAL_TEST1) {
 954       // In the following senarios, given |test1| should always have value.
 955       DCHECK(test1.has_value());
 956       test1->state = Test1::State::MOVED;
 957     }
 958     Test3& operator=(const Test1& test1) {
 959       state = State::COPY_ASSIGNED_FROM_TEST1;
 960       return *this;
 961     }
 962     Test3& operator=(Test1&& test1) {
 963       state = State::MOVE_ASSIGNED_FROM_TEST1;
 964       test1.state = Test1::State::MOVED;
 965       return *this;
 966     }
 967     Test3& operator=(const absl::optional<Test1>& test1) {
 968       state = State::COPY_ASSIGNED_FROM_OPTIONAL_TEST1;
 969       return *this;
 970     }
 971     Test3& operator=(absl::optional<Test1>&& test1) {
 972       state = State::MOVE_ASSIGNED_FROM_OPTIONAL_TEST1;
 973       // In the following senarios, given |test1| should always have value.
 974       DCHECK(test1.has_value());
 975       test1->state = Test1::State::MOVED;
 976       return *this;
 977     }
 978
 979     State state = State::DEFAULT_CONSTRUCTED;
 980   };
 981
 982   {
 983     absl::optional<Test1> a(absl::in_place);
 984     absl::optional<Test3> b;
 985
 986     b = a;
 987     EXPECT_TRUE(!!a);
 988     EXPECT_TRUE(!!b);
 989     EXPECT_EQ(Test1::State::CONSTRUCTED, a->state);
 990     EXPECT_EQ(Test3::State::COPY_CONSTRUCTED_FROM_OPTIONAL_TEST1, b->state);
 991   }
 992
 993   {
 994     absl::optional<Test1> a(absl::in_place);
 995     absl::optional<Test3> b(absl::in_place);
 996
 997     b = a;
 998     EXPECT_TRUE(!!a);
 999     EXPECT_TRUE(!!b);
1000     EXPECT_EQ(Test1::State::CONSTRUCTED, a->state);
1001     EXPECT_EQ(Test3::State::COPY_ASSIGNED_FROM_OPTIONAL_TEST1, b->state);
1002   }
1003
1004   {
1005     absl::optional<Test1> a(absl::in_place);
1006     absl::optional<Test3> b;
1007
1008     b = std::move(a);
1009     EXPECT_TRUE(!!a);
1010     EXPECT_TRUE(!!b);
1011     EXPECT_EQ(Test1::State::MOVED, a->state);
1012     EXPECT_EQ(Test3::State::MOVE_CONSTRUCTED_FROM_OPTIONAL_TEST1, b->state);
1013   }
1014
1015   {
1016     absl::optional<Test1> a(absl::in_place);
1017     absl::optional<Test3> b(absl::in_place);
1018
1019     b = std::move(a);
1020     EXPECT_TRUE(!!a);
1021     EXPECT_TRUE(!!b);
1022     EXPECT_EQ(Test1::State::MOVED, a->state);
1023     EXPECT_EQ(Test3::State::MOVE_ASSIGNED_FROM_OPTIONAL_TEST1, b->state);
1024   }
1025 }
1026
1027 TEST(OptionalTest, OperatorStar) {
1028   {
1029     absl::optional<float> a(0.1f);
1030     EXPECT_EQ(a.value(), *a);
1031   }
1032
1033   {
1034     absl::optional<std::string> a("foo");
1035     EXPECT_EQ(a.value(), *a);
1036   }
1037
1038   {
1039     absl::optional<TestObject> a(TestObject(3, 0.1));
1040     EXPECT_EQ(a.value(), *a);
1041   }
1042 }
1043
1044 TEST(OptionalTest, OperatorStar_rvalue) {
1045   EXPECT_EQ(0.1f, *absl::optional<float>(0.1f));
1046   EXPECT_EQ(std::string("foo"), *absl::optional<std::string>("foo"));
1047   EXPECT_TRUE(TestObject(3, 0.1) ==
1048               *absl::optional<TestObject>(TestObject(3, 0.1)));
1049 }
1050
1051 TEST(OptionalTest, OperatorArrow) {
1052   absl::optional<TestObject> a(TestObject(3, 0.1));
1053   EXPECT_EQ(a->foo(), 3);
1054 }
1055
1056 TEST(OptionalTest, Value_rvalue) {
1057   EXPECT_EQ(0.1f, absl::optional<float>(0.1f).value());
1058   EXPECT_EQ(std::string("foo"), absl::optional<std::string>("foo").value());
1059   EXPECT_TRUE(TestObject(3, 0.1) ==
1060               absl::optional<TestObject>(TestObject(3, 0.1)).value());
1061 }
1062
1063 TEST(OptionalTest, ValueOr) {
1064   {
1065     absl::optional<float> a;
1066     EXPECT_EQ(0.0f, a.value_or(0.0f));
1067
1068     a = 0.1f;
1069     EXPECT_EQ(0.1f, a.value_or(0.0f));
1070
1071     a = absl::nullopt;
1072     EXPECT_EQ(0.0f, a.value_or(0.0f));
1073   }
1074
1075   // value_or() can be constexpr.
1076   {
1077     constexpr absl::optional<int> a(absl::in_place, 1);
1078     constexpr int value = a.value_or(10);
1079     EXPECT_EQ(1, value);
1080   }
1081   {
1082     constexpr absl::optional<int> a;
1083     constexpr int value = a.value_or(10);
1084     EXPECT_EQ(10, value);
1085   }
1086
1087   {
1088     absl::optional<std::string> a;
1089     EXPECT_EQ("bar", a.value_or("bar"));
1090
1091     a = std::string("foo");
1092     EXPECT_EQ(std::string("foo"), a.value_or("bar"));
1093
1094     a = absl::nullopt;
1095     EXPECT_EQ(std::string("bar"), a.value_or("bar"));
1096   }
1097
1098   {
1099     absl::optional<TestObject> a;
1100     EXPECT_TRUE(a.value_or(TestObject(1, 0.3)) == TestObject(1, 0.3));
1101
1102     a = TestObject(3, 0.1);
1103     EXPECT_TRUE(a.value_or(TestObject(1, 0.3)) == TestObject(3, 0.1));
1104
1105     a = absl::nullopt;
1106     EXPECT_TRUE(a.value_or(TestObject(1, 0.3)) == TestObject(1, 0.3));
1107   }
1108 }
1109
1110 TEST(OptionalTest, Swap_bothNoValue) {
1111   absl::optional<TestObject> a, b;
1112   a.swap(b);
1113
1114   EXPECT_FALSE(a);
1115   EXPECT_FALSE(b);
1116   EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42)));
1117   EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42)));
1118 }
1119
1120 TEST(OptionalTest, Swap_inHasValue) {
1121   absl::optional<TestObject> a(TestObject(1, 0.3));
1122   absl::optional<TestObject> b;
1123   a.swap(b);
1124
1125   EXPECT_FALSE(a);
1126
1127   EXPECT_TRUE(!!b);
1128   EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42)));
1129   EXPECT_TRUE(TestObject(1, 0.3) == b.value_or(TestObject(42, 0.42)));
1130 }
1131
1132 TEST(OptionalTest, Swap_outHasValue) {
1133   absl::optional<TestObject> a;
1134   absl::optional<TestObject> b(TestObject(1, 0.3));
1135   a.swap(b);
1136
1137   EXPECT_TRUE(!!a);
1138   EXPECT_FALSE(!!b);
1139   EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42)));
1140   EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42)));
1141 }
1142
1143 TEST(OptionalTest, Swap_bothValue) {
1144   absl::optional<TestObject> a(TestObject(0, 0.1));
1145   absl::optional<TestObject> b(TestObject(1, 0.3));
1146   a.swap(b);
1147
1148   EXPECT_TRUE(!!a);
1149   EXPECT_TRUE(!!b);
1150   EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42)));
1151   EXPECT_TRUE(TestObject(0, 0.1) == b.value_or(TestObject(42, 0.42)));
1152   EXPECT_EQ(TestObject::State::SWAPPED, a->state());
1153   EXPECT_EQ(TestObject::State::SWAPPED, b->state());
1154 }
1155
1156 TEST(OptionalTest, Emplace) {
1157   {
1158     absl::optional<float> a(0.1f);
1159     EXPECT_EQ(0.3f, a.emplace(0.3f));
1160
1161     EXPECT_TRUE(a);
1162     EXPECT_EQ(0.3f, a.value());
1163   }
1164
1165   {
1166     absl::optional<std::string> a("foo");
1167     EXPECT_EQ("bar", a.emplace("bar"));
1168
1169     EXPECT_TRUE(a);
1170     EXPECT_EQ("bar", a.value());
1171   }
1172
1173   {
1174     absl::optional<TestObject> a(TestObject(0, 0.1));
1175     EXPECT_EQ(TestObject(1, 0.2), a.emplace(TestObject(1, 0.2)));
1176
1177     EXPECT_TRUE(!!a);
1178     EXPECT_TRUE(TestObject(1, 0.2) == a.value());
1179   }
1180
1181   {
1182     absl::optional<std::vector<int>> a;
1183     auto& ref = a.emplace({2, 3});
1184     static_assert(std::is_same<std::vector<int>&, decltype(ref)>::value, "");
1185     EXPECT_TRUE(a);
1186     EXPECT_THAT(*a, ElementsAre(2, 3));
1187     EXPECT_EQ(&ref, &*a);
1188   }
1189
1190   {
1191     absl::optional<std::vector<int>> a;
1192     auto& ref = a.emplace({4, 5}, std::allocator<int>());
1193     static_assert(std::is_same<std::vector<int>&, decltype(ref)>::value, "");
1194     EXPECT_TRUE(a);
1195     EXPECT_THAT(*a, ElementsAre(4, 5));
1196     EXPECT_EQ(&ref, &*a);
1197   }
1198 }
1199
1200 TEST(OptionalTest, Equals_TwoEmpty) {
1201   absl::optional<int> a;
1202   absl::optional<int> b;
1203
1204   EXPECT_TRUE(a == b);
1205 }
1206
1207 TEST(OptionalTest, Equals_TwoEquals) {
1208   absl::optional<int> a(1);
1209   absl::optional<int> b(1);
1210
1211   EXPECT_TRUE(a == b);
1212 }
1213
1214 TEST(OptionalTest, Equals_OneEmpty) {
1215   absl::optional<int> a;
1216   absl::optional<int> b(1);
1217
1218   EXPECT_FALSE(a == b);
1219 }
1220
1221 TEST(OptionalTest, Equals_TwoDifferent) {
1222   absl::optional<int> a(0);
1223   absl::optional<int> b(1);
1224
1225   EXPECT_FALSE(a == b);
1226 }
1227
1228 TEST(OptionalTest, Equals_DifferentType) {
1229   absl::optional<int> a(0);
1230   absl::optional<double> b(0);
1231
1232   EXPECT_TRUE(a == b);
1233 }
1234
1235 TEST(OptionalTest, NotEquals_TwoEmpty) {
1236   absl::optional<int> a;
1237   absl::optional<int> b;
1238
1239   EXPECT_FALSE(a != b);
1240 }
1241
1242 TEST(OptionalTest, NotEquals_TwoEquals) {
1243   absl::optional<int> a(1);
1244   absl::optional<int> b(1);
1245
1246   EXPECT_FALSE(a != b);
1247 }
1248
1249 TEST(OptionalTest, NotEquals_OneEmpty) {
1250   absl::optional<int> a;
1251   absl::optional<int> b(1);
1252
1253   EXPECT_TRUE(a != b);
1254 }
1255
1256 TEST(OptionalTest, NotEquals_TwoDifferent) {
1257   absl::optional<int> a(0);
1258   absl::optional<int> b(1);
1259
1260   EXPECT_TRUE(a != b);
1261 }
1262
1263 TEST(OptionalTest, NotEquals_DifferentType) {
1264   absl::optional<int> a(0);
1265   absl::optional<double> b(0.0);
1266
1267   EXPECT_FALSE(a != b);
1268 }
1269
1270 TEST(OptionalTest, Less_LeftEmpty) {
1271   absl::optional<int> l;
1272   absl::optional<int> r(1);
1273
1274   EXPECT_TRUE(l < r);
1275 }
1276
1277 TEST(OptionalTest, Less_RightEmpty) {
1278   absl::optional<int> l(1);
1279   absl::optional<int> r;
1280
1281   EXPECT_FALSE(l < r);
1282 }
1283
1284 TEST(OptionalTest, Less_BothEmpty) {
1285   absl::optional<int> l;
1286   absl::optional<int> r;
1287
1288   EXPECT_FALSE(l < r);
1289 }
1290
1291 TEST(OptionalTest, Less_BothValues) {
1292   {
1293     absl::optional<int> l(1);
1294     absl::optional<int> r(2);
1295
1296     EXPECT_TRUE(l < r);
1297   }
1298   {
1299     absl::optional<int> l(2);
1300     absl::optional<int> r(1);
1301
1302     EXPECT_FALSE(l < r);
1303   }
1304   {
1305     absl::optional<int> l(1);
1306     absl::optional<int> r(1);
1307
1308     EXPECT_FALSE(l < r);
1309   }
1310 }
1311
1312 TEST(OptionalTest, Less_DifferentType) {
1313   absl::optional<int> l(1);
1314   absl::optional<double> r(2.0);
1315
1316   EXPECT_TRUE(l < r);
1317 }
1318
1319 TEST(OptionalTest, LessEq_LeftEmpty) {
1320   absl::optional<int> l;
1321   absl::optional<int> r(1);
1322
1323   EXPECT_TRUE(l <= r);
1324 }
1325
1326 TEST(OptionalTest, LessEq_RightEmpty) {
1327   absl::optional<int> l(1);
1328   absl::optional<int> r;
1329
1330   EXPECT_FALSE(l <= r);
1331 }
1332
1333 TEST(OptionalTest, LessEq_BothEmpty) {
1334   absl::optional<int> l;
1335   absl::optional<int> r;
1336
1337   EXPECT_TRUE(l <= r);
1338 }
1339
1340 TEST(OptionalTest, LessEq_BothValues) {
1341   {
1342     absl::optional<int> l(1);
1343     absl::optional<int> r(2);
1344
1345     EXPECT_TRUE(l <= r);
1346   }
1347   {
1348     absl::optional<int> l(2);
1349     absl::optional<int> r(1);
1350
1351     EXPECT_FALSE(l <= r);
1352   }
1353   {
1354     absl::optional<int> l(1);
1355     absl::optional<int> r(1);
1356
1357     EXPECT_TRUE(l <= r);
1358   }
1359 }
1360
1361 TEST(OptionalTest, LessEq_DifferentType) {
1362   absl::optional<int> l(1);
1363   absl::optional<double> r(2.0);
1364
1365   EXPECT_TRUE(l <= r);
1366 }
1367
1368 TEST(OptionalTest, Greater_BothEmpty) {
1369   absl::optional<int> l;
1370   absl::optional<int> r;
1371
1372   EXPECT_FALSE(l > r);
1373 }
1374
1375 TEST(OptionalTest, Greater_LeftEmpty) {
1376   absl::optional<int> l;
1377   absl::optional<int> r(1);
1378
1379   EXPECT_FALSE(l > r);
1380 }
1381
1382 TEST(OptionalTest, Greater_RightEmpty) {
1383   absl::optional<int> l(1);
1384   absl::optional<int> r;
1385
1386   EXPECT_TRUE(l > r);
1387 }
1388
1389 TEST(OptionalTest, Greater_BothValue) {
1390   {
1391     absl::optional<int> l(1);
1392     absl::optional<int> r(2);
1393
1394     EXPECT_FALSE(l > r);
1395   }
1396   {
1397     absl::optional<int> l(2);
1398     absl::optional<int> r(1);
1399
1400     EXPECT_TRUE(l > r);
1401   }
1402   {
1403     absl::optional<int> l(1);
1404     absl::optional<int> r(1);
1405
1406     EXPECT_FALSE(l > r);
1407   }
1408 }
1409
1410 TEST(OptionalTest, Greater_DifferentType) {
1411   absl::optional<int> l(1);
1412   absl::optional<double> r(2.0);
1413
1414   EXPECT_FALSE(l > r);
1415 }
1416
1417 TEST(OptionalTest, GreaterEq_BothEmpty) {
1418   absl::optional<int> l;
1419   absl::optional<int> r;
1420
1421   EXPECT_TRUE(l >= r);
1422 }
1423
1424 TEST(OptionalTest, GreaterEq_LeftEmpty) {
1425   absl::optional<int> l;
1426   absl::optional<int> r(1);
1427
1428   EXPECT_FALSE(l >= r);
1429 }
1430
1431 TEST(OptionalTest, GreaterEq_RightEmpty) {
1432   absl::optional<int> l(1);
1433   absl::optional<int> r;
1434
1435   EXPECT_TRUE(l >= r);
1436 }
1437
1438 TEST(OptionalTest, GreaterEq_BothValue) {
1439   {
1440     absl::optional<int> l(1);
1441     absl::optional<int> r(2);
1442
1443     EXPECT_FALSE(l >= r);
1444   }
1445   {
1446     absl::optional<int> l(2);
1447     absl::optional<int> r(1);
1448
1449     EXPECT_TRUE(l >= r);
1450   }
1451   {
1452     absl::optional<int> l(1);
1453     absl::optional<int> r(1);
1454
1455     EXPECT_TRUE(l >= r);
1456   }
1457 }
1458
1459 TEST(OptionalTest, GreaterEq_DifferentType) {
1460   absl::optional<int> l(1);
1461   absl::optional<double> r(2.0);
1462
1463   EXPECT_FALSE(l >= r);
1464 }
1465
1466 TEST(OptionalTest, OptNullEq) {
1467   {
1468     absl::optional<int> opt;
1469     EXPECT_TRUE(opt == absl::nullopt);
1470   }
1471   {
1472     absl::optional<int> opt(1);
1473     EXPECT_FALSE(opt == absl::nullopt);
1474   }
1475 }
1476
1477 TEST(OptionalTest, NullOptEq) {
1478   {
1479     absl::optional<int> opt;
1480     EXPECT_TRUE(absl::nullopt == opt);
1481   }
1482   {
1483     absl::optional<int> opt(1);
1484     EXPECT_FALSE(absl::nullopt == opt);
1485   }
1486 }
1487
1488 TEST(OptionalTest, OptNullNotEq) {
1489   {
1490     absl::optional<int> opt;
1491     EXPECT_FALSE(opt != absl::nullopt);
1492   }
1493   {
1494     absl::optional<int> opt(1);
1495     EXPECT_TRUE(opt != absl::nullopt);
1496   }
1497 }
1498
1499 TEST(OptionalTest, NullOptNotEq) {
1500   {
1501     absl::optional<int> opt;
1502     EXPECT_FALSE(absl::nullopt != opt);
1503   }
1504   {
1505     absl::optional<int> opt(1);
1506     EXPECT_TRUE(absl::nullopt != opt);
1507   }
1508 }
1509
1510 TEST(OptionalTest, OptNullLower) {
1511   {
1512     absl::optional<int> opt;
1513     EXPECT_FALSE(opt < absl::nullopt);
1514   }
1515   {
1516     absl::optional<int> opt(1);
1517     EXPECT_FALSE(opt < absl::nullopt);
1518   }
1519 }
1520
1521 TEST(OptionalTest, NullOptLower) {
1522   {
1523     absl::optional<int> opt;
1524     EXPECT_FALSE(absl::nullopt < opt);
1525   }
1526   {
1527     absl::optional<int> opt(1);
1528     EXPECT_TRUE(absl::nullopt < opt);
1529   }
1530 }
1531
1532 TEST(OptionalTest, OptNullLowerEq) {
1533   {
1534     absl::optional<int> opt;
1535     EXPECT_TRUE(opt <= absl::nullopt);
1536   }
1537   {
1538     absl::optional<int> opt(1);
1539     EXPECT_FALSE(opt <= absl::nullopt);
1540   }
1541 }
1542
1543 TEST(OptionalTest, NullOptLowerEq) {
1544   {
1545     absl::optional<int> opt;
1546     EXPECT_TRUE(absl::nullopt <= opt);
1547   }
1548   {
1549     absl::optional<int> opt(1);
1550     EXPECT_TRUE(absl::nullopt <= opt);
1551   }
1552 }
1553
1554 TEST(OptionalTest, OptNullGreater) {
1555   {
1556     absl::optional<int> opt;
1557     EXPECT_FALSE(opt > absl::nullopt);
1558   }
1559   {
1560     absl::optional<int> opt(1);
1561     EXPECT_TRUE(opt > absl::nullopt);
1562   }
1563 }
1564
1565 TEST(OptionalTest, NullOptGreater) {
1566   {
1567     absl::optional<int> opt;
1568     EXPECT_FALSE(absl::nullopt > opt);
1569   }
1570   {
1571     absl::optional<int> opt(1);
1572     EXPECT_FALSE(absl::nullopt > opt);
1573   }
1574 }
1575
1576 TEST(OptionalTest, OptNullGreaterEq) {
1577   {
1578     absl::optional<int> opt;
1579     EXPECT_TRUE(opt >= absl::nullopt);
1580   }
1581   {
1582     absl::optional<int> opt(1);
1583     EXPECT_TRUE(opt >= absl::nullopt);
1584   }
1585 }
1586
1587 TEST(OptionalTest, NullOptGreaterEq) {
1588   {
1589     absl::optional<int> opt;
1590     EXPECT_TRUE(absl::nullopt >= opt);
1591   }
1592   {
1593     absl::optional<int> opt(1);
1594     EXPECT_FALSE(absl::nullopt >= opt);
1595   }
1596 }
1597
1598 TEST(OptionalTest, ValueEq_Empty) {
1599   absl::optional<int> opt;
1600   EXPECT_FALSE(opt == 1);
1601 }
1602
1603 TEST(OptionalTest, ValueEq_NotEmpty) {
1604   {
1605     absl::optional<int> opt(0);
1606     EXPECT_FALSE(opt == 1);
1607   }
1608   {
1609     absl::optional<int> opt(1);
1610     EXPECT_TRUE(opt == 1);
1611   }
1612 }
1613
1614 TEST(OptionalTest, ValueEq_DifferentType) {
1615   absl::optional<int> opt(0);
1616   EXPECT_TRUE(opt == 0.0);
1617 }
1618
1619 TEST(OptionalTest, EqValue_Empty) {
1620   absl::optional<int> opt;
1621   EXPECT_FALSE(1 == opt);
1622 }
1623
1624 TEST(OptionalTest, EqValue_NotEmpty) {
1625   {
1626     absl::optional<int> opt(0);
1627     EXPECT_FALSE(1 == opt);
1628   }
1629   {
1630     absl::optional<int> opt(1);
1631     EXPECT_TRUE(1 == opt);
1632   }
1633 }
1634
1635 TEST(OptionalTest, EqValue_DifferentType) {
1636   absl::optional<int> opt(0);
1637   EXPECT_TRUE(0.0 == opt);
1638 }
1639
1640 TEST(OptionalTest, ValueNotEq_Empty) {
1641   absl::optional<int> opt;
1642   EXPECT_TRUE(opt != 1);
1643 }
1644
1645 TEST(OptionalTest, ValueNotEq_NotEmpty) {
1646   {
1647     absl::optional<int> opt(0);
1648     EXPECT_TRUE(opt != 1);
1649   }
1650   {
1651     absl::optional<int> opt(1);
1652     EXPECT_FALSE(opt != 1);
1653   }
1654 }
1655
1656 TEST(OptionalTest, ValueNotEq_DifferentType) {
1657   absl::optional<int> opt(0);
1658   EXPECT_FALSE(opt != 0.0);
1659 }
1660
1661 TEST(OptionalTest, NotEqValue_Empty) {
1662   absl::optional<int> opt;
1663   EXPECT_TRUE(1 != opt);
1664 }
1665
1666 TEST(OptionalTest, NotEqValue_NotEmpty) {
1667   {
1668     absl::optional<int> opt(0);
1669     EXPECT_TRUE(1 != opt);
1670   }
1671   {
1672     absl::optional<int> opt(1);
1673     EXPECT_FALSE(1 != opt);
1674   }
1675 }
1676
1677 TEST(OptionalTest, NotEqValue_DifferentType) {
1678   absl::optional<int> opt(0);
1679   EXPECT_FALSE(0.0 != opt);
1680 }
1681
1682 TEST(OptionalTest, ValueLess_Empty) {
1683   absl::optional<int> opt;
1684   EXPECT_TRUE(opt < 1);
1685 }
1686
1687 TEST(OptionalTest, ValueLess_NotEmpty) {
1688   {
1689     absl::optional<int> opt(0);
1690     EXPECT_TRUE(opt < 1);
1691   }
1692   {
1693     absl::optional<int> opt(1);
1694     EXPECT_FALSE(opt < 1);
1695   }
1696   {
1697     absl::optional<int> opt(2);
1698     EXPECT_FALSE(opt < 1);
1699   }
1700 }
1701
1702 TEST(OptionalTest, ValueLess_DifferentType) {
1703   absl::optional<int> opt(0);
1704   EXPECT_TRUE(opt < 1.0);
1705 }
1706
1707 TEST(OptionalTest, LessValue_Empty) {
1708   absl::optional<int> opt;
1709   EXPECT_FALSE(1 < opt);
1710 }
1711
1712 TEST(OptionalTest, LessValue_NotEmpty) {
1713   {
1714     absl::optional<int> opt(0);
1715     EXPECT_FALSE(1 < opt);
1716   }
1717   {
1718     absl::optional<int> opt(1);
1719     EXPECT_FALSE(1 < opt);
1720   }
1721   {
1722     absl::optional<int> opt(2);
1723     EXPECT_TRUE(1 < opt);
1724   }
1725 }
1726
1727 TEST(OptionalTest, LessValue_DifferentType) {
1728   absl::optional<int> opt(0);
1729   EXPECT_FALSE(0.0 < opt);
1730 }
1731
1732 TEST(OptionalTest, ValueLessEq_Empty) {
1733   absl::optional<int> opt;
1734   EXPECT_TRUE(opt <= 1);
1735 }
1736
1737 TEST(OptionalTest, ValueLessEq_NotEmpty) {
1738   {
1739     absl::optional<int> opt(0);
1740     EXPECT_TRUE(opt <= 1);
1741   }
1742   {
1743     absl::optional<int> opt(1);
1744     EXPECT_TRUE(opt <= 1);
1745   }
1746   {
1747     absl::optional<int> opt(2);
1748     EXPECT_FALSE(opt <= 1);
1749   }
1750 }
1751
1752 TEST(OptionalTest, ValueLessEq_DifferentType) {
1753   absl::optional<int> opt(0);
1754   EXPECT_TRUE(opt <= 0.0);
1755 }
1756
1757 TEST(OptionalTest, LessEqValue_Empty) {
1758   absl::optional<int> opt;
1759   EXPECT_FALSE(1 <= opt);
1760 }
1761
1762 TEST(OptionalTest, LessEqValue_NotEmpty) {
1763   {
1764     absl::optional<int> opt(0);
1765     EXPECT_FALSE(1 <= opt);
1766   }
1767   {
1768     absl::optional<int> opt(1);
1769     EXPECT_TRUE(1 <= opt);
1770   }
1771   {
1772     absl::optional<int> opt(2);
1773     EXPECT_TRUE(1 <= opt);
1774   }
1775 }
1776
1777 TEST(OptionalTest, LessEqValue_DifferentType) {
1778   absl::optional<int> opt(0);
1779   EXPECT_TRUE(0.0 <= opt);
1780 }
1781
1782 TEST(OptionalTest, ValueGreater_Empty) {
1783   absl::optional<int> opt;
1784   EXPECT_FALSE(opt > 1);
1785 }
1786
1787 TEST(OptionalTest, ValueGreater_NotEmpty) {
1788   {
1789     absl::optional<int> opt(0);
1790     EXPECT_FALSE(opt > 1);
1791   }
1792   {
1793     absl::optional<int> opt(1);
1794     EXPECT_FALSE(opt > 1);
1795   }
1796   {
1797     absl::optional<int> opt(2);
1798     EXPECT_TRUE(opt > 1);
1799   }
1800 }
1801
1802 TEST(OptionalTest, ValueGreater_DifferentType) {
1803   absl::optional<int> opt(0);
1804   EXPECT_FALSE(opt > 0.0);
1805 }
1806
1807 TEST(OptionalTest, GreaterValue_Empty) {
1808   absl::optional<int> opt;
1809   EXPECT_TRUE(1 > opt);
1810 }
1811
1812 TEST(OptionalTest, GreaterValue_NotEmpty) {
1813   {
1814     absl::optional<int> opt(0);
1815     EXPECT_TRUE(1 > opt);
1816   }
1817   {
1818     absl::optional<int> opt(1);
1819     EXPECT_FALSE(1 > opt);
1820   }
1821   {
1822     absl::optional<int> opt(2);
1823     EXPECT_FALSE(1 > opt);
1824   }
1825 }
1826
1827 TEST(OptionalTest, GreaterValue_DifferentType) {
1828   absl::optional<int> opt(0);
1829   EXPECT_FALSE(0.0 > opt);
1830 }
1831
1832 TEST(OptionalTest, ValueGreaterEq_Empty) {
1833   absl::optional<int> opt;
1834   EXPECT_FALSE(opt >= 1);
1835 }
1836
1837 TEST(OptionalTest, ValueGreaterEq_NotEmpty) {
1838   {
1839     absl::optional<int> opt(0);
1840     EXPECT_FALSE(opt >= 1);
1841   }
1842   {
1843     absl::optional<int> opt(1);
1844     EXPECT_TRUE(opt >= 1);
1845   }
1846   {
1847     absl::optional<int> opt(2);
1848     EXPECT_TRUE(opt >= 1);
1849   }
1850 }
1851
1852 TEST(OptionalTest, ValueGreaterEq_DifferentType) {
1853   absl::optional<int> opt(0);
1854   EXPECT_TRUE(opt <= 0.0);
1855 }
1856
1857 TEST(OptionalTest, GreaterEqValue_Empty) {
1858   absl::optional<int> opt;
1859   EXPECT_TRUE(1 >= opt);
1860 }
1861
1862 TEST(OptionalTest, GreaterEqValue_NotEmpty) {
1863   {
1864     absl::optional<int> opt(0);
1865     EXPECT_TRUE(1 >= opt);
1866   }
1867   {
1868     absl::optional<int> opt(1);
1869     EXPECT_TRUE(1 >= opt);
1870   }
1871   {
1872     absl::optional<int> opt(2);
1873     EXPECT_FALSE(1 >= opt);
1874   }
1875 }
1876
1877 TEST(OptionalTest, GreaterEqValue_DifferentType) {
1878   absl::optional<int> opt(0);
1879   EXPECT_TRUE(0.0 >= opt);
1880 }
1881
1882 TEST(OptionalTest, NotEquals) {
1883   {
1884     absl::optional<float> a(0.1f);
1885     absl::optional<float> b(0.2f);
1886     EXPECT_NE(a, b);
1887   }
1888
1889   {
1890     absl::optional<std::string> a("foo");
1891     absl::optional<std::string> b("bar");
1892     EXPECT_NE(a, b);
1893   }
1894
1895   {
1896     absl::optional<int> a(1);
1897     absl::optional<double> b(2);
1898     EXPECT_NE(a, b);
1899   }
1900
1901   {
1902     absl::optional<TestObject> a(TestObject(3, 0.1));
1903     absl::optional<TestObject> b(TestObject(4, 1.0));
1904     EXPECT_TRUE(a != b);
1905   }
1906 }
1907
1908 TEST(OptionalTest, NotEqualsNull) {
1909   {
1910     absl::optional<float> a(0.1f);
1911     absl::optional<float> b(0.1f);
1912     b = absl::nullopt;
1913     EXPECT_NE(a, b);
1914   }
1915
1916   {
1917     absl::optional<std::string> a("foo");
1918     absl::optional<std::string> b("foo");
1919     b = absl::nullopt;
1920     EXPECT_NE(a, b);
1921   }
1922
1923   {
1924     absl::optional<TestObject> a(TestObject(3, 0.1));
1925     absl::optional<TestObject> b(TestObject(3, 0.1));
1926     b = absl::nullopt;
1927     EXPECT_TRUE(a != b);
1928   }
1929 }
1930
1931 TEST(OptionalTest, MakeOptional) {
1932   {
1933     absl::optional<float> o = absl::make_optional(32.f);
1934     EXPECT_TRUE(o);
1935     EXPECT_EQ(32.f, *o);
1936
1937     float value = 3.f;
1938     o = absl::make_optional(std::move(value));
1939     EXPECT_TRUE(o);
1940     EXPECT_EQ(3.f, *o);
1941   }
1942
1943   {
1944     absl::optional<std::string> o = absl::make_optional(std::string("foo"));
1945     EXPECT_TRUE(o);
1946     EXPECT_EQ("foo", *o);
1947
1948     std::string value = "bar";
1949     o = absl::make_optional(std::move(value));
1950     EXPECT_TRUE(o);
1951     EXPECT_EQ(std::string("bar"), *o);
1952   }
1953
1954   {
1955     absl::optional<TestObject> o = absl::make_optional(TestObject(3, 0.1));
1956     EXPECT_TRUE(!!o);
1957     EXPECT_TRUE(TestObject(3, 0.1) == *o);
1958
1959     TestObject value = TestObject(0, 0.42);
1960     o = absl::make_optional(std::move(value));
1961     EXPECT_TRUE(!!o);
1962     EXPECT_TRUE(TestObject(0, 0.42) == *o);
1963     EXPECT_EQ(TestObject::State::MOVED_FROM, value.state());
1964     EXPECT_EQ(TestObject::State::MOVE_ASSIGNED, o->state());
1965
1966     EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED,
1967               absl::make_optional(std::move(value))->state());
1968   }
1969
1970   {
1971     struct Test {
1972       Test(int a, double b, bool c) : a(a), b(b), c(c) {}
1973
1974       int a;
1975       double b;
1976       bool c;
1977     };
1978
1979     absl::optional<Test> o = absl::make_optional<Test>(1, 2.0, true);
1980     EXPECT_TRUE(!!o);
1981     EXPECT_EQ(1, o->a);
1982     EXPECT_EQ(2.0, o->b);
1983     EXPECT_TRUE(o->c);
1984   }
1985
1986   {
1987     auto str1 = absl::make_optional<std::string>({'1', '2', '3'});
1988     EXPECT_EQ("123", *str1);
1989
1990     auto str2 = absl::make_optional<std::string>({'a', 'b', 'c'},
1991                                                  std::allocator<char>());
1992     EXPECT_EQ("abc", *str2);
1993   }
1994 }
1995
1996 TEST(OptionalTest, NonMemberSwap_bothNoValue) {
1997   absl::optional<TestObject> a, b;
1998   absl::swap(a, b);
1999
2000   EXPECT_FALSE(!!a);
2001   EXPECT_FALSE(!!b);
2002   EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42)));
2003   EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42)));
2004 }
2005
2006 TEST(OptionalTest, NonMemberSwap_inHasValue) {
2007   absl::optional<TestObject> a(TestObject(1, 0.3));
2008   absl::optional<TestObject> b;
2009   absl::swap(a, b);
2010
2011   EXPECT_FALSE(!!a);
2012   EXPECT_TRUE(!!b);
2013   EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42)));
2014   EXPECT_TRUE(TestObject(1, 0.3) == b.value_or(TestObject(42, 0.42)));
2015 }
2016
2017 TEST(OptionalTest, NonMemberSwap_outHasValue) {
2018   absl::optional<TestObject> a;
2019   absl::optional<TestObject> b(TestObject(1, 0.3));
2020   absl::swap(a, b);
2021
2022   EXPECT_TRUE(!!a);
2023   EXPECT_FALSE(!!b);
2024   EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42)));
2025   EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42)));
2026 }
2027
2028 TEST(OptionalTest, NonMemberSwap_bothValue) {
2029   absl::optional<TestObject> a(TestObject(0, 0.1));
2030   absl::optional<TestObject> b(TestObject(1, 0.3));
2031   absl::swap(a, b);
2032
2033   EXPECT_TRUE(!!a);
2034   EXPECT_TRUE(!!b);
2035   EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42)));
2036   EXPECT_TRUE(TestObject(0, 0.1) == b.value_or(TestObject(42, 0.42)));
2037   EXPECT_EQ(TestObject::State::SWAPPED, a->state());
2038   EXPECT_EQ(TestObject::State::SWAPPED, b->state());
2039 }
2040
2041 TEST(OptionalTest, Hash_OptionalReflectsInternal) {
2042   {
2043     std::hash<int> int_hash;
2044     std::hash<absl::optional<int>> opt_int_hash;
2045
2046     EXPECT_EQ(int_hash(1), opt_int_hash(absl::optional<int>(1)));
2047   }
2048
2049   {
2050     std::hash<std::string> str_hash;
2051     std::hash<absl::optional<std::string>> opt_str_hash;
2052
2053     EXPECT_EQ(str_hash(std::string("foobar")),
2054               opt_str_hash(absl::optional<std::string>(std::string("foobar"))));
2055   }
2056 }
2057
2058 TEST(OptionalTest, Hash_NullOptEqualsNullOpt) {
2059   std::hash<absl::optional<int>> opt_int_hash;
2060   std::hash<absl::optional<std::string>> opt_str_hash;
2061
2062   EXPECT_EQ(opt_str_hash(absl::optional<std::string>()),
2063             opt_int_hash(absl::optional<int>()));
2064 }
2065
2066 TEST(OptionalTest, Hash_UseInSet) {
2067   std::set<absl::optional<int>> setOptInt;
2068
2069   EXPECT_EQ(setOptInt.end(), setOptInt.find(42));
2070
2071   setOptInt.insert(absl::optional<int>(3));
2072   EXPECT_EQ(setOptInt.end(), setOptInt.find(42));
2073   EXPECT_NE(setOptInt.end(), setOptInt.find(3));
2074 }
2075
2076 TEST(OptionalTest, HasValue) {
2077   absl::optional<int> a;
2078   EXPECT_FALSE(a.has_value());
2079
2080   a = 42;
2081   EXPECT_TRUE(a.has_value());
2082
2083   a = absl::nullopt;
2084   EXPECT_FALSE(a.has_value());
2085
2086   a = 0;
2087   EXPECT_TRUE(a.has_value());
2088
2089   a = absl::optional<int>();
2090   EXPECT_FALSE(a.has_value());
2091 }
2092
2093 TEST(OptionalTest, Reset_int) {
2094   absl::optional<int> a(0);
2095   EXPECT_TRUE(a.has_value());
2096   EXPECT_EQ(0, a.value());
2097
2098   a.reset();
2099   EXPECT_FALSE(a.has_value());
2100   EXPECT_EQ(-1, a.value_or(-1));
2101 }
2102
2103 TEST(OptionalTest, Reset_Object) {
2104   absl::optional<TestObject> a(TestObject(0, 0.1));
2105   EXPECT_TRUE(a.has_value());
2106   EXPECT_EQ(TestObject(0, 0.1), a.value());
2107
2108   a.reset();
2109   EXPECT_FALSE(a.has_value());
2110   EXPECT_EQ(TestObject(42, 0.0), a.value_or(TestObject(42, 0.0)));
2111 }
2112
2113 TEST(OptionalTest, Reset_NoOp) {
2114   absl::optional<int> a;
2115   EXPECT_FALSE(a.has_value());
2116
2117   a.reset();
2118   EXPECT_FALSE(a.has_value());
2119 }
2120
2121 TEST(OptionalTest, AssignFromRValue) {
2122   absl::optional<TestObject> a;
2123   EXPECT_FALSE(a.has_value());
2124
2125   TestObject obj;
2126   a = std::move(obj);
2127   EXPECT_TRUE(a.has_value());
2128   EXPECT_EQ(1, a->move_ctors_count());
2129 }
2130
2131 TEST(OptionalTest, DontCallDefaultCtor) {
2132   absl::optional<DeletedDefaultConstructor> a;
2133   EXPECT_FALSE(a.has_value());
2134
2135   a = absl::make_optional<DeletedDefaultConstructor>(42);
2136   EXPECT_TRUE(a.has_value());
2137   EXPECT_EQ(42, a->foo());
2138 }
2139
2140 TEST(OptionalTest, DontCallNewMemberFunction) {
2141   absl::optional<DeleteNewOperators> a;
2142   EXPECT_FALSE(a.has_value());
2143
2144   a = DeleteNewOperators();
2145   EXPECT_TRUE(a.has_value());
2146 }
2147
2148 TEST(OptionalTest, DereferencingNoValueCrashes) {
2149   class C {
2150    public:
2151     void Method() const {}
2152   };
2153
2154   {
2155     const absl::optional<C> const_optional;
2156     EXPECT_DEATH_IF_SUPPORTED(const_optional.value(), "");
2157     EXPECT_DEATH_IF_SUPPORTED(const_optional->Method(), "");
2158     EXPECT_DEATH_IF_SUPPORTED(*const_optional, "");
2159     EXPECT_DEATH_IF_SUPPORTED(*std::move(const_optional), "");
2160   }
2161
2162   {
2163     absl::optional<C> non_const_optional;
2164     EXPECT_DEATH_IF_SUPPORTED(non_const_optional.value(), "");
2165     EXPECT_DEATH_IF_SUPPORTED(non_const_optional->Method(), "");
2166     EXPECT_DEATH_IF_SUPPORTED(*non_const_optional, "");
2167     EXPECT_DEATH_IF_SUPPORTED(*std::move(non_const_optional), "");
2168   }
2169 }
2170
2171 TEST(OptionalTest, Noexcept) {
2172   // Trivial copy ctor, non-trivial move ctor, nothrow move assign.
2173   struct Test1 {
2174     Test1(const Test1&) = default;
2175     Test1(Test1&&) {}
2176     Test1& operator=(Test1&&) = default;
2177   };
2178   // Non-trivial copy ctor, trivial move ctor, throw move assign.
2179   struct Test2 {
2180     Test2(const Test2&) {}
2181     Test2(Test2&&) = default;
2182     Test2& operator=(Test2&&) { return *this; }
2183   };
2184   // Trivial copy ctor, non-trivial nothrow move ctor.
2185   struct Test3 {
2186     Test3(const Test3&) = default;
2187     Test3(Test3&&) noexcept {}
2188   };
2189   // Non-trivial copy ctor, non-trivial nothrow move ctor.
2190   struct Test4 {
2191     Test4(const Test4&) {}
2192     Test4(Test4&&) noexcept {}
2193   };
2194   // Non-trivial copy ctor, non-trivial move ctor.
2195   struct Test5 {
2196     Test5(const Test5&) {}
2197     Test5(Test5&&) {}
2198   };
2199
2200   static_assert(
2201       noexcept(absl::optional<int>(std::declval<absl::optional<int>>())),
2202       "move constructor for noexcept move-constructible T must be noexcept "
2203       "(trivial copy, trivial move)");
2204   static_assert(
2205       !noexcept(absl::optional<Test1>(std::declval<absl::optional<Test1>>())),
2206       "move constructor for non-noexcept move-constructible T must not be "
2207       "noexcept (trivial copy)");
2208   static_assert(
2209       noexcept(absl::optional<Test2>(std::declval<absl::optional<Test2>>())),
2210       "move constructor for noexcept move-constructible T must be noexcept "
2211       "(non-trivial copy, trivial move)");
2212   static_assert(
2213       noexcept(absl::optional<Test3>(std::declval<absl::optional<Test3>>())),
2214       "move constructor for noexcept move-constructible T must be noexcept "
2215       "(trivial copy, non-trivial move)");
2216   static_assert(
2217       noexcept(absl::optional<Test4>(std::declval<absl::optional<Test4>>())),
2218       "move constructor for noexcept move-constructible T must be noexcept "
2219       "(non-trivial copy, non-trivial move)");
2220   static_assert(
2221       !noexcept(absl::optional<Test5>(std::declval<absl::optional<Test5>>())),
2222       "move constructor for non-noexcept move-constructible T must not be "
2223       "noexcept (non-trivial copy)");
2224
2225   static_assert(noexcept(std::declval<absl::optional<int>>() =
2226                              std::declval<absl::optional<int>>()),
2227                 "move assign for noexcept move-constructible/move-assignable T "
2228                 "must be noexcept");
2229   static_assert(
2230       !noexcept(std::declval<absl::optional<Test1>>() =
2231                     std::declval<absl::optional<Test1>>()),
2232       "move assign for non-noexcept move-constructible T must not be noexcept");
2233   static_assert(
2234       !noexcept(std::declval<absl::optional<Test2>>() =
2235                     std::declval<absl::optional<Test2>>()),
2236       "move assign for non-noexcept move-assignable T must not be noexcept");
2237 }
2238
2239 TEST(OptionalTest, OverrideAddressOf) {
2240   // Objects with an overloaded address-of should not trigger the overload for
2241   // arrow or copy assignment.
2242   static_assert(std::is_trivially_destructible<
2243                     TriviallyDestructibleOverloadAddressOf>::value,
2244                 "Trivially...AddressOf must be trivially destructible.");
2245   absl::optional<TriviallyDestructibleOverloadAddressOf> optional;
2246   TriviallyDestructibleOverloadAddressOf n;
2247   optional = n;
2248
2249   // operator->() should not call address-of either, for either const or non-
2250   // const calls.  It's not strictly necessary that we call a nonconst method
2251   // to test the non-const operator->(), but it makes it very clear that the
2252   // compiler can't chose the const operator->().
2253   optional->nonconst_method();
2254   const auto& const_optional = optional;
2255   const_optional->const_method();
2256
2257   static_assert(!std::is_trivially_destructible<
2258                     NonTriviallyDestructibleOverloadAddressOf>::value,
2259                 "NotTrivially...AddressOf must not be trivially destructible.");
2260   absl::optional<NonTriviallyDestructibleOverloadAddressOf> nontrivial_optional;
2261   NonTriviallyDestructibleOverloadAddressOf n1;
2262   nontrivial_optional = n1;
2263 }
2264
2265 }  // namespace base