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