Make base::Optional constructor constexpr.

base/optional_unittest.cc

Index: base/optional_unittest.cc
diff --git a/base/optional_unittest.cc b/base/optional_unittest.cc
index 565b6cd6c74cad6679c02c68953176b0dce11c6f..83025e8bdad3590de2da4e565d88d0661053fdf8 100644
--- a/base/optional_unittest.cc
+++ b/base/optional_unittest.cc
@@ -98,7 +98,7 @@ static_assert(
 
 TEST(OptionalTest, DefaultConstructor) {
   {
-    Optional<float> o;
+    constexpr Optional<float> o;
     EXPECT_FALSE(o);
   }
 
@@ -144,21 +144,28 @@ TEST(OptionalTest, CopyConstructor) {
 
 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());
   }
 }
 
@@ -198,35 +205,28 @@ TEST(OptionalTest, MoveConstructor) {
 
 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()));
-
-    EXPECT_TRUE(!!second);
-    EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED, second->state());
-    EXPECT_TRUE(TestObject(3, 0.1) == second.value());
+    TestObject value(3, 0.1);
+    Optional<TestObject> o(std::move(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());
   }
 }
 
@@ -251,7 +251,7 @@ TEST(OptionalTest, ConstructorForwardArguments) {
 }
 
 TEST(OptionalTest, NulloptConstructor) {
-  Optional<int> a = base::nullopt;
+  constexpr Optional<int> a(base::nullopt);
   EXPECT_FALSE(a);
 }