Base: add Optional<T>.

base/optional_unittest.cc

Index: base/optional_unittest.cc
diff --git a/base/optional_unittest.cc b/base/optional_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d3b5cfb12f52365cb30e84004fb629db4da093b8
--- /dev/null
+++ b/base/optional_unittest.cc
@@ -0,0 +1,308 @@
+// Copyright 2015 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 "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+
+namespace {
+
+class DummyObject {
+ public:
+  DummyObject() : foo_(0), bar_(0.0) { }
+  DummyObject(int foo, double bar) : foo_(foo), bar_(bar) { }
+
+  bool operator==(const DummyObject& other) const {
+    return foo_ == other.foo_ && bar_ == other.bar_;
+  }
+
+  int foo() const { return foo_; }
+
+ private:
+  int foo_;
+  double bar_;
+};
+
+}  // anonymous namespace
+
+TEST(OptionalTest, DefaultConstructor) {
+  {
+    Optional<float> o;
+    EXPECT_FALSE(o);
+  }
+
+  {
+    Optional<std::string> o;
+    EXPECT_FALSE(o);
+  }
+
+  {
+    Optional<DummyObject> o;
+    EXPECT_FALSE(o);
+  }
+}
+
+
+TEST(OptionalTest, ValueConstructor) {
+  {
+    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");
+  }
+
+  {
+    Optional<DummyObject> o(DummyObject(3, 0.1));
+    EXPECT_TRUE(o);
+    EXPECT_EQ(o.value(), DummyObject(3, 0.1));
+  }
+}
+
+TEST(OptionalTest, CopyConstructor) {
+  {
+    Optional<float> first(0.1f);
+    Optional<float> other(first);
+
+    EXPECT_TRUE(other);
+    EXPECT_EQ(other.value(), 0.1f);
+    EXPECT_EQ(first, other);
+  }
+
+  {
+    Optional<std::string> first("foo");
+    Optional<std::string> other(first);
+
+    EXPECT_TRUE(other);
+    EXPECT_EQ(other.value(), "foo");
+    EXPECT_EQ(first, other);
+  }
+
+  {
+    Optional<DummyObject> first(DummyObject(3, 0.1));
+    Optional<DummyObject> other(first);
+
+    EXPECT_TRUE(other);
+    EXPECT_EQ(other.value(), DummyObject(3, 0.1));
+    EXPECT_EQ(first, other);
+  }
+}
+
+TEST(OptionalTest, Equals) {
+  {
+    Optional<float> a(0.1f);
+    Optional<float> b(0.1f);
+    EXPECT_EQ(a, b);
+  }
+
+  {
+    Optional<std::string> a("foo");
+    Optional<std::string> b("foo");
+    EXPECT_EQ(a, b);
+  }
+
+  {
+    Optional<DummyObject> a(DummyObject(3, 0.1));
+    Optional<DummyObject> b(DummyObject(3, 0.1));
+    EXPECT_EQ(a, b);
+  }
+}
+
+TEST(OptionalTest, EqualsNull) {
+  {
+    Optional<float> a(0.1f);
+    Optional<float> b(0.2f);
+    a = nullptr;
+    b = nullptr;
+    EXPECT_EQ(a, b);
+  }
+
+  {
+    Optional<std::string> a("foo");
+    Optional<std::string> b("bar");
+    a = nullptr;
+    b = nullptr;
+    EXPECT_EQ(a, b);
+  }
+
+  {
+    Optional<DummyObject> a(DummyObject(3, 0.1));
+    Optional<DummyObject> b(DummyObject(4, 1.0));
+    a = nullptr;
+    b = nullptr;
+    EXPECT_EQ(a, b);
+  }
+}
+
+TEST(OptionalTest, NotEquals) {
+  {
+    Optional<float> a(0.1f);
+    Optional<float> b(0.2f);
+    EXPECT_NE(a, b);
+  }
+
+  {
+    Optional<std::string> a("foo");
+    Optional<std::string> b("bar");
+    EXPECT_NE(a, b);
+  }
+
+  {
+    Optional<DummyObject> a(DummyObject(3, 0.1));
+    Optional<DummyObject> b(DummyObject(4, 1.0));
+    EXPECT_NE(a, b);
+  }
+}
+
+TEST(OptionalTest, NotEqualsNull) {
+  {
+    Optional<float> a(0.1f);
+    Optional<float> b(0.1f);
+    b = nullptr;
+    EXPECT_NE(a, b);
+  }
+
+  {
+    Optional<std::string> a("foo");
+    Optional<std::string> b("foo");
+    b = nullptr;
+    EXPECT_NE(a, b);
+  }
+
+  {
+    Optional<DummyObject> a(DummyObject(3, 0.1));
+    Optional<DummyObject> b(DummyObject(3, 0.1));
+    b = nullptr;
+    EXPECT_NE(a, b);
+  }
+}
+
+TEST(OptionalTest, AssignValue) {
+  {
+    Optional<float> a;
+    EXPECT_FALSE(a);
+    a = 0.1f;
+    EXPECT_TRUE(a);
+
+    Optional<float> b(0.1f);
+    EXPECT_EQ(a, b);
+  }
+
+  {
+    Optional<std::string> a;
+    EXPECT_FALSE(a);
+    a = "foo";
+    EXPECT_TRUE(a);
+
+    Optional<std::string> b("foo");
+    EXPECT_EQ(a, b);
+  }
+
+  {
+    Optional<DummyObject> a;
+    EXPECT_FALSE(a);
+    a = DummyObject(3, 0.1);
+    EXPECT_TRUE(a);
+
+    Optional<DummyObject> b(DummyObject(3, 0.1));
+    EXPECT_EQ(a, b);
+  }
+}
+
+TEST(OptionalTest, AssignObject) {
+  {
+    Optional<float> a;
+    Optional<float> b(0.1f);
+    a = b;
+
+    EXPECT_TRUE(a);
+    EXPECT_EQ(a.value(), 0.1f);
+    EXPECT_EQ(a, b);
+  }
+
+  {
+    Optional<std::string> a;
+    Optional<std::string> b("foo");
+    a = b;
+
+    EXPECT_TRUE(a);
+    EXPECT_EQ(a.value(), "foo");
+    EXPECT_EQ(a, b);
+  }
+
+  {
+    Optional<DummyObject> a;
+    Optional<DummyObject> b(DummyObject(3, 0.1));
+    a = b;
+
+    EXPECT_TRUE(a);
+    EXPECT_EQ(a.value(), DummyObject(3, 0.1));
+    EXPECT_EQ(a, b);
+  }
+}
+
+TEST(OptionalTest, OperatorArrow) {
+  {
+    Optional<float> a(0.1f);
+    EXPECT_EQ(a.value(), *a);
+  }
+
+  {
+    Optional<std::string> a("foo");
+    EXPECT_EQ(a.value(), *a);
+  }
+
+  {
+    Optional<DummyObject> a(DummyObject(3, 0.1));
+    EXPECT_EQ(a.value(), *a);
+  }
+}
+
+TEST(OptionalTest, OperatorReference) {
+  Optional<DummyObject> a(DummyObject(3, 0.1));
+  EXPECT_EQ(a->foo(), 3);
+}
+
+TEST(OptionalTest, ValueOr) {
+  {
+    Optional<float> a;
+    EXPECT_EQ(a.value_or(0.0f), 0.0f);
+
+    a = 0.1f;
+    EXPECT_EQ(a.value_or(0.0f), 0.1f);
+
+    a = nullptr;
+    EXPECT_EQ(a.value_or(0.0f), 0.0f);
+  }
+
+  {
+    Optional<std::string> a;
+    EXPECT_EQ(a.value_or("bar"), "bar");
+
+    a = "foo";
+    EXPECT_EQ(a.value_or("bar"), "foo");
+
+    a = nullptr;
+    EXPECT_EQ(a.value_or("bar"), "bar");
+  }
+
+  {
+    Optional<DummyObject> a;
+    EXPECT_EQ(a.value_or(DummyObject(1, 0.3)), DummyObject(1, 0.3));
+
+    a = DummyObject(3, 0.1);
+    EXPECT_EQ(a.value_or(DummyObject(1, 0.3)), DummyObject(3, 0.1));
+
+    a = nullptr;
+    EXPECT_EQ(a.value_or(DummyObject(1, 0.3)), DummyObject(1, 0.3));
+  }
+}
+
+}  // namespace base