Make base::Optional constructor constexpr.

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"
 
@@ skipping 80 matching lines @@
 
 static_assert(is_trivially_destructible<Optional<int>>::value,
               "OptionalIsTriviallyDestructible");
 
 static_assert(
     !is_trivially_destructible<Optional<NonTriviallyDestructible>>::value,
     "OptionalIsTriviallyDestructible");
 
 TEST(OptionalTest, DefaultConstructor) {
   {
-    Optional<float> o;
+    constexpr Optional<float> o;
     EXPECT_FALSE(o);
   }
 
   {
     Optional<std::string> o;
     EXPECT_FALSE(o);
   }
 
   {
     Optional<TestObject> o;
@@ skipping 25 matching lines @@
     Optional<TestObject> other(first);
 
     EXPECT_TRUE(!!other);
     EXPECT_TRUE(other.value() == TestObject(3, 0.1));
     EXPECT_TRUE(first == other);
   }
 }
 
 TEST(OptionalTest, ValueConstructor) {
   {
-    Optional<float> o(0.1f);
+    constexpr float value = 0.1f;
+    constexpr Optional<float> o(value);
+
     EXPECT_TRUE(o);
-    EXPECT_EQ(o.value(), 0.1f);
+    EXPECT_EQ(value, o.value());
   }
 
   {
-    Optional<std::string> o("foo");
+    std::string value("foo");
+    Optional<std::string> o(value);
+
     EXPECT_TRUE(o);
-    EXPECT_EQ(o.value(), "foo");
+    EXPECT_EQ(value, o.value());
   }
 
   {
-    Optional<TestObject> o(TestObject(3, 0.1));
-    EXPECT_TRUE(!!o);
-    EXPECT_TRUE(o.value() == TestObject(3, 0.1));
+    TestObject value(3, 0.1);
+    Optional<TestObject> o(value);
+
+    EXPECT_TRUE(o);
+    EXPECT_EQ(TestObject::State::COPY_CONSTRUCTED, o->state());
+    EXPECT_EQ(value, o.value());
   }
 }
 
 TEST(OptionalTest, MoveConstructor) {
   {
     Optional<float> first(0.1f);
     Optional<float> second(std::move(first));
 
     EXPECT_TRUE(second);
     EXPECT_EQ(second.value(), 0.1f);
@@ skipping 19 matching lines @@
     EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, second->state());
     EXPECT_TRUE(TestObject(3, 0.1) == second.value());
 
     EXPECT_TRUE(!!first);
     EXPECT_EQ(TestObject::State::MOVED_FROM, first->state());
   }
 }
 
 TEST(OptionalTest, MoveValueConstructor) {
   {
-    Optional<float> first(0.1f);
-    Optional<float> second(std::move(first.value()));
+    float value = 0.1f;
+    Optional<float> o(std::move(value));
 
-    EXPECT_TRUE(second);
-    EXPECT_EQ(second.value(), 0.1f);
-
-    EXPECT_TRUE(first);
+    EXPECT_TRUE(o);
+    EXPECT_EQ(0.1f, o.value());
   }
 
   {
-    Optional<std::string> first("foo");
-    Optional<std::string> second(std::move(first.value()));
+    std::string value("foo");
+    Optional<std::string> o(std::move(value));
 
-    EXPECT_TRUE(second);
-    EXPECT_EQ("foo", second.value());
-
-    EXPECT_TRUE(first);
+    EXPECT_TRUE(o);
+    EXPECT_EQ("foo", o.value());
   }
 
   {
-    Optional<TestObject> first(TestObject(3, 0.1));
-    Optional<TestObject> second(std::move(first.value()));
+    TestObject value(3, 0.1);
+    Optional<TestObject> o(std::move(value));
 
-    EXPECT_TRUE(!!second);
-    EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, second->state());
-    EXPECT_TRUE(TestObject(3, 0.1) == second.value());
-
-    EXPECT_TRUE(!!first);
-    EXPECT_EQ(TestObject::State::MOVED_FROM, first->state());
+    EXPECT_TRUE(o);
+    EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, o->state());
+    EXPECT_EQ(TestObject(3, 0.1), o.value());
   }
 }
 
 TEST(OptionalTest, ConstructorForwardArguments) {
   {
     Optional<float> a(base::in_place, 0.1f);
     EXPECT_TRUE(a);
     EXPECT_EQ(0.1f, a.value());
   }
 
   {
     Optional<std::string> a(base::in_place, "foo");
     EXPECT_TRUE(a);
     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;
+  constexpr Optional<int> a(base::nullopt);
   EXPECT_FALSE(a);
 }
 
 TEST(OptionalTest, AssignValue) {
   {
     Optional<float> a;
     EXPECT_FALSE(a);
     a = 0.1f;
     EXPECT_TRUE(a);
 
@@ skipping 1072 matching lines @@
 
 TEST(OptionalTest, Reset_NoOp) {
   Optional<int> a;
   EXPECT_FALSE(a.has_value());
 
   a.reset();
   EXPECT_FALSE(a.has_value());
 }
 
 }  // namespace base