Imported Optional from Chromium with some modifications.

webrtc/base/optional_unittest.cc

Index: webrtc/base/optional_unittest.cc
diff --git a/webrtc/base/optional_unittest.cc b/webrtc/base/optional_unittest.cc
index b51701f6b26b6355f636919a2fc0dad8e5306fdf..61fbc5f16c4790b916ecc3a2d1442fb94a540619 100644
--- a/webrtc/base/optional_unittest.cc
+++ b/webrtc/base/optional_unittest.cc
@@ -1,472 +1,1301 @@
-/*
- *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#include <memory>
-#include <sstream>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "webrtc/base/gunit.h"
+// Copyright 2016 The Chromium Authors. All rights reserved.

[ossu, 2016/06/17 14:51:48]

Same with this copyright message.

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
 #include "webrtc/base/optional.h"
 
+#include <set>
+
+#include "testing/gtest/include/gtest/gtest.h"
+
 namespace rtc {
 
 namespace {
 
-// Class whose instances logs various method calls (constructor, destructor,
-// etc.). Each instance has a unique ID (a simple global sequence number) and
-// an origin ID. When a copy is made, the new object gets a fresh ID but copies
-// the origin ID from the original. When a new Logger is created from scratch,
-// it gets a fresh ID, and the origin ID is the same as the ID (default
-// constructor) or given as an argument (explicit constructor).
-class Logger {
+// Object used to test complex object with Optional<T> in addition of the move
+// semantics.
+class TestObject {
  public:
-  Logger() : id_(g_next_id++), origin_(id_) { Log("default constructor"); }
-  explicit Logger(int origin) : id_(g_next_id++), origin_(origin) {
-    Log("explicit constructor");
-  }
-  Logger(const Logger& other) : id_(g_next_id++), origin_(other.origin_) {
-    LogFrom("copy constructor", other);
-  }
-  Logger(Logger&& other) : id_(g_next_id++), origin_(other.origin_) {
-    LogFrom("move constructor", other);
+  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;
   }
-  ~Logger() { Log("destructor"); }
-  Logger& operator=(const Logger& other) {
-    origin_ = other.origin_;
-    LogFrom("operator= copy", other);
+
+  TestObject& operator=(const TestObject& other) {
+    foo_ = other.foo_;
+    bar_ = other.bar_;
+    state_ = State::COPY_ASSIGNED;
     return *this;
   }
-  Logger& operator=(Logger&& other) {
-    origin_ = other.origin_;
-    LogFrom("operator= move", other);
+
+  TestObject& operator=(TestObject&& other) {
+    foo_ = other.foo_;
+    bar_ = other.bar_;
+    state_ = State::MOVE_ASSIGNED;
+    other.state_ = State::MOVED_FROM;
     return *this;
   }
-  friend void swap(Logger& a, Logger& b) {
+
+  void Swap(TestObject* other) {
     using std::swap;
-    swap(a.origin_, b.origin_);
-    Log2("swap", a, b);
+    swap(foo_, other->foo_);
+    swap(bar_, other->bar_);
+    state_ = State::SWAPPED;
+    other->state_ = State::SWAPPED;
   }
-  friend bool operator==(const Logger& a, const Logger& b) {
-    Log2("operator==", a, b);
-    return a.origin_ == b.origin_;
+
+  bool operator==(const TestObject& other) const {
+    return foo_ == other.foo_ && bar_ == other.bar_;
   }
-  friend bool operator!=(const Logger& a, const Logger& b) {
-    Log2("operator!=", a, b);
-    return a.origin_ != b.origin_;
+
+  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);
   }
-  void Foo() { Log("Foo()"); }
-  void Foo() const { Log("Foo() const"); }
-  static std::unique_ptr<std::vector<std::string>> Setup() {
-    std::unique_ptr<std::vector<std::string>> s(new std::vector<std::string>);
-    g_log = s.get();
-    g_next_id = 0;
-    return s;
+
+  {
+    Optional<std::string> o;
+    EXPECT_FALSE(o);
   }
 
- private:
-  int id_;
-  int origin_;
-  static std::vector<std::string>* g_log;
-  static int g_next_id;
-  void Log(const char* msg) const {
-    std::ostringstream oss;
-    oss << id_ << ':' << origin_ << ". " << msg;
-    g_log->push_back(oss.str());
-  }
-  void LogFrom(const char* msg, const Logger& other) const {
-    std::ostringstream oss;
-    oss << id_ << ':' << origin_ << ". " << msg << " (from " << other.id_ << ':'
-        << other.origin_ << ")";
-    g_log->push_back(oss.str());
-  }
-  static void Log2(const char* msg, const Logger& a, const Logger& b) {
-    std::ostringstream oss;
-    oss << msg << ' ' << a.id_ << ':' << a.origin_ << ", " << b.id_ << ':'
-        << b.origin_;
-    g_log->push_back(oss.str());
+  {
+    Optional<TestObject> o;
+    EXPECT_FALSE(o);
   }
-};
+}
 
-std::vector<std::string>* Logger::g_log = nullptr;
-int Logger::g_next_id = 0;
+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<TestObject> first(TestObject(3, 0.1));
+    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);
+    EXPECT_TRUE(o);
+    EXPECT_EQ(o.value(), 0.1f);
+  }
+
+  {
+    Optional<std::string> o("foo");
+    EXPECT_TRUE(o);
+    EXPECT_EQ(o.value(), "foo");
+  }
 
-// Append all the other args to the vector pointed to by the first arg.
-template <typename T>
-void VectorAppend(std::vector<T>* v) {}
-template <typename T, typename... Ts>
-void VectorAppend(std::vector<T>* v, const T& e, Ts... es) {
-  v->push_back(e);
-  VectorAppend(v, es...);
+  {
+    Optional<TestObject> o(TestObject(3, 0.1));
+    EXPECT_TRUE(!!o);
+    EXPECT_TRUE(o.value() == TestObject(3, 0.1));
+  }
 }
 
-// Create a vector of strings. Because we're not allowed to use
-// std::initializer_list.
-template <typename... Ts>
-std::vector<std::string> V(Ts... es) {
-  std::vector<std::string> strings;
-  VectorAppend(&strings, static_cast<std::string>(es)...);
-  return strings;
+TEST(OptionalTest, MoveConstructor) {
+  {
+    Optional<float> first(0.1f);
+    Optional<float> second(std::move(first));
+
+    EXPECT_TRUE(second);
+    EXPECT_EQ(second.value(), 0.1f);
+
+    EXPECT_TRUE(first);
+  }
+
+  {
+    Optional<std::string> first("foo");
+    Optional<std::string> second(std::move(first));
+
+    EXPECT_TRUE(second);
+    EXPECT_EQ("foo", second.value());
+
+    EXPECT_TRUE(first);
+  }
+
+  {
+    Optional<TestObject> first(TestObject(3, 0.1));
+    Optional<TestObject> second(std::move(first));
+
+    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());
+  }
 }
 
-}  // namespace
+TEST(OptionalTest, MoveValueConstructor) {
+  {
+    Optional<float> first(0.1f);
+    Optional<float> second(std::move(first.value()));
+
+    EXPECT_TRUE(second);
+    EXPECT_EQ(second.value(), 0.1f);
+
+    EXPECT_TRUE(first);
+  }
+
+  {
+    Optional<std::string> first("foo");
+    Optional<std::string> second(std::move(first.value()));
+
+    EXPECT_TRUE(second);
+    EXPECT_EQ("foo", second.value());
+
+    EXPECT_TRUE(first);
+  }
 
-TEST(OptionalTest, TestConstructDefault) {
-  auto log = Logger::Setup();
   {
-    Optional<Logger> x;
-    EXPECT_FALSE(x);
+    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());
   }
-  EXPECT_EQ(V(), *log);
 }
 
-TEST(OptionalTest, TestConstructCopyEmpty) {
-  auto log = Logger::Setup();
+TEST(OptionalTest, ConstructorForwardArguments) {
+  {
+    Optional<float> a(rtc::in_place, 0.1f);
+    EXPECT_TRUE(a);
+    EXPECT_EQ(0.1f, a.value());
+  }
+
   {
-    Optional<Logger> x;
-    EXPECT_FALSE(x);
-    auto y = x;
-    EXPECT_FALSE(y);
+    Optional<std::string> a(rtc::in_place, "foo");
+    EXPECT_TRUE(a);
+    EXPECT_EQ("foo", a.value());
   }
-  EXPECT_EQ(V(), *log);
+
+  {
+    Optional<TestObject> a(rtc::in_place, 0, 0.1);
+    EXPECT_TRUE(!!a);
+    EXPECT_TRUE(TestObject(0, 0.1) == a.value());
+  }
+}
+
+TEST(OptionalTest, NulloptConstructor) {
+  Optional<int> a = rtc::nullopt;
+  EXPECT_FALSE(a);
 }
 
-TEST(OptionalTest, TestConstructCopyFull) {
-  auto log = Logger::Setup();
+TEST(OptionalTest, AssignValue) {
+  {
+    Optional<float> a;
+    EXPECT_FALSE(a);
+    a = 0.1f;
+    EXPECT_TRUE(a);
+
+    Optional<float> b(0.1f);
+    EXPECT_TRUE(a == b);
+  }
+
+  {
+    Optional<std::string> a;
+    EXPECT_FALSE(a);
+    a = std::string("foo");
+    EXPECT_TRUE(a);
+
+    Optional<std::string> b(std::string("foo"));
+    EXPECT_EQ(a, b);
+  }
+
+  {
+    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);
+  }
+
   {
-    Logger a;
-    Optional<Logger> x(a);
-    EXPECT_TRUE(x);
-    log->push_back("---");
-    auto y = x;
-    EXPECT_TRUE(y);
-    log->push_back("---");
+    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);
   }
-  EXPECT_EQ(V("0:0. default constructor", "1:0. copy constructor (from 0:0)",
-              "---", "2:0. copy constructor (from 1:0)", "---",
-              "2:0. destructor", "1:0. destructor", "0:0. destructor"),
-            *log);
 }
 
-TEST(OptionalTest, TestConstructMoveEmpty) {
-  auto log = Logger::Setup();
+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<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<Logger> x;
-    EXPECT_FALSE(x);
-    auto y = std::move(x);
-    EXPECT_FALSE(y);
+    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);
   }
-  EXPECT_EQ(V(), *log);
 }
 
-TEST(OptionalTest, TestConstructMoveFull) {
-  auto log = Logger::Setup();
+TEST(OptionalTest, AssignObject_rvalue) {
+  {
+    Optional<float> a;
+    Optional<float> b(0.1f);
+    a = std::move(b);
+
+    EXPECT_TRUE(a);
+    EXPECT_TRUE(b);
+    EXPECT_EQ(0.1f, a.value());
+  }
+
+  {
+    Optional<std::string> a;
+    Optional<std::string> b("foo");
+    a = std::move(b);
+
+    EXPECT_TRUE(a);
+    EXPECT_TRUE(b);
+    EXPECT_EQ("foo", a.value());
+  }
+
+  {
+    Optional<TestObject> a;
+    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<Logger> x(Logger(17));
-    EXPECT_TRUE(x);
-    log->push_back("---");
-    auto y = std::move(x);
-    EXPECT_TRUE(x);
-    EXPECT_TRUE(y);
-    log->push_back("---");
+    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());
   }
-  EXPECT_EQ(
-      V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
-        "0:17. destructor", "---", "2:17. move constructor (from 1:17)", "---",
-        "2:17. destructor", "1:17. destructor"),
-      *log);
 }
 
-TEST(OptionalTest, TestCopyAssignToEmptyFromEmpty) {
-  auto log = Logger::Setup();
+TEST(OptionalTest, AssignNull) {
+  {
+    Optional<float> a(0.1f);
+    Optional<float> b(0.2f);
+    a = rtc::nullopt;
+    b = rtc::nullopt;
+    EXPECT_EQ(a, b);
+  }
+
+  {
+    Optional<std::string> a("foo");
+    Optional<std::string> b("bar");
+    a = rtc::nullopt;
+    b = rtc::nullopt;
+    EXPECT_EQ(a, b);
+  }
+
   {
-    Optional<Logger> x, y;
-    x = y;
+    Optional<TestObject> a(TestObject(3, 0.1));
+    Optional<TestObject> b(TestObject(4, 1.0));
+    a = rtc::nullopt;
+    b = rtc::nullopt;
+    EXPECT_TRUE(a == b);
   }
-  EXPECT_EQ(V(), *log);
 }
 
-TEST(OptionalTest, TestCopyAssignToFullFromEmpty) {
-  auto log = Logger::Setup();
+TEST(OptionalTest, OperatorStar) {
+  {
+    Optional<float> a(0.1f);
+    EXPECT_EQ(a.value(), *a);
+  }
+
+  {
+    Optional<std::string> a("foo");
+    EXPECT_EQ(a.value(), *a);
+  }
+
   {
-    Optional<Logger> x(Logger(17));
-    Optional<Logger> y;
-    log->push_back("---");
-    x = y;
-    log->push_back("---");
+    Optional<TestObject> a(TestObject(3, 0.1));
+    EXPECT_EQ(a.value(), *a);
   }
-  EXPECT_EQ(
-      V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
-        "0:17. destructor", "---", "1:17. destructor", "---"),
-      *log);
 }
 
-TEST(OptionalTest, TestCopyAssignToEmptyFromFull) {
-  auto log = Logger::Setup();
+TEST(OptionalTest, OperatorStar_rvalue) {
+  EXPECT_EQ(0.1f, *Optional<float>(0.1f));
+  EXPECT_EQ(std::string("foo"), *Optional<std::string>("foo"));
+  EXPECT_TRUE(TestObject(3, 0.1) == *Optional<TestObject>(TestObject(3, 0.1)));
+}
+
+TEST(OptionalTest, OperatorArrow) {
+  Optional<TestObject> a(TestObject(3, 0.1));
+  EXPECT_EQ(a->foo(), 3);
+}
+
+TEST(OptionalTest, Value_rvalue) {
+  EXPECT_EQ(0.1f, Optional<float>(0.1f).value());
+  EXPECT_EQ(std::string("foo"), Optional<std::string>("foo").value());
+  EXPECT_TRUE(TestObject(3, 0.1) ==
+              Optional<TestObject>(TestObject(3, 0.1)).value());
+}
+
+TEST(OptionalTest, ValueOr) {
   {
-    Optional<Logger> x;
-    Optional<Logger> y(Logger(17));
-    log->push_back("---");
-    x = y;
-    log->push_back("---");
+    Optional<float> a;
+    EXPECT_EQ(0.0f, a.value_or(0.0f));
+
+    a = 0.1f;
+    EXPECT_EQ(0.1f, a.value_or(0.0f));
+
+    a = rtc::nullopt;
+    EXPECT_EQ(0.0f, a.value_or(0.0f));
+  }
+
+  {
+    Optional<std::string> a;
+    EXPECT_EQ("bar", a.value_or("bar"));
+
+    a = std::string("foo");
+    EXPECT_EQ(std::string("foo"), a.value_or("bar"));
+
+    a = rtc::nullopt;
+    EXPECT_EQ(std::string("bar"), a.value_or("bar"));
+  }
+
+  {
+    Optional<TestObject> a;
+    EXPECT_TRUE(a.value_or(TestObject(1, 0.3)) == TestObject(1, 0.3));
+
+    a = TestObject(3, 0.1);
+    EXPECT_TRUE(a.value_or(TestObject(1, 0.3)) == TestObject(3, 0.1));
+
+    a = rtc::nullopt;
+    EXPECT_TRUE(a.value_or(TestObject(1, 0.3)) == TestObject(1, 0.3));
   }
-  EXPECT_EQ(
-      V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
-        "0:17. destructor", "---", "2:17. copy constructor (from 1:17)", "---",
-        "1:17. destructor", "2:17. destructor"),
-      *log);
 }
 
-TEST(OptionalTest, TestCopyAssignToFullFromFull) {
-  auto log = Logger::Setup();
+TEST(OptionalTest, Swap_bothNoValue) {
+  Optional<TestObject> a, b;
+  a.swap(b);
+
+  EXPECT_FALSE(a);
+  EXPECT_FALSE(b);
+  EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42)));
+  EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42)));
+}
+
+TEST(OptionalTest, Swap_inHasValue) {
+  Optional<TestObject> a(TestObject(1, 0.3));
+  Optional<TestObject> b;
+  a.swap(b);
+
+  EXPECT_FALSE(a);
+
+  EXPECT_TRUE(!!b);
+  EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42)));
+  EXPECT_TRUE(TestObject(1, 0.3) == b.value_or(TestObject(42, 0.42)));
+}
+
+TEST(OptionalTest, Swap_outHasValue) {
+  Optional<TestObject> a;
+  Optional<TestObject> b(TestObject(1, 0.3));
+  a.swap(b);
+
+  EXPECT_TRUE(!!a);
+  EXPECT_FALSE(!!b);
+  EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42)));
+  EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42)));
+}
+
+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());
+  }
+
+  {
+    Optional<std::string> a("foo");
+    a.emplace("bar");
+
+    EXPECT_TRUE(a);
+    EXPECT_EQ("bar", a.value());
+  }
+
   {
-    Optional<Logger> x(Logger(17));
-    Optional<Logger> y(Logger(42));
-    log->push_back("---");
-    x = y;
-    log->push_back("---");
+    Optional<TestObject> a(TestObject(0, 0.1));
+    a.emplace(TestObject(1, 0.2));
+
+    EXPECT_TRUE(!!a);
+    EXPECT_TRUE(TestObject(1, 0.2) == a.value());
   }
-  EXPECT_EQ(
-      V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
-        "0:17. destructor", "2:42. explicit constructor",
-        "3:42. move constructor (from 2:42)", "2:42. destructor", "---",
-        "1:42. operator= copy (from 3:42)", "---", "3:42. destructor",
-        "1:42. destructor"),
-      *log);
 }
 
-TEST(OptionalTest, TestCopyAssignToEmptyFromT) {
-  auto log = Logger::Setup();
+TEST(OptionalTest, Equals_TwoEmpty) {
+  Optional<int> a;
+  Optional<int> b;
+
+  EXPECT_TRUE(a == b);
+}
+
+TEST(OptionalTest, Equals_TwoEquals) {
+  Optional<int> a(1);
+  Optional<int> b(1);
+
+  EXPECT_TRUE(a == b);
+}
+
+TEST(OptionalTest, Equals_OneEmpty) {
+  Optional<int> a;
+  Optional<int> b(1);
+
+  EXPECT_FALSE(a == b);
+}
+
+TEST(OptionalTest, Equals_TwoDifferent) {
+  Optional<int> a(0);
+  Optional<int> b(1);
+
+  EXPECT_FALSE(a == b);
+}
+
+TEST(OptionalTest, NotEquals_TwoEmpty) {
+  Optional<int> a;
+  Optional<int> b;
+
+  EXPECT_FALSE(a != b);
+}
+
+TEST(OptionalTest, NotEquals_TwoEquals) {
+  Optional<int> a(1);
+  Optional<int> b(1);
+
+  EXPECT_FALSE(a != b);
+}
+
+TEST(OptionalTest, NotEquals_OneEmpty) {
+  Optional<int> a;
+  Optional<int> b(1);
+
+  EXPECT_TRUE(a != b);
+}
+
+TEST(OptionalTest, NotEquals_TwoDifferent) {
+  Optional<int> a(0);
+  Optional<int> b(1);
+
+  EXPECT_TRUE(a != b);
+}
+
+TEST(OptionalTest, Less_LeftEmpty) {
+  Optional<int> l;
+  Optional<int> r(1);
+
+  EXPECT_TRUE(l < r);
+}
+
+TEST(OptionalTest, Less_RightEmpty) {
+  Optional<int> l(1);
+  Optional<int> r;
+
+  EXPECT_FALSE(l < r);
+}
+
+TEST(OptionalTest, Less_BothEmpty) {
+  Optional<int> l;
+  Optional<int> r;
+
+  EXPECT_FALSE(l < r);
+}
+
+TEST(OptionalTest, Less_BothValues) {
+  {
+    Optional<int> l(1);
+    Optional<int> r(2);
+
+    EXPECT_TRUE(l < r);
+  }
+  {
+    Optional<int> l(2);
+    Optional<int> r(1);
+
+    EXPECT_FALSE(l < r);
+  }
   {
-    Optional<Logger> x;
-    Logger y(17);
-    log->push_back("---");
-    x = Optional<Logger>(y);
-    log->push_back("---");
+    Optional<int> l(1);
+    Optional<int> r(1);
+
+    EXPECT_FALSE(l < r);
   }
-  EXPECT_EQ(V("0:17. explicit constructor", "---",
-              "1:17. copy constructor (from 0:17)",
-              "2:17. move constructor (from 1:17)", "1:17. destructor", "---",
-              "0:17. destructor", "2:17. destructor"),
-            *log);
 }
 
-TEST(OptionalTest, TestCopyAssignToFullFromT) {
-  auto log = Logger::Setup();
+TEST(OptionalTest, LessEq_LeftEmpty) {
+  Optional<int> l;
+  Optional<int> r(1);
+
+  EXPECT_TRUE(l <= r);
+}
+
+TEST(OptionalTest, LessEq_RightEmpty) {
+  Optional<int> l(1);
+  Optional<int> r;
+
+  EXPECT_FALSE(l <= r);
+}
+
+TEST(OptionalTest, LessEq_BothEmpty) {
+  Optional<int> l;
+  Optional<int> r;
+
+  EXPECT_TRUE(l <= r);
+}
+
+TEST(OptionalTest, LessEq_BothValues) {
+  {
+    Optional<int> l(1);
+    Optional<int> r(2);
+
+    EXPECT_TRUE(l <= r);
+  }
+  {
+    Optional<int> l(2);
+    Optional<int> r(1);
+
+    EXPECT_FALSE(l <= r);
+  }
   {
-    Optional<Logger> x(Logger(17));
-    Logger y(42);
-    log->push_back("---");
-    x = Optional<Logger>(y);
-    log->push_back("---");
+    Optional<int> l(1);
+    Optional<int> r(1);
+
+    EXPECT_TRUE(l <= r);
   }
-  EXPECT_EQ(
-      V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
-        "0:17. destructor", "2:42. explicit constructor", "---",
-        "3:42. copy constructor (from 2:42)",
-        "1:42. operator= move (from 3:42)", "3:42. destructor", "---",
-        "2:42. destructor", "1:42. destructor"),
-      *log);
 }
 
-TEST(OptionalTest, TestMoveAssignToEmptyFromEmpty) {
-  auto log = Logger::Setup();
+TEST(OptionalTest, Greater_BothEmpty) {
+  Optional<int> l;
+  Optional<int> r;
+
+  EXPECT_FALSE(l > r);
+}
+
+TEST(OptionalTest, Greater_LeftEmpty) {
+  Optional<int> l;
+  Optional<int> r(1);
+
+  EXPECT_FALSE(l > r);
+}
+
+TEST(OptionalTest, Greater_RightEmpty) {
+  Optional<int> l(1);
+  Optional<int> r;
+
+  EXPECT_TRUE(l > r);
+}
+
+TEST(OptionalTest, Greater_BothValue) {
+  {
+    Optional<int> l(1);
+    Optional<int> r(2);
+
+    EXPECT_FALSE(l > r);
+  }
+  {
+    Optional<int> l(2);
+    Optional<int> r(1);
+
+    EXPECT_TRUE(l > r);
+  }
   {
-    Optional<Logger> x, y;
-    x = std::move(y);
+    Optional<int> l(1);
+    Optional<int> r(1);
+
+    EXPECT_FALSE(l > r);
   }
-  EXPECT_EQ(V(), *log);
 }
 
-TEST(OptionalTest, TestMoveAssignToFullFromEmpty) {
-  auto log = Logger::Setup();
-  {
-    Optional<Logger> x(Logger(17));
-    Optional<Logger> y;
-    log->push_back("---");
-    x = std::move(y);
-    log->push_back("---");
-  }
-  EXPECT_EQ(
-      V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
-        "0:17. destructor", "---", "1:17. destructor", "---"),
-      *log);
-}
-
-TEST(OptionalTest, TestMoveAssignToEmptyFromFull) {
-  auto log = Logger::Setup();
-  {
-    Optional<Logger> x;
-    Optional<Logger> y(Logger(17));
-    log->push_back("---");
-    x = std::move(y);
-    log->push_back("---");
-  }
-  EXPECT_EQ(
-      V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
-        "0:17. destructor", "---", "2:17. move constructor (from 1:17)", "---",
-        "1:17. destructor", "2:17. destructor"),
-      *log);
-}
-
-TEST(OptionalTest, TestMoveAssignToFullFromFull) {
-  auto log = Logger::Setup();
-  {
-    Optional<Logger> x(Logger(17));
-    Optional<Logger> y(Logger(42));
-    log->push_back("---");
-    x = std::move(y);
-    log->push_back("---");
-  }
-  EXPECT_EQ(
-      V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
-        "0:17. destructor", "2:42. explicit constructor",
-        "3:42. move constructor (from 2:42)", "2:42. destructor", "---",
-        "1:42. operator= move (from 3:42)", "---", "3:42. destructor",
-        "1:42. destructor"),
-      *log);
-}
-
-TEST(OptionalTest, TestMoveAssignToEmptyFromT) {
-  auto log = Logger::Setup();
-  {
-    Optional<Logger> x;
-    Logger y(17);
-    log->push_back("---");
-    x = Optional<Logger>(std::move(y));
-    log->push_back("---");
-  }
-  EXPECT_EQ(V("0:17. explicit constructor", "---",
-              "1:17. move constructor (from 0:17)",
-              "2:17. move constructor (from 1:17)", "1:17. destructor", "---",
-              "0:17. destructor", "2:17. destructor"),
-            *log);
-}
-
-TEST(OptionalTest, TestMoveAssignToFullFromT) {
-  auto log = Logger::Setup();
-  {
-    Optional<Logger> x(Logger(17));
-    Logger y(42);
-    log->push_back("---");
-    x = Optional<Logger>(std::move(y));
-    log->push_back("---");
-  }
-  EXPECT_EQ(
-      V("0:17. explicit constructor", "1:17. move constructor (from 0:17)",
-        "0:17. destructor", "2:42. explicit constructor", "---",
-        "3:42. move constructor (from 2:42)",
-        "1:42. operator= move (from 3:42)", "3:42. destructor", "---",
-        "2:42. destructor", "1:42. destructor"),
-      *log);
-}
-
-TEST(OptionalTest, TestDereference) {
-  auto log = Logger::Setup();
-  {
-    Optional<Logger> x(Logger(42));
-    const auto& y = x;
-    log->push_back("---");
-    x->Foo();
-    y->Foo();
-    std::move(x)->Foo();
-    std::move(y)->Foo();
-    log->push_back("---");
-    (*x).Foo();
-    (*y).Foo();
-    (*std::move(x)).Foo();
-    (*std::move(y)).Foo();
-    log->push_back("---");
-  }
-  EXPECT_EQ(V("0:42. explicit constructor",
-              "1:42. move constructor (from 0:42)", "0:42. destructor", "---",
-              "1:42. Foo()", "1:42. Foo() const", "1:42. Foo()",
-              "1:42. Foo() const", "---", "1:42. Foo()", "1:42. Foo() const",
-              "1:42. Foo()", "1:42. Foo() const", "---", "1:42. destructor"),
-            *log);
-}
-
-TEST(OptionalTest, TestDereferenceWithDefault) {
-  auto log = Logger::Setup();
-  {
-    const Logger a(17), b(42);
-    Optional<Logger> x(a);
-    Optional<Logger> y;
-    log->push_back("-1-");
-    EXPECT_EQ(a, x.value_or(Logger(42)));
-    log->push_back("-2-");
-    EXPECT_EQ(b, y.value_or(Logger(42)));
-    log->push_back("-3-");
-    EXPECT_EQ(a, Optional<Logger>(Logger(17)).value_or(b));
-    log->push_back("-4-");
-    EXPECT_EQ(b, Optional<Logger>().value_or(b));
-    log->push_back("-5-");
-  }
-  EXPECT_EQ(
-      V("0:17. explicit constructor", "1:42. explicit constructor",
-        "2:17. copy constructor (from 0:17)", "-1-",
-        "3:42. explicit constructor", "operator== 0:17, 2:17",
-        "3:42. destructor", "-2-", "4:42. explicit constructor",
-        "operator== 1:42, 4:42", "4:42. destructor", "-3-",
-        "5:17. explicit constructor", "6:17. move constructor (from 5:17)",
-        "operator== 0:17, 6:17", "6:17. destructor", "5:17. destructor", "-4-",
-        "operator== 1:42, 1:42", "-5-", "2:17. destructor", "1:42. destructor",
-        "0:17. destructor"),
-      *log);
-}
-
-TEST(OptionalTest, TestEquality) {
-  auto log = Logger::Setup();
-  {
-    Logger a(17), b(42);
-    Optional<Logger> ma1(a), ma2(a), mb(b), me1, me2;
-    log->push_back("---");
-    EXPECT_EQ(ma1, ma1);
-    EXPECT_EQ(ma1, ma2);
-    EXPECT_NE(ma1, mb);
-    EXPECT_NE(ma1, me1);
-    EXPECT_EQ(me1, me1);
-    EXPECT_EQ(me1, me2);
-    log->push_back("---");
-  }
-  EXPECT_EQ(
-      V("0:17. explicit constructor", "1:42. explicit constructor",
-        "2:17. copy constructor (from 0:17)",
-        "3:17. copy constructor (from 0:17)",
-        "4:42. copy constructor (from 1:42)", "---", "operator== 2:17, 2:17",
-        "operator== 2:17, 3:17", "operator!= 2:17, 4:42", "---",
-        "4:42. destructor", "3:17. destructor", "2:17. destructor",
-        "1:42. destructor", "0:17. destructor"),
-      *log);
-}
-
-TEST(OptionalTest, TestSwap) {
-  auto log = Logger::Setup();
-  {
-    Logger a(17), b(42);
-    Optional<Logger> x1(a), x2(b), y1(a), y2, z1, z2;
-    log->push_back("---");
-    swap(x1, x2);  // Swap full <-> full.
-    swap(y1, y2);  // Swap full <-> empty.
-    swap(z1, z2);  // Swap empty <-> empty.
-    log->push_back("---");
-  }
-  EXPECT_EQ(V("0:17. explicit constructor", "1:42. explicit constructor",
-              "2:17. copy constructor (from 0:17)",
-              "3:42. copy constructor (from 1:42)",
-              "4:17. copy constructor (from 0:17)", "---", "swap 2:42, 3:17",
-              "5:17. move constructor (from 4:17)", "4:17. destructor", "---",
-              "5:17. destructor", "3:17. destructor", "2:42. destructor",
-              "1:42. destructor", "0:17. destructor"),
-            *log);
+TEST(OptionalTest, GreaterEq_BothEmpty) {
+  Optional<int> l;
+  Optional<int> r;
+
+  EXPECT_TRUE(l >= r);
+}
+
+TEST(OptionalTest, GreaterEq_LeftEmpty) {
+  Optional<int> l;
+  Optional<int> r(1);
+
+  EXPECT_FALSE(l >= r);
+}
+
+TEST(OptionalTest, GreaterEq_RightEmpty) {
+  Optional<int> l(1);
+  Optional<int> r;
+
+  EXPECT_TRUE(l >= r);
+}
+
+TEST(OptionalTest, GreaterEq_BothValue) {
+  {
+    Optional<int> l(1);
+    Optional<int> r(2);
+
+    EXPECT_FALSE(l >= r);
+  }
+  {
+    Optional<int> l(2);
+    Optional<int> r(1);
+
+    EXPECT_TRUE(l >= r);
+  }
+  {
+    Optional<int> l(1);
+    Optional<int> r(1);
+
+    EXPECT_TRUE(l >= r);
+  }
+}
+
+TEST(OptionalTest, OptNullEq) {
+  {
+    Optional<int> opt;
+    EXPECT_TRUE(opt == rtc::nullopt);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_FALSE(opt == rtc::nullopt);
+  }
+}
+
+TEST(OptionalTest, NullOptEq) {
+  {
+    Optional<int> opt;
+    EXPECT_TRUE(rtc::nullopt == opt);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_FALSE(rtc::nullopt == opt);
+  }
+}
+
+TEST(OptionalTest, OptNullNotEq) {
+  {
+    Optional<int> opt;
+    EXPECT_FALSE(opt != rtc::nullopt);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_TRUE(opt != rtc::nullopt);
+  }
+}
+
+TEST(OptionalTest, NullOptNotEq) {
+  {
+    Optional<int> opt;
+    EXPECT_FALSE(rtc::nullopt != opt);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_TRUE(rtc::nullopt != opt);
+  }
+}
+
+TEST(OptionalTest, OptNullLower) {
+  {
+    Optional<int> opt;
+    EXPECT_FALSE(opt < rtc::nullopt);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_FALSE(opt < rtc::nullopt);
+  }
+}
+
+TEST(OptionalTest, NullOptLower) {
+  {
+    Optional<int> opt;
+    EXPECT_FALSE(rtc::nullopt < opt);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_TRUE(rtc::nullopt < opt);
+  }
+}
+
+TEST(OptionalTest, OptNullLowerEq) {
+  {
+    Optional<int> opt;
+    EXPECT_TRUE(opt <= rtc::nullopt);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_FALSE(opt <= rtc::nullopt);
+  }
+}
+
+TEST(OptionalTest, NullOptLowerEq) {
+  {
+    Optional<int> opt;
+    EXPECT_TRUE(rtc::nullopt <= opt);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_TRUE(rtc::nullopt <= opt);
+  }
+}
+
+TEST(OptionalTest, OptNullGreater) {
+  {
+    Optional<int> opt;
+    EXPECT_FALSE(opt > rtc::nullopt);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_TRUE(opt > rtc::nullopt);
+  }
+}
+
+TEST(OptionalTest, NullOptGreater) {
+  {
+    Optional<int> opt;
+    EXPECT_FALSE(rtc::nullopt > opt);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_FALSE(rtc::nullopt > opt);
+  }
+}
+
+TEST(OptionalTest, OptNullGreaterEq) {
+  {
+    Optional<int> opt;
+    EXPECT_TRUE(opt >= rtc::nullopt);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_TRUE(opt >= rtc::nullopt);
+  }
+}
+
+TEST(OptionalTest, NullOptGreaterEq) {
+  {
+    Optional<int> opt;
+    EXPECT_TRUE(rtc::nullopt >= opt);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_FALSE(rtc::nullopt >= opt);
+  }
+}
+
+TEST(OptionalTest, ValueEq_Empty) {
+  Optional<int> opt;
+  EXPECT_FALSE(opt == 1);
+}
+
+TEST(OptionalTest, ValueEq_NotEmpty) {
+  {
+    Optional<int> opt(0);
+    EXPECT_FALSE(opt == 1);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_TRUE(opt == 1);
+  }
+}
+
+TEST(OptionalTest, EqValue_Empty) {
+  Optional<int> opt;
+  EXPECT_FALSE(1 == opt);
+}
+
+TEST(OptionalTest, EqValue_NotEmpty) {
+  {
+    Optional<int> opt(0);
+    EXPECT_FALSE(1 == opt);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_TRUE(1 == opt);
+  }
+}
+
+TEST(OptionalTest, ValueNotEq_Empty) {
+  Optional<int> opt;
+  EXPECT_TRUE(opt != 1);
+}
+
+TEST(OptionalTest, ValueNotEq_NotEmpty) {
+  {
+    Optional<int> opt(0);
+    EXPECT_TRUE(opt != 1);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_FALSE(opt != 1);
+  }
+}
+
+TEST(OptionalTest, NotEqValue_Empty) {
+  Optional<int> opt;
+  EXPECT_TRUE(1 != opt);
+}
+
+TEST(OptionalTest, NotEqValue_NotEmpty) {
+  {
+    Optional<int> opt(0);
+    EXPECT_TRUE(1 != opt);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_FALSE(1 != opt);
+  }
+}
+
+TEST(OptionalTest, ValueLess_Empty) {
+  Optional<int> opt;
+  EXPECT_TRUE(opt < 1);
+}
+
+TEST(OptionalTest, ValueLess_NotEmpty) {
+  {
+    Optional<int> opt(0);
+    EXPECT_TRUE(opt < 1);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_FALSE(opt < 1);
+  }
+  {
+    Optional<int> opt(2);
+    EXPECT_FALSE(opt < 1);
+  }
+}
+
+TEST(OptionalTest, LessValue_Empty) {
+  Optional<int> opt;
+  EXPECT_FALSE(1 < opt);
+}
+
+TEST(OptionalTest, LessValue_NotEmpty) {
+  {
+    Optional<int> opt(0);
+    EXPECT_FALSE(1 < opt);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_FALSE(1 < opt);
+  }
+  {
+    Optional<int> opt(2);
+    EXPECT_TRUE(1 < opt);
+  }
+}
+
+TEST(OptionalTest, ValueLessEq_Empty) {
+  Optional<int> opt;
+  EXPECT_TRUE(opt <= 1);
+}
+
+TEST(OptionalTest, ValueLessEq_NotEmpty) {
+  {
+    Optional<int> opt(0);
+    EXPECT_TRUE(opt <= 1);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_TRUE(opt <= 1);
+  }
+  {
+    Optional<int> opt(2);
+    EXPECT_FALSE(opt <= 1);
+  }
+}
+
+TEST(OptionalTest, LessEqValue_Empty) {
+  Optional<int> opt;
+  EXPECT_FALSE(1 <= opt);
+}
+
+TEST(OptionalTest, LessEqValue_NotEmpty) {
+  {
+    Optional<int> opt(0);
+    EXPECT_FALSE(1 <= opt);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_TRUE(1 <= opt);
+  }
+  {
+    Optional<int> opt(2);
+    EXPECT_TRUE(1 <= opt);
+  }
+}
+
+TEST(OptionalTest, ValueGreater_Empty) {
+  Optional<int> opt;
+  EXPECT_FALSE(opt > 1);
+}
+
+TEST(OptionalTest, ValueGreater_NotEmpty) {
+  {
+    Optional<int> opt(0);
+    EXPECT_FALSE(opt > 1);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_FALSE(opt > 1);
+  }
+  {
+    Optional<int> opt(2);
+    EXPECT_TRUE(opt > 1);
+  }
+}
+
+TEST(OptionalTest, GreaterValue_Empty) {
+  Optional<int> opt;
+  EXPECT_TRUE(1 > opt);
+}
+
+TEST(OptionalTest, GreaterValue_NotEmpty) {
+  {
+    Optional<int> opt(0);
+    EXPECT_TRUE(1 > opt);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_FALSE(1 > opt);
+  }
+  {
+    Optional<int> opt(2);
+    EXPECT_FALSE(1 > opt);
+  }
+}
+
+TEST(OptionalTest, ValueGreaterEq_Empty) {
+  Optional<int> opt;
+  EXPECT_FALSE(opt >= 1);
+}
+
+TEST(OptionalTest, ValueGreaterEq_NotEmpty) {
+  {
+    Optional<int> opt(0);
+    EXPECT_FALSE(opt >= 1);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_TRUE(opt >= 1);
+  }
+  {
+    Optional<int> opt(2);
+    EXPECT_TRUE(opt >= 1);
+  }
+}
+
+TEST(OptionalTest, GreaterEqValue_Empty) {
+  Optional<int> opt;
+  EXPECT_TRUE(1 >= opt);
+}
+
+TEST(OptionalTest, GreaterEqValue_NotEmpty) {
+  {
+    Optional<int> opt(0);
+    EXPECT_TRUE(1 >= opt);
+  }
+  {
+    Optional<int> opt(1);
+    EXPECT_TRUE(1 >= opt);
+  }
+  {
+    Optional<int> opt(2);
+    EXPECT_FALSE(1 >= opt);
+  }
+}
+
+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<TestObject> a(TestObject(3, 0.1));
+    Optional<TestObject> b(TestObject(4, 1.0));
+    EXPECT_TRUE(a != b);
+  }
+}
+
+TEST(OptionalTest, NotEqualsNull) {
+  {
+    Optional<float> a(0.1f);
+    Optional<float> b(0.1f);
+    b = rtc::nullopt;
+    EXPECT_NE(a, b);
+  }
+
+  {
+    Optional<std::string> a("foo");
+    Optional<std::string> b("foo");
+    b = rtc::nullopt;
+    EXPECT_NE(a, b);
+  }
+
+  {
+    Optional<TestObject> a(TestObject(3, 0.1));
+    Optional<TestObject> b(TestObject(3, 0.1));
+    b = rtc::nullopt;
+    EXPECT_TRUE(a != b);
+  }
+}
+
+TEST(OptionalTest, MakeOptional) {
+  {
+    Optional<float> o = rtc::make_optional(32.f);
+    EXPECT_TRUE(o);
+    EXPECT_EQ(32.f, *o);
+
+    float value = 3.f;
+    o = rtc::make_optional(std::move(value));
+    EXPECT_TRUE(o);
+    EXPECT_EQ(3.f, *o);
+  }
+
+  {
+    Optional<std::string> o = rtc::make_optional(std::string("foo"));
+    EXPECT_TRUE(o);
+    EXPECT_EQ("foo", *o);
+
+    std::string value = "bar";
+    o = rtc::make_optional(std::move(value));
+    EXPECT_TRUE(o);
+    EXPECT_EQ(std::string("bar"), *o);
+  }
+
+  {
+    Optional<TestObject> o = rtc::make_optional(TestObject(3, 0.1));
+    EXPECT_TRUE(!!o);
+    EXPECT_TRUE(TestObject(3, 0.1) == *o);
+
+    TestObject value = TestObject(0, 0.42);
+    o = rtc::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::MOVE_ASSIGNED, o->state());
+
+    EXPECT_EQ(TestObject::State::MOVE_CONSTRUCTED,
+              rtc::make_optional(std::move(value))->state());
+  }
+}
+
+TEST(OptionalTest, NonMemberSwap_bothNoValue) {
+  Optional<TestObject> a, b;
+  rtc::swap(a, b);
+
+  EXPECT_FALSE(!!a);
+  EXPECT_FALSE(!!b);
+  EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42)));
+  EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42)));
+}
+
+TEST(OptionalTest, NonMemberSwap_inHasValue) {
+  Optional<TestObject> a(TestObject(1, 0.3));
+  Optional<TestObject> b;
+  rtc::swap(a, b);
+
+  EXPECT_FALSE(!!a);
+  EXPECT_TRUE(!!b);
+  EXPECT_TRUE(TestObject(42, 0.42) == a.value_or(TestObject(42, 0.42)));
+  EXPECT_TRUE(TestObject(1, 0.3) == b.value_or(TestObject(42, 0.42)));
+}
+
+TEST(OptionalTest, NonMemberSwap_outHasValue) {
+  Optional<TestObject> a;
+  Optional<TestObject> b(TestObject(1, 0.3));
+  rtc::swap(a, b);
+
+  EXPECT_TRUE(!!a);
+  EXPECT_FALSE(!!b);
+  EXPECT_TRUE(TestObject(1, 0.3) == a.value_or(TestObject(42, 0.42)));
+  EXPECT_TRUE(TestObject(42, 0.42) == b.value_or(TestObject(42, 0.42)));
+}
+
+TEST(OptionalTest, NonMemberSwap_bothValue) {
+  Optional<TestObject> a(TestObject(0, 0.1));
+  Optional<TestObject> b(TestObject(1, 0.3));
+  rtc::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)));
+  }
+
+  {
+    std::hash<std::string> str_hash;
+    std::hash<Optional<std::string>> opt_str_hash;
+
+    EXPECT_EQ(str_hash(std::string("foobar")),
+              opt_str_hash(Optional<std::string>(std::string("foobar"))));
+  }
+}
+
+TEST(OptionalTest, Hash_NullOptEqualsNullOpt) {
+  std::hash<Optional<int>> opt_int_hash;
+  std::hash<Optional<std::string>> opt_str_hash;
+
+  EXPECT_EQ(opt_str_hash(Optional<std::string>()),
+            opt_int_hash(Optional<int>()));
+}
+
+TEST(OptionalTest, Hash_UseInSet) {
+  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 rtc