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 Optional<float> o(0.1f);
     EXPECT_TRUE(o);
     EXPECT_EQ(o.value(), 0.1f);
   }
 
   {
     Optional<std::string> o("foo");
     EXPECT_TRUE(o);
     EXPECT_EQ(o.value(), "foo");
   }
 
@@ skipping 33 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()));
+    constexpr float value = 0.1f;

[danakj, 2016/10/21 23:12:08]

Can you make all 3 cases in this test look alike? None of them need a first
Optional instance to call value() on really.

[alshabalin, 2016/10/22 07:47:52]

Done.

+    constexpr Optional<float> a(std::move(value));
 
-    EXPECT_TRUE(second);
-    EXPECT_EQ(second.value(), 0.1f);
-
-    EXPECT_TRUE(first);
+    EXPECT_TRUE(a);
+    EXPECT_EQ(0.1f, a.value());
   }
 
   {
     Optional<std::string> first("foo");
     Optional<std::string> second(std::move(first.value()));
 
     EXPECT_TRUE(second);
     EXPECT_EQ("foo", second.value());
 
     EXPECT_TRUE(first);
   }
 
   {
     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());
 
     EXPECT_TRUE(!!first);
     EXPECT_EQ(TestObject::State::MOVED_FROM, first->state());
   }
 }
 
 TEST(OptionalTest, ConstructorForwardArguments) {
   {
-    Optional<float> a(base::in_place, 0.1f);
+    constexpr 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