Make base::Optional trivially destructible when possible.

base/optional_unittest.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/optional.h"
 
 #include <set>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 namespace {
 
 // Object used to test complex object with Optional<T> in addition of the move
 // semantics.
 class TestObject {
  public:
   enum class State {
     DEFAULT_CONSTRUCTED,
     VALUE_CONSTRUCTED,
     COPY_CONSTRUCTED,
     MOVE_CONSTRUCTED,
     MOVED_FROM,
+    COPY_ASSIGNED,
+    MOVE_ASSIGNED,
+    SWAPPED,
   };
 
   TestObject() : foo_(0), bar_(0.0), state_(State::DEFAULT_CONSTRUCTED) {}
 
   TestObject(int foo, double bar)
       : foo_(foo), bar_(bar), state_(State::VALUE_CONSTRUCTED) {}
 
   TestObject(const TestObject& other)
       : foo_(other.foo_), bar_(other.bar_), state_(State::COPY_CONSTRUCTED) {}
 
   TestObject(TestObject&& other)
       : foo_(std::move(other.foo_)),
         bar_(std::move(other.bar_)),
         state_(State::MOVE_CONSTRUCTED) {
     other.state_ = State::MOVED_FROM;
   }
 
   TestObject& operator=(const TestObject& other) {
     foo_ = other.foo_;
     bar_ = other.bar_;
-    state_ = State::COPY_CONSTRUCTED;
+    state_ = State::COPY_ASSIGNED;
     return *this;
   }
 
+  TestObject& operator=(TestObject&& other) {
+    foo_ = other.foo_;
+    bar_ = other.bar_;
+    state_ = State::MOVE_ASSIGNED;
+    other.state_ = State::MOVED_FROM;
+    return *this;
+  }
+
+  void Swap(TestObject* other) {
+    using std::swap;
+    swap(foo_, other->foo_);
+    swap(bar_, other->bar_);
+    state_ = State::SWAPPED;
+    other->state_ = State::SWAPPED;
+  }
+
   bool operator==(const TestObject& other) const {
     return foo_ == other.foo_ && bar_ == other.bar_;
   }
 
   int foo() const { return foo_; }
   State state() const { return state_; }
 
  private:
   int foo_;
   double bar_;
   State state_;
 };
 
+// Implementing Swappable concept.
+void swap(TestObject& lhs, TestObject& rhs) {
+  lhs.Swap(&rhs);
+}
+
+class NonTriviallyDestructible {
+  ~NonTriviallyDestructible() {}
+};
+
 }  // anonymous namespace
 
+static_assert(is_trivially_destructible<Optional<int>>::value,
+              "OptionalIsTriviallyDestructible");
+
+static_assert(
+    !is_trivially_destructible<Optional<NonTriviallyDestructible>>::value,
+    "OptionalIsTriviallyDestructible");
+
 TEST(OptionalTest, DefaultConstructor) {
   {
     Optional<float> o;
     EXPECT_FALSE(o);
   }
 
   {
     Optional<std::string> o;
     EXPECT_FALSE(o);
   }
@@ skipping 134 matching lines @@
     EXPECT_EQ("foo", a.value());
   }
 
   {
     Optional<TestObject> a(base::in_place, 0, 0.1);
     EXPECT_TRUE(!!a);
     EXPECT_TRUE(TestObject(0, 0.1) == a.value());
   }
 }
 
+TEST(OptionalTest, NulloptConstructor) {
+  Optional<int> a = base::nullopt;
+  EXPECT_FALSE(a);
+}
+
 TEST(OptionalTest, AssignValue) {
   {
     Optional<float> a;
     EXPECT_FALSE(a);
     a = 0.1f;
     EXPECT_TRUE(a);
 
     Optional<float> b(0.1f);
     EXPECT_TRUE(a == b);
   }
@@ skipping 10 matching lines @@
 
   {
     Optional<TestObject> a;
     EXPECT_FALSE(!!a);
     a = TestObject(3, 0.1);
     EXPECT_TRUE(!!a);
 
     Optional<TestObject> b(TestObject(3, 0.1));
     EXPECT_TRUE(a == b);
   }
+
+  {
+    Optional<TestObject> a = TestObject(4, 1.0);
+    EXPECT_TRUE(!!a);
+    a = TestObject(3, 0.1);
+    EXPECT_TRUE(!!a);
+
+    Optional<TestObject> b(TestObject(3, 0.1));
+    EXPECT_TRUE(a == b);
+  }
 }
 
 TEST(OptionalTest, AssignObject) {
   {
     Optional<float> a;
     Optional<float> b(0.1f);
     a = b;
 
     EXPECT_TRUE(a);
     EXPECT_EQ(a.value(), 0.1f);
@@ skipping 12 matching lines @@
 
   {
     Optional<TestObject> a;
     Optional<TestObject> b(TestObject(3, 0.1));
     a = b;
 
     EXPECT_TRUE(!!a);
     EXPECT_TRUE(a.value() == TestObject(3, 0.1));
     EXPECT_TRUE(a == b);
   }
+
+  {
+    Optional<TestObject> a(TestObject(4, 1.0));
+    Optional<TestObject> b(TestObject(3, 0.1));
+    a = b;
+
+    EXPECT_TRUE(!!a);
+    EXPECT_TRUE(a.value() == TestObject(3, 0.1));
+    EXPECT_TRUE(a == b);
+  }
 }
 
 TEST(OptionalTest, AssignObject_rvalue) {
   {
     Optional<float> a;
     Optional<float> b(0.1f);
     a = std::move(b);
 
     EXPECT_TRUE(a);
     EXPECT_TRUE(b);
@@ skipping 15 matching lines @@
     Optional<TestObject> b(TestObject(3, 0.1));
     a = std::move(b);
 
     EXPECT_TRUE(!!a);
     EXPECT_TRUE(!!b);
     EXPECT_TRUE(TestObject(3, 0.1) == a.value());
 
     EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, a->state());
     EXPECT_EQ(TestObject::State::MOVED_FROM, b->state());
   }
+
+  {
+    Optional<TestObject> a(TestObject(4, 1.0));
+    Optional<TestObject> b(TestObject(3, 0.1));
+    a = std::move(b);
+
+    EXPECT_TRUE(!!a);
+    EXPECT_TRUE(!!b);
+    EXPECT_TRUE(TestObject(3, 0.1) == a.value());
+
+    EXPECT_EQ(TestObject::State::MOVE_ASSIGNED, a->state());
+    EXPECT_EQ(TestObject::State::MOVED_FROM, b->state());
+  }
 }
 
 TEST(OptionalTest, AssignNull) {
   {
     Optional<float> a(0.1f);
     Optional<float> b(0.2f);
     a = base::nullopt;
     b = base::nullopt;
     EXPECT_EQ(a, b);
   }
@@ skipping 120 matching lines @@
 
 TEST(OptionalTest, Swap_bothValue) {
   Optional<TestObject> a(TestObject(0, 0.1));
   Optional<TestObject> b(TestObject(1, 0.3));
   a.swap(b);
 
   EXPECT_TRUE(!!a);
   EXPECT_TRUE(!!b);
   EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42)));
   EXPECT_TRUE(TestObject(0, 0.1) == b.value_or(TestObject(42, 0.42)));
+  EXPECT_EQ(TestObject::State::SWAPPED, a->state());
+  EXPECT_EQ(TestObject::State::SWAPPED, b->state());
 }
 
 TEST(OptionalTest, Emplace) {
   {
     Optional<float> a(0.1f);
     a.emplace(0.3f);
 
     EXPECT_TRUE(a);
     EXPECT_EQ(0.3f, a.value());
   }
@@ skipping 664 matching lines @@
   {
     Optional<TestObject> o = base::make_optional(TestObject(3, 0.1));
     EXPECT_TRUE(!!o);
     EXPECT_TRUE(TestObject(3, 0.1) == *o);
 
     TestObject value = TestObject(0, 0.42);
     o = base::make_optional(std::move(value));
     EXPECT_TRUE(!!o);
     EXPECT_TRUE(TestObject(0, 0.42) == *o);
     EXPECT_EQ(TestObject::State::MOVED_FROM, value.state());
-    EXPECT_EQ(TestObject::State::COPY_CONSTRUCTED, o->state());
+    EXPECT_EQ(TestObject::State::MOVE_ASSIGNED, o->state());
 
     EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED,
               base::make_optional(std::move(value))->state());
   }
 }
 
 TEST(OptionalTest, NonMemberSwap_bothNoValue) {
   Optional<TestObject> a, b;
   base::swap(a, b);
 
@@ skipping 27 matching lines @@
 
 TEST(OptionalTest, NonMemberSwap_bothValue) {
   Optional<TestObject> a(TestObject(0, 0.1));
   Optional<TestObject> b(TestObject(1, 0.3));
   base::swap(a, b);
 
   EXPECT_TRUE(!!a);
   EXPECT_TRUE(!!b);
   EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42)));
   EXPECT_TRUE(TestObject(0, 0.1) == b.value_or(TestObject(42, 0.42)));
+  EXPECT_EQ(TestObject::State::SWAPPED, a->state());
+  EXPECT_EQ(TestObject::State::SWAPPED, b->state());
 }
 
 TEST(OptionalTest, Hash_OptionalReflectsInternal) {
   {
     std::hash<int> int_hash;
     std::hash<Optional<int>> opt_int_hash;
 
     EXPECT_EQ(int_hash(1), opt_int_hash(Optional<int>(1)));
   }
 
@@ skipping 18 matching lines @@
   std::set<Optional<int>> setOptInt;
 
   EXPECT_EQ(setOptInt.end(), setOptInt.find(42));
 
   setOptInt.insert(Optional<int>(3));
   EXPECT_EQ(setOptInt.end(), setOptInt.find(42));
   EXPECT_NE(setOptInt.end(), setOptInt.find(3));
 }
 
 }  // namespace base