Add all the relational operators to std::experimental::optional. Also update bad_optional_access to match the Library Fundamentals draft standard. This is not all of the upcoming changes to optional, though.

llvm-svn: 223775

24 files changed, 1063 insertions, 282 deletions

diff --git a/libcxx/include/experimental/optional b/libcxx/include/experimental/optional
index 2f0df35db2d..a384882a1e1 100644
--- a/libcxx/include/experimental/optional
+++ b/libcxx/include/experimental/optional
@@ -16,131 +16,147 @@
 
 // C++1y
 
-#include <initializer_list>
-
-namespace std { namespace experimental {
-
-// optional for object types
-template <class T>
-class optional
-{
-public:
-    typedef T value_type;
-
-    // constructors
-    constexpr optional() noexcept;
-    constexpr optional(nullopt_t) noexcept;
-    optional(const optional&);
-    optional(optional&&) noexcept(is_nothrow_move_constructible<T>::value);
-    constexpr optional(const T&);
-    constexpr optional(T&&);
-    template <class... Args> constexpr explicit optional(in_place_t, Args&&...);
-    template <class U, class... Args>
-        constexpr explicit optional(in_place_t, initializer_list<U>, Args&&...);
-
-    // destructor
-    ~optional();
-
-    // assignment
-    optional& operator=(nullopt_t) noexcept;
-    optional& operator=(const optional&);
-    optional& operator=(optional&&)
-        noexcept(is_nothrow_move_assignable<T>::value &&
-                 is_nothrow_move_constructible<T>::value);
-    template <class U> optional& operator=(U&&);
-    template <class... Args> void emplace(Args&&...);
-    template <class U, class... Args> void emplace(initializer_list<U>, Args&&...);
-
-    // swap
-    void swap(optional&)
-        noexcept(is_nothrow_move_constructible<T>::value &&
-                 noexcept(swap(declval<T&>(), declval<T&>())));
-
-    // observers
-    constexpr T const* operator->() const;
-    T* operator->();
-    constexpr T const& operator*() const;
-    T& operator*();
-    constexpr explicit operator bool() const noexcept;
-    constexpr T const& value() const;
-    T& value();
-    template <class U> constexpr T value_or(U&&) const&;
-    template <class U> T value_or(U&&) &&;
-};
-
-// In-place construction
-struct in_place_t{};
-constexpr in_place_t in_place{};
-
-// Disengaged state indicator
-struct nullopt_t{see below};
-constexpr nullopt_t nullopt(unspecified);
-
-// class bad_optional_access
-class bad_optional_access
-    : public logic_error
-{
-public:
-    explicit bad_optional_access(const string& what_arg);
-    explicit bad_optional_access(const char* what_arg);
-};
-
-// Relational operators
-template <class T> constexpr bool operator==(const optional<T>&, const optional<T>&);
-template <class T> constexpr bool operator< (const optional<T>&, const optional<T>&);
-
-// Comparison with nullopt
-template <class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept;
-template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept;
-template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept;
-template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept;
-
-// Comparison with T
-template <class T> constexpr bool operator==(const optional<T>&, const T&);
-template <class T> constexpr bool operator==(const T&, const optional<T>&);
-template <class T> constexpr bool operator<(const optional<T>&, const T&);
-template <class T> constexpr bool operator<(const T&, const optional<T>&);
-
-// Specialized algorithms
-template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below);
-template <class T> constexpr optional<typename decay<T>::type> make_optional(T&&);
-
-// hash support
-template <class T> struct hash;
-template <class T> struct hash<optional<T>>;
-
-}}  // std::experimental
+namespace std { namespace experimental { inline namespace fundamentals_v1 {
+
+    // 5.3, optional for object types
+    template <class T> class optional;
+
+    // 5.4, In-place construction
+    struct in_place_t{};
+    constexpr in_place_t in_place{};
+
+    // 5.5, No-value state indicator
+    struct nullopt_t{see below};
+    constexpr nullopt_t nullopt(unspecified);
+
+    // 5.6, Class bad_optional_access
+    class bad_optional_access;
+
+    // 5.7, Relational operators
+    template <class T>
+      constexpr bool operator==(const optional<T>&, const optional<T>&);
+    template <class T>
+      constexpr bool operator!=(const optional<T>&, const optional<T>&);
+    template <class T>
+      constexpr bool operator<(const optional<T>&, const optional<T>&);
+    template <class T>
+      constexpr bool operator>(const optional<T>&, const optional<T>&);
+    template <class T>
+      constexpr bool operator<=(const optional<T>&, const optional<T>&);
+    template <class T>
+      constexpr bool operator>=(const optional<T>&, const optional<T>&);
+
+    // 5.8, Comparison with nullopt
+    template <class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept;
+    template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept;
+    template <class T> constexpr bool operator!=(const optional<T>&, nullopt_t) noexcept;
+    template <class T> constexpr bool operator!=(nullopt_t, const optional<T>&) noexcept;
+    template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept;
+    template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept;
+    template <class T> constexpr bool operator<=(const optional<T>&, nullopt_t) noexcept;
+    template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept;
+    template <class T> constexpr bool operator>(const optional<T>&, nullopt_t) noexcept;
+    template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept;
+    template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept;
+    template <class T> constexpr bool operator>=(nullopt_t, const optional<T>&) noexcept;
+
+    // 5.9, Comparison with T
+    template <class T> constexpr bool operator==(const optional<T>&, const T&);
+    template <class T> constexpr bool operator==(const T&, const optional<T>&);
+    template <class T> constexpr bool operator!=(const optional<T>&, const T&);
+    template <class T> constexpr bool operator!=(const T&, const optional<T>&);
+    template <class T> constexpr bool operator<(const optional<T>&, const T&);
+    template <class T> constexpr bool operator<(const T&, const optional<T>&);
+    template <class T> constexpr bool operator<=(const optional<T>&, const T&);
+    template <class T> constexpr bool operator<=(const T&, const optional<T>&);
+    template <class T> constexpr bool operator>(const optional<T>&, const T&);
+    template <class T> constexpr bool operator>(const T&, const optional<T>&);
+    template <class T> constexpr bool operator>=(const optional<T>&, const T&);
+    template <class T> constexpr bool operator>=(const T&, const optional<T>&);
+
+    // 5.10, Specialized algorithms
+    template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below);
+    template <class T> constexpr optional<see below> make_optional(T&&);
+
+	template <class T>
+	class optional
+	{
+	public:
+	  typedef T value_type;
+
+	  // 5.3.1, Constructors
+	  constexpr optional() noexcept;
+	  constexpr optional(nullopt_t) noexcept;
+	  optional(const optional&);
+	  optional(optional&&) noexcept(see below);
+	  constexpr optional(const T&);
+	  constexpr optional(T&&);
+	  template <class... Args> constexpr explicit optional(in_place_t, Args&&...);
+	  template <class U, class... Args>
+		constexpr explicit optional(in_place_t, initializer_list<U>, Args&&...);
+
+	  // 5.3.2, Destructor
+	  ~optional();
+
+	  // 5.3.3, Assignment
+	  optional& operator=(nullopt_t) noexcept;
+	  optional& operator=(const optional&);
+	  optional& operator=(optional&&) noexcept(see below);
+	  template <class U> optional& operator=(U&&);
+	  template <class... Args> void emplace(Args&&...);
+	  template <class U, class... Args>
+		void emplace(initializer_list<U>, Args&&...);
+
+	  // 5.3.4, Swap
+	  void swap(optional&) noexcept(see below);
+
+	  // 5.3.5, Observers
+	  constexpr T const* operator ->() const;
+	  constexpr T* operator ->();
+	  constexpr T const& operator *() const &;
+	  constexpr T& operator *() &;
+	  constexpr T&& operator *() &&;
+	  constexpr const T&& operator *() const &&;
+	  constexpr explicit operator bool() const noexcept;
+	  constexpr T const& value() const &;
+	  constexpr T& value() &;
+	  constexpr T&& value() &&;
+	  constexpr const T&& value() const &&;
+	  template <class U> constexpr T value_or(U&&) const &;
+	  template <class U> constexpr T value_or(U&&) &&;
+
+	private:
+	  T*   val;  // exposition only
+	};
+
+  } // namespace fundamentals_v1
+  } // namespace experimental
+
+  // 5.11, Hash support
+  template <class T> struct hash;
+  template <class T> struct hash<experimental::optional<T>>;
+
+} // namespace std
 
 */
 
-#include <__config>
+#include <experimental/__config>
 #include <functional>
 #include <stdexcept>
 
-namespace std { namespace experimental {
-
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
 class _LIBCPP_EXCEPTION_ABI bad_optional_access
-    : public logic_error
+    : public std::logic_error
 {
 public:
-#if _LIBCPP_STD_VER > 11
-    _LIBCPP_INLINE_VISIBILITY explicit bad_optional_access(const string& __arg)
-        : logic_error(__arg) {}
-    _LIBCPP_INLINE_VISIBILITY explicit bad_optional_access(const char* __arg)
-        : logic_error(__arg) {}
-    _LIBCPP_INLINE_VISIBILITY bad_optional_access(const bad_optional_access&) noexcept = default;
-    _LIBCPP_INLINE_VISIBILITY bad_optional_access& operator=(const bad_optional_access&) noexcept = default;
-#else
-private:
-    bad_optional_access(const bad_optional_access&);
-    bad_optional_access& operator=(const bad_optional_access&);
-public:
-#endif  // _LIBCPP_STD_VER > 11
-    // Get the key function ~bad_optional_access() into the dylib even if not compiling for C++1y
+	bad_optional_access() : std::logic_error("Bad optional Access") {}
+
+//	Get the key function ~bad_optional_access() into the dylib
     virtual ~bad_optional_access() _NOEXCEPT;
 };
 
-}}  // std::experimental
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL
+
 
 #if _LIBCPP_STD_VER > 11
 
@@ -148,16 +164,14 @@ public:
 #include <type_traits>
 #include <new>
 #include <__functional_base>
-
 #include <__undef_min_max>
-
 #include <__debug>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
-namespace std { namespace experimental { inline namespace __library_fundamentals_v1 {
+_LIBCPP_BEGIN_NAMESPACE_LFTS
 
 struct in_place_t {};
 constexpr in_place_t in_place{};
@@ -503,7 +517,7 @@ public:
     constexpr value_type const& value() const
     {
         if (!this->__engaged_)
-            throw bad_optional_access("optional<T>::value: not engaged");
+            throw bad_optional_access();
         return this->__val_;
     }
 
@@ -511,7 +525,7 @@ public:
     value_type& value()
     {
         if (!this->__engaged_)
-            throw bad_optional_access("optional<T>::value: not engaged");
+            throw bad_optional_access();
         return this->__val_;
     }
 
@@ -556,6 +570,7 @@ private:
     }
 };
 
+// Comparisons between optionals
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 constexpr
@@ -573,19 +588,57 @@ template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 constexpr
 bool
+operator!=(const optional<_Tp>& __x, const optional<_Tp>& __y)
+{
+    return !(__x == __y);
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
 operator<(const optional<_Tp>& __x, const optional<_Tp>& __y)
 {
     if (!static_cast<bool>(__y))
         return false;
     if (!static_cast<bool>(__x))
         return true;
-    return less<_Tp>{}(*__x, *__y);
+    return *__x < *__y;
 }
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 constexpr
 bool
+operator>(const optional<_Tp>& __x, const optional<_Tp>& __y)
+{
+    return __y < __x;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator<=(const optional<_Tp>& __x, const optional<_Tp>& __y)
+{
+    return !(__y < __x);
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator>=(const optional<_Tp>& __x, const optional<_Tp>& __y)
+{
+    return !(__x < __y);
+}
+
+
+// Comparisons with nullopt
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
 operator==(const optional<_Tp>& __x, nullopt_t) noexcept
 {
     return !static_cast<bool>(__x);
@@ -604,6 +657,24 @@ template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 constexpr
 bool
+operator!=(const optional<_Tp>& __x, nullopt_t) noexcept
+{
+    return static_cast<bool>(__x);
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator!=(nullopt_t, const optional<_Tp>& __x) noexcept
+{
+    return static_cast<bool>(__x);
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
 operator<(const optional<_Tp>&, nullopt_t) noexcept
 {
     return false;
@@ -622,6 +693,61 @@ template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 constexpr
 bool
+operator<=(const optional<_Tp>& __x, nullopt_t) noexcept
+{
+    return !static_cast<bool>(__x);
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator<=(nullopt_t, const optional<_Tp>& __x) noexcept
+{
+    return true;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator>(const optional<_Tp>& __x, nullopt_t) noexcept
+{
+    return static_cast<bool>(__x);
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator>(nullopt_t, const optional<_Tp>& __x) noexcept
+{
+    return false;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator>=(const optional<_Tp>&, nullopt_t) noexcept
+{
+    return true;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator>=(nullopt_t, const optional<_Tp>& __x) noexcept
+{
+    return !static_cast<bool>(__x);
+}
+
+// Comparisons with T
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
 operator==(const optional<_Tp>& __x, const _Tp& __v)
 {
     return static_cast<bool>(__x) ? *__x == __v : false;
@@ -640,6 +766,24 @@ template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 constexpr
 bool
+operator!=(const optional<_Tp>& __x, const _Tp& __v)
+{
+    return static_cast<bool>(__x) ? !(*__x == __v) : true;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator!=(const _Tp& __v, const optional<_Tp>& __x)
+{
+    return static_cast<bool>(__x) ? !(*__x == __v) : true;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
 operator<(const optional<_Tp>& __x, const _Tp& __v)
 {
     return static_cast<bool>(__x) ? less<_Tp>{}(*__x, __v) : true;
@@ -656,6 +800,61 @@ operator<(const _Tp& __v, const optional<_Tp>& __x)
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator<=(const optional<_Tp>& __x, const _Tp& __v)
+{
+    return !(__x > __v);
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator<=(const _Tp& __v, const optional<_Tp>& __x)
+{
+    return !(__v > __x);
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator>(const optional<_Tp>& __x, const _Tp& __v)
+{
+    return static_cast<bool>(__x) ? __v < __x : false;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator>(const _Tp& __v, const optional<_Tp>& __x)
+{
+    return static_cast<bool>(__x) ? __x < __v : true;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator>=(const optional<_Tp>& __x, const _Tp& __v)
+{
+    return !(__x < __v);
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+constexpr
+bool
+operator>=(const _Tp& __v, const optional<_Tp>& __x)
+{
+    return !(__v < __x);
+}
+
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y)))
 {
@@ -671,7 +870,7 @@ make_optional(_Tp&& __v)
     return optional<typename decay<_Tp>::type>(_VSTD::forward<_Tp>(__v));
 }
 
-}}}  // namespace std::experimental::__library_fundamentals_v1
+_LIBCPP_END_NAMESPACE_LFTS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
diff --git a/libcxx/src/optional.cpp b/libcxx/src/optional.cpp
index b614d811612..8c5dd76d86d 100644
--- a/libcxx/src/optional.cpp
+++ b/libcxx/src/optional.cpp
@@ -9,8 +9,7 @@
 
 #include "experimental/optional"
 
-namespace std  // purposefully not using versioning namespace
-{ namespace experimental {
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
 
 #ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
 
@@ -22,4 +21,4 @@ bad_optional_access::~bad_optional_access() _NOEXCEPT = default;
 
 #endif
 
-}}  // std::experimental
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL
diff --git a/libcxx/test/utilities/optional/optional.bad_optional_access/char_pointer.pass.cpp b/libcxx/test/utilities/optional/optional.bad_optional_access/char_pointer.pass.cpp
deleted file mode 100644
index eacf34c34aa..00000000000
--- a/libcxx/test/utilities/optional/optional.bad_optional_access/char_pointer.pass.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// <optional>
-
-// class bad_optional_access;
-// explicit bad_optional_access(const char* what_arg);
-
-#include <experimental/optional>
-#include <string>
-#include <cstring>
-#include <cassert>
-
-int main()
-{
-#if _LIBCPP_STD_VER > 11
-    using std::experimental::bad_optional_access;
-
-    const char* s = "message";
-    bad_optional_access e(s);
-    assert(std::strcmp(e.what(), s) == 0);
-#endif  // _LIBCPP_STD_VER > 11
-}
diff --git a/libcxx/test/utilities/optional/optional.bad_optional_access/copy_assign.pass.cpp b/libcxx/test/utilities/optional/optional.bad_optional_access/copy_assign.pass.cpp
deleted file mode 100644
index bb78ca4f440..00000000000
--- a/libcxx/test/utilities/optional/optional.bad_optional_access/copy_assign.pass.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// <optional>
-
-// class bad_optional_access;
-// bad_optional_access& operator=(const bad_optional_access&);
-
-#include <experimental/optional>
-#include <string>
-#include <cstring>
-#include <type_traits>
-#include <cassert>
-
-int main()
-{
-#if _LIBCPP_STD_VER > 11
-    using std::experimental::bad_optional_access;
-
-    static_assert(std::is_nothrow_copy_assignable<bad_optional_access>::value, "");
-    const std::string s1("one message");
-    const std::string s2("another message");
-    bad_optional_access e1(s1);
-    bad_optional_access e2(s2);
-    assert(std::strcmp(e1.what(), e2.what()) != 0);
-    e1 = e2;
-    assert(std::strcmp(e1.what(), e2.what()) == 0);
-#endif  // _LIBCPP_STD_VER > 11
-}
diff --git a/libcxx/test/utilities/optional/optional.bad_optional_access/copy_ctor.pass.cpp b/libcxx/test/utilities/optional/optional.bad_optional_access/copy_ctor.pass.cpp
deleted file mode 100644
index 30ef533e711..00000000000
--- a/libcxx/test/utilities/optional/optional.bad_optional_access/copy_ctor.pass.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// <optional>
-
-// class bad_optional_access;
-// bad_optional_access(const bad_optional_access&);
-
-#include <experimental/optional>
-#include <string>
-#include <cstring>
-#include <type_traits>
-#include <cassert>
-
-int main()
-{
-#if _LIBCPP_STD_VER > 11
-    using std::experimental::bad_optional_access;
-
-    static_assert(std::is_nothrow_copy_constructible<bad_optional_access>::value, "");
-    const std::string s("another message");
-    bad_optional_access e1(s);
-    bad_optional_access e2 = e1;
-    assert(std::strcmp(e1.what(), e2.what()) == 0);
-#endif  // _LIBCPP_STD_VER > 11
-}
diff --git a/libcxx/test/utilities/optional/optional.bad_optional_access/default.pass.cpp b/libcxx/test/utilities/optional/optional.bad_optional_access/default.pass.cpp
index 606be40b8b3..cecf98a3518 100644
--- a/libcxx/test/utilities/optional/optional.bad_optional_access/default.pass.cpp
+++ b/libcxx/test/utilities/optional/optional.bad_optional_access/default.pass.cpp
@@ -9,7 +9,7 @@
 
 // <optional>
 
-// class bad_optional_access is not default constructible
+// class bad_optional_access is default constructible
 
 #include <experimental/optional>
 #include <type_traits>
@@ -18,7 +18,6 @@ int main()
 {
 #if _LIBCPP_STD_VER > 11
     using std::experimental::bad_optional_access;
-
-    static_assert(!std::is_default_constructible<bad_optional_access>::value, "");
+    bad_optional_access ex;
 #endif  // _LIBCPP_STD_VER > 11
 }
diff --git a/libcxx/test/utilities/optional/optional.bad_optional_access/string.pass.cpp b/libcxx/test/utilities/optional/optional.bad_optional_access/string.pass.cpp
deleted file mode 100644
index d0b3fb519ca..00000000000
--- a/libcxx/test/utilities/optional/optional.bad_optional_access/string.pass.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// <optional>
-
-// class bad_optional_access;
-// explicit bad_optional_access(const string& what_arg);
-
-#include <experimental/optional>
-#include <string>
-#include <cstring>
-#include <cassert>
-
-int main()
-{
-#if _LIBCPP_STD_VER > 11
-    using std::experimental::bad_optional_access;
-
-    const std::string s("message");
-    bad_optional_access e(s);
-    assert(std::strcmp(e.what(), s.c_str()) == 0);
-#endif  // _LIBCPP_STD_VER > 11
-}
diff --git a/libcxx/test/utilities/optional/optional.comp_with_t/equal.pass.cpp b/libcxx/test/utilities/optional/optional.comp_with_t/equal.pass.cpp
index 2380739cf03..e796723cc09 100644
--- a/libcxx/test/utilities/optional/optional.comp_with_t/equal.pass.cpp
+++ b/libcxx/test/utilities/optional/optional.comp_with_t/equal.pass.cpp
@@ -38,21 +38,21 @@ int main()
     typedef optional<T> O;
     
     constexpr T val(2);
-    constexpr O o1;     // disengaged
-    constexpr O o2{1};  // engaged
+    constexpr O o1;       // disengaged
+    constexpr O o2{1};    // engaged
     constexpr O o3{val};  // engaged
 
     static_assert ( !(o1 == T(1)), "" );
-    static_assert (   o2 == T(1),  "" );
+    static_assert (  (o2 == T(1)), "" );
     static_assert ( !(o3 == T(1)), "" );
-    static_assert (   o3 == T(2) , "" );
-    static_assert (   o3 == val, "" );
+    static_assert (  (o3 == T(2)), "" );
+    static_assert (  (o3 == val),  "" );
         
     static_assert ( !(T(1) == o1), "" );
-    static_assert (   T(1) == o2,  "" );
+    static_assert (  (T(1) == o2), "" );
     static_assert ( !(T(1) == o3), "" );
-    static_assert (   T(2) == o3 , "" );
-    static_assert ( val == o3 , "" );
+    static_assert (  (T(2) == o3), "" );
+    static_assert (  (val  == o3), "" );
     }
 #endif
 }
diff --git a/libcxx/test/utilities/optional/optional.comp_with_t/greater.pass.cpp b/libcxx/test/utilities/optional/optional.comp_with_t/greater.pass.cpp
new file mode 100644
index 00000000000..cf3923bb4fb
--- /dev/null
+++ b/libcxx/test/utilities/optional/optional.comp_with_t/greater.pass.cpp
@@ -0,0 +1,61 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <optional>
+
+// template <class T> constexpr bool operator>(const optional<T>& x, const T& v);
+// template <class T> constexpr bool operator>(const T& v, const optional<T>& x);
+
+#include <experimental/optional>
+
+#if _LIBCPP_STD_VER > 11
+
+using std::experimental::optional;
+
+struct X
+{
+    int i_;
+
+    constexpr X(int i) : i_(i) {}
+};
+
+constexpr bool operator < ( const X &lhs, const X &rhs )
+    { return lhs.i_ < rhs.i_ ; }
+    
+#endif
+
+int main()
+{
+#if _LIBCPP_STD_VER > 11
+
+    {
+    typedef X T;
+    typedef optional<T> O;
+
+    constexpr T val(2);
+    constexpr O o1;       // disengaged
+    constexpr O o2{1};    // engaged
+    constexpr O o3{val};  // engaged
+
+    static_assert ( !(o1 > T(1)), "" );
+    static_assert ( !(o2 > T(1)), "" );  // equal
+    static_assert (  (o3 > T(1)), "" );
+    static_assert ( !(o2 >  val), "" );
+    static_assert ( !(o3 >  val), "" );  // equal
+    static_assert ( !(o3 > T(3)), "" );
+
+    static_assert (   (T(1) > o1), "" );
+    static_assert (  !(T(1) > o2), "" ); // equal
+    static_assert (  !(T(1) > o3), "" );
+    static_assert (   (val  > o2), "" );
+    static_assert (  !(val  > o3), "" ); // equal
+    static_assert (   (T(3) > o3), "" );
+    }
+#endif
+}
diff --git a/libcxx/test/utilities/optional/optional.comp_with_t/greater_equal.pass.cpp b/libcxx/test/utilities/optional/optional.comp_with_t/greater_equal.pass.cpp
new file mode 100644
index 00000000000..85fea1377b3
--- /dev/null
+++ b/libcxx/test/utilities/optional/optional.comp_with_t/greater_equal.pass.cpp
@@ -0,0 +1,61 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <optional>
+
+// template <class T> constexpr bool operator>=(const optional<T>& x, const T& v);
+// template <class T> constexpr bool operator>=(const T& v, const optional<T>& x);
+
+#include <experimental/optional>
+
+#if _LIBCPP_STD_VER > 11
+
+using std::experimental::optional;
+
+struct X
+{
+    int i_;
+
+    constexpr X(int i) : i_(i) {}
+};
+
+constexpr bool operator < ( const X &lhs, const X &rhs )
+    { return lhs.i_ < rhs.i_ ; }
+    
+#endif
+
+int main()
+{
+#if _LIBCPP_STD_VER > 11
+
+    {
+    typedef X T;
+    typedef optional<T> O;
+
+    constexpr T val(2);
+    constexpr O o1;       // disengaged
+    constexpr O o2{1};    // engaged
+    constexpr O o3{val};  // engaged
+
+    static_assert ( !(o1 >= T(1)), "" );
+    static_assert (  (o2 >= T(1)), "" );  // equal
+    static_assert (  (o3 >= T(1)), "" );
+    static_assert ( !(o2 >=  val), "" );
+    static_assert (  (o3 >=  val), "" );  // equal
+    static_assert ( !(o3 >= T(3)), "" );
+
+    static_assert (   (T(1) >= o1), "" );
+    static_assert (   (T(1) >= o2), "" ); // equal
+    static_assert (  !(T(1) >= o3), "" );
+    static_assert (   (val  >= o2), "" );
+    static_assert (   (val  >= o3), "" ); // equal
+    static_assert (   (T(3) >= o3), "" );
+    }
+#endif
+}
diff --git a/libcxx/test/utilities/optional/optional.comp_with_t/less_equal.pass.cpp b/libcxx/test/utilities/optional/optional.comp_with_t/less_equal.pass.cpp
new file mode 100644
index 00000000000..333f7cdea21
--- /dev/null
+++ b/libcxx/test/utilities/optional/optional.comp_with_t/less_equal.pass.cpp
@@ -0,0 +1,61 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <optional>
+
+// template <class T> constexpr bool operator<=(const optional<T>& x, const T& v);
+// template <class T> constexpr bool operator<=(const T& v, const optional<T>& x);
+
+#include <experimental/optional>
+
+#if _LIBCPP_STD_VER > 11
+
+using std::experimental::optional;
+
+struct X
+{
+    int i_;
+
+    constexpr X(int i) : i_(i) {}
+};
+
+constexpr bool operator < ( const X &lhs, const X &rhs )
+    { return lhs.i_ < rhs.i_ ; }
+    
+#endif
+
+int main()
+{
+#if _LIBCPP_STD_VER > 11
+
+    {
+    typedef X T;
+    typedef optional<T> O;
+
+    constexpr T val(2);
+    constexpr O o1;       // disengaged
+    constexpr O o2{1};    // engaged
+    constexpr O o3{val};  // engaged
+
+    static_assert (  (o1 <= T(1)), "" );
+    static_assert (  (o2 <= T(1)), "" );  // equal
+    static_assert ( !(o3 <= T(1)), "" );
+    static_assert (  (o2 <=  val), "" );
+    static_assert (  (o3 <=  val), "" );  // equal
+    static_assert (  (o3 <= T(3)), "" );
+
+    static_assert (  !(T(1) <= o1), "" );
+    static_assert (   (T(1) <= o2), "" ); // equal
+    static_assert (   (T(1) <= o3), "" );
+    static_assert (  !(val  <= o2), "" );
+    static_assert (   (val  <= o3), "" ); // equal
+    static_assert (  !(T(3) <= o3), "" );
+    }
+#endif
+}
diff --git a/libcxx/test/utilities/optional/optional.comp_with_t/less_than.pass.cpp b/libcxx/test/utilities/optional/optional.comp_with_t/less_than.pass.cpp
index 808537608eb..e35df21bbab 100644
--- a/libcxx/test/utilities/optional/optional.comp_with_t/less_than.pass.cpp
+++ b/libcxx/test/utilities/optional/optional.comp_with_t/less_than.pass.cpp
@@ -37,24 +37,24 @@ int main()
     {
     typedef X T;
     typedef optional<T> O;
-    
+
     constexpr T val(2);
-    constexpr O o1;     // disengaged
-    constexpr O o2{1};  // engaged
+    constexpr O o1;       // disengaged
+    constexpr O o2{1};    // engaged
     constexpr O o3{val};  // engaged
 
-    static_assert (   o1 < T(1) , "" );
-    static_assert ( !(o2 < T(1)), "" );
+    static_assert (  (o1 < T(1)), "" );
+    static_assert ( !(o2 < T(1)), "" );  // equal
     static_assert ( !(o3 < T(1)), "" );
-    static_assert (   o2 < T(2) , "" );
-    static_assert (   o2 < T(val), "" );
-    static_assert (   o3 < T(3) , "" );
+    static_assert (  (o2 <  val), "" );
+    static_assert ( !(o3 <  val), "" );  // equal
+    static_assert (  (o3 < T(3)), "" );
 
     static_assert (  !(T(1) < o1), "" );
-    static_assert (  !(T(1) < o2), "" );
-    static_assert (    T(1) < o3 , "" );
-    static_assert (  !(T(2) < o2), "" );
-    static_assert (!(T(val) < o2), "" );
+    static_assert (  !(T(1) < o2), "" ); // equal
+    static_assert (   (T(1) < o3), "" );
+    static_assert (  !(val  < o2), "" );
+    static_assert (  !(val  < o3), "" ); // equal
     static_assert (  !(T(3) < o3), "" );
     }
 #endif
diff --git a/libcxx/test/utilities/optional/optional.comp_with_t/not_equal.pass.cpp b/libcxx/test/utilities/optional/optional.comp_with_t/not_equal.pass.cpp
new file mode 100644
index 00000000000..0dad68d3863
--- /dev/null
+++ b/libcxx/test/utilities/optional/optional.comp_with_t/not_equal.pass.cpp
@@ -0,0 +1,58 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <optional>
+
+// template <class T> constexpr bool operator!=(const optional<T>& x, const T& v);
+// template <class T> constexpr bool operator!=(const T& v, const optional<T>& x);
+
+#include <experimental/optional>
+
+#if _LIBCPP_STD_VER > 11
+
+using std::experimental::optional;
+
+struct X
+{
+    int i_;
+
+    constexpr X(int i) : i_(i) {}
+};
+
+constexpr bool operator == ( const X &lhs, const X &rhs )
+    { return lhs.i_ == rhs.i_ ; }
+    
+#endif
+
+int main()
+{
+#if _LIBCPP_STD_VER > 11
+    {
+    typedef X T;
+    typedef optional<T> O;
+    
+    constexpr T val(2);
+    constexpr O o1;       // disengaged
+    constexpr O o2{1};    // engaged
+    constexpr O o3{val};  // engaged
+
+    static_assert (  (o1 != T(1)), "" );
+    static_assert ( !(o2 != T(1)), "" );
+    static_assert (  (o3 != T(1)), "" );
+    static_assert ( !(o3 != T(2)), "" );
+    static_assert ( !(o3 != val),  "" );
+        
+    static_assert (  (T(1) != o1), "" );
+    static_assert ( !(T(1) != o2), "" );
+    static_assert (  (T(1) != o3), "" );
+    static_assert ( !(T(2) != o3), "" );
+    static_assert ( !(val  != o3), "" );
+    }
+#endif
+}
diff --git a/libcxx/test/utilities/optional/optional.nullops/eqaul.pass.cpp b/libcxx/test/utilities/optional/optional.nullops/equal.pass.cpp
index 54fb522d8ca..931db614425 100644
--- a/libcxx/test/utilities/optional/optional.nullops/eqaul.pass.cpp
+++ b/libcxx/test/utilities/optional/optional.nullops/equal.pass.cpp
@@ -29,9 +29,9 @@ int main()
     constexpr O o1;     // disengaged
     constexpr O o2{1};  // engaged
 
-    static_assert (   nullopt == o1 , "" );
+    static_assert (  (nullopt == o1), "" );
     static_assert ( !(nullopt == o2), "" );
-    static_assert (   o1 == nullopt , "" );
+    static_assert (  (o1 == nullopt), "" );
     static_assert ( !(o2 == nullopt), "" );
 
     static_assert (noexcept(nullopt == o1), "");
diff --git a/libcxx/test/utilities/optional/optional.nullops/greater.pass.cpp b/libcxx/test/utilities/optional/optional.nullops/greater.pass.cpp
new file mode 100644
index 00000000000..b72a4d3f1a6
--- /dev/null
+++ b/libcxx/test/utilities/optional/optional.nullops/greater.pass.cpp
@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+// <optional>
+
+// template <class T> constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept;
+// template <class T> constexpr bool operator>(nullopt_t, const optional<T>& x) noexcept;
+
+#include <experimental/optional>
+
+int main()
+{
+#if _LIBCPP_STD_VER > 11
+    using std::experimental::optional;
+    using std::experimental::nullopt_t;
+    using std::experimental::nullopt;
+
+    {
+    typedef int T;
+    typedef optional<T> O;
+    
+    constexpr O o1;     // disengaged
+    constexpr O o2{1};  // engaged
+
+    static_assert ( !(nullopt > o1), "" );
+    static_assert ( !(nullopt > o2), "" );
+    static_assert ( !(o1 > nullopt), "" );
+    static_assert (  (o2 > nullopt), "" );
+
+    static_assert (noexcept(nullopt > o1), "");
+    static_assert (noexcept(o1 > nullopt), "");
+    }
+#endif
+}
diff --git a/libcxx/test/utilities/optional/optional.nullops/greater_equal.pass.cpp b/libcxx/test/utilities/optional/optional.nullops/greater_equal.pass.cpp
new file mode 100644
index 00000000000..86c8743b555
--- /dev/null
+++ b/libcxx/test/utilities/optional/optional.nullops/greater_equal.pass.cpp
@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+// <optional>
+
+// template <class T> constexpr bool operator>=(const optional<T>& x, nullopt_t) noexcept;
+// template <class T> constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept;
+
+#include <experimental/optional>
+
+int main()
+{
+#if _LIBCPP_STD_VER > 11
+    using std::experimental::optional;
+    using std::experimental::nullopt_t;
+    using std::experimental::nullopt;
+
+    {
+    typedef int T;
+    typedef optional<T> O;
+    
+    constexpr O o1;     // disengaged
+    constexpr O o2{1};  // engaged
+
+    static_assert (  (nullopt >= o1), "" );
+    static_assert ( !(nullopt >= o2), "" );
+    static_assert (  (o1 >= nullopt), "" );
+    static_assert (  (o2 >= nullopt), "" );
+
+    static_assert (noexcept(nullopt >= o1), "");
+    static_assert (noexcept(o1 >= nullopt), "");
+    }
+#endif
+}
diff --git a/libcxx/test/utilities/optional/optional.nullops/less_equal.pass.cpp b/libcxx/test/utilities/optional/optional.nullops/less_equal.pass.cpp
new file mode 100644
index 00000000000..3e8444bc73f
--- /dev/null
+++ b/libcxx/test/utilities/optional/optional.nullops/less_equal.pass.cpp
@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+// <optional>
+
+// template <class T> constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept;
+// template <class T> constexpr bool operator<=(nullopt_t, const optional<T>& x) noexcept;
+
+#include <experimental/optional>
+
+int main()
+{
+#if _LIBCPP_STD_VER > 11
+    using std::experimental::optional;
+    using std::experimental::nullopt_t;
+    using std::experimental::nullopt;
+
+    {
+    typedef int T;
+    typedef optional<T> O;
+    
+    constexpr O o1;     // disengaged
+    constexpr O o2{1};  // engaged
+
+    static_assert (  (nullopt <= o1), "" );
+    static_assert (  (nullopt <= o2), "" );
+    static_assert (  (o1 <= nullopt), "" );
+    static_assert ( !(o2 <= nullopt), "" );
+
+    static_assert (noexcept(nullopt <= o1), "");
+    static_assert (noexcept(o1 <= nullopt), "");
+    }
+#endif
+}
diff --git a/libcxx/test/utilities/optional/optional.nullops/less_than.pass.cpp b/libcxx/test/utilities/optional/optional.nullops/less_than.pass.cpp
index 576a98aa4f3..149c809b040 100644
--- a/libcxx/test/utilities/optional/optional.nullops/less_than.pass.cpp
+++ b/libcxx/test/utilities/optional/optional.nullops/less_than.pass.cpp
@@ -30,7 +30,7 @@ int main()
     constexpr O o2{1};  // engaged
 
     static_assert ( !(nullopt < o1), "" );
-    static_assert (   nullopt < o2 , "" );
+    static_assert (  (nullopt < o2), "" );
     static_assert ( !(o1 < nullopt), "" );
     static_assert ( !(o2 < nullopt), "" );
 
diff --git a/libcxx/test/utilities/optional/optional.nullops/not_equal.pass.cpp b/libcxx/test/utilities/optional/optional.nullops/not_equal.pass.cpp
new file mode 100644
index 00000000000..6f28edf6d26
--- /dev/null
+++ b/libcxx/test/utilities/optional/optional.nullops/not_equal.pass.cpp
@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+// <optional>
+
+// template <class T> constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept;
+// template <class T> constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept;
+
+#include <experimental/optional>
+
+int main()
+{
+#if _LIBCPP_STD_VER > 11
+    using std::experimental::optional;
+    using std::experimental::nullopt_t;
+    using std::experimental::nullopt;
+    
+    {
+    typedef int T;
+    typedef optional<T> O;
+    
+    constexpr O o1;     // disengaged
+    constexpr O o2{1};  // engaged
+
+    static_assert ( !(nullopt != o1), "" );
+    static_assert (  (nullopt != o2), "" );
+    static_assert ( !(o1 != nullopt), "" );
+    static_assert (  (o2 != nullopt), "" );
+
+    static_assert (noexcept(nullopt != o1), "");
+    static_assert (noexcept(o1 != nullopt), "");
+    }
+#endif
+}
diff --git a/libcxx/test/utilities/optional/optional.relops/greater_equal.pass.cpp b/libcxx/test/utilities/optional/optional.relops/greater_equal.pass.cpp
new file mode 100644
index 00000000000..98d6855f931
--- /dev/null
+++ b/libcxx/test/utilities/optional/optional.relops/greater_equal.pass.cpp
@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <optional>
+
+// template <class T> constexpr bool operator>= (const optional<T>& x, const optional<T>& y);
+
+#include <experimental/optional>
+
+#if _LIBCPP_STD_VER > 11
+
+using std::experimental::optional;
+
+struct X
+{
+    int i_;
+
+    constexpr X(int i) : i_(i) {}
+};
+
+constexpr bool operator < ( const X &lhs, const X &rhs )
+    { return lhs.i_ < rhs.i_ ; }
+
+#endif
+
+int main()
+{
+#if _LIBCPP_STD_VER > 11
+    {
+    typedef optional<X> O;
+    
+    constexpr O o1;     // disengaged
+    constexpr O o2;     // disengaged
+    constexpr O o3{1};  // engaged
+    constexpr O o4{2};  // engaged
+    constexpr O o5{1};  // engaged
+    
+    static_assert (  (o1 >= o1), "" );
+    static_assert (  (o1 >= o2), "" );
+    static_assert ( !(o1 >= o3), "" );
+    static_assert ( !(o1 >= o4), "" );
+    static_assert ( !(o1 >= o5), "" );
+
+    static_assert (  (o2 >= o1), "" );
+    static_assert (  (o2 >= o2), "" );
+    static_assert ( !(o2 >= o3), "" );
+    static_assert ( !(o2 >= o4), "" );
+    static_assert ( !(o2 >= o5), "" );
+
+    static_assert (  (o3 >= o1), "" );
+    static_assert (  (o3 >= o2), "" );
+    static_assert (  (o3 >= o3), "" );
+    static_assert ( !(o3 >= o4), "" );
+    static_assert (  (o3 >= o5), "" );
+
+    static_assert (  (o4 >= o1), "" );
+    static_assert (  (o4 >= o2), "" );
+    static_assert (  (o4 >= o3), "" );
+    static_assert (  (o4 >= o4), "" );
+    static_assert (  (o4 >= o5), "" );
+
+    static_assert (  (o5 >= o1), "" );
+    static_assert (  (o5 >= o2), "" );
+    static_assert (  (o5 >= o3), "" );
+    static_assert ( !(o5 >= o4), "" );
+    static_assert (  (o5 >= o5), "" );
+    }
+#endif
+}
diff --git a/libcxx/test/utilities/optional/optional.relops/greater_than.pass.cpp b/libcxx/test/utilities/optional/optional.relops/greater_than.pass.cpp
new file mode 100644
index 00000000000..d51bd4f2ac4
--- /dev/null
+++ b/libcxx/test/utilities/optional/optional.relops/greater_than.pass.cpp
@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <optional>
+
+// template <class T> constexpr bool operator> (const optional<T>& x, const optional<T>& y);
+
+#include <experimental/optional>
+
+#if _LIBCPP_STD_VER > 11
+
+using std::experimental::optional;
+
+struct X
+{
+    int i_;
+
+    constexpr X(int i) : i_(i) {}
+};
+
+constexpr bool operator < ( const X &lhs, const X &rhs )
+    { return lhs.i_ < rhs.i_ ; }
+
+#endif
+
+int main()
+{
+#if _LIBCPP_STD_VER > 11
+    {
+    typedef optional<X> O;
+    
+    constexpr O o1;     // disengaged
+    constexpr O o2;     // disengaged
+    constexpr O o3{1};  // engaged
+    constexpr O o4{2};  // engaged
+    constexpr O o5{1};  // engaged
+    
+    static_assert ( !(o1 > o1), "" );
+    static_assert ( !(o1 > o2), "" );
+    static_assert ( !(o1 > o3), "" );
+    static_assert ( !(o1 > o4), "" );
+    static_assert ( !(o1 > o5), "" );
+
+    static_assert ( !(o2 > o1), "" );
+    static_assert ( !(o2 > o2), "" );
+    static_assert ( !(o2 > o3), "" );
+    static_assert ( !(o2 > o4), "" );
+    static_assert ( !(o2 > o5), "" );
+
+    static_assert (  (o3 > o1), "" );
+    static_assert (  (o3 > o2), "" );
+    static_assert ( !(o3 > o3), "" );
+    static_assert ( !(o3 > o4), "" );
+    static_assert ( !(o3 > o5), "" );
+
+    static_assert (  (o4 > o1), "" );
+    static_assert (  (o4 > o2), "" );
+    static_assert (  (o4 > o3), "" );
+    static_assert ( !(o4 > o4), "" );
+    static_assert (  (o4 > o5), "" );
+
+    static_assert (  (o5 > o1), "" );
+    static_assert (  (o5 > o2), "" );
+    static_assert ( !(o5 > o3), "" );
+    static_assert ( !(o5 > o4), "" );
+    static_assert ( !(o5 > o5), "" );
+    }
+#endif
+}
diff --git a/libcxx/test/utilities/optional/optional.relops/less_equal.pass.cpp b/libcxx/test/utilities/optional/optional.relops/less_equal.pass.cpp
new file mode 100644
index 00000000000..326f3a89649
--- /dev/null
+++ b/libcxx/test/utilities/optional/optional.relops/less_equal.pass.cpp
@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <optional>
+
+// template <class T> constexpr bool operator<= (const optional<T>& x, const optional<T>& y);
+
+#include <experimental/optional>
+
+#if _LIBCPP_STD_VER > 11
+
+using std::experimental::optional;
+
+struct X
+{
+    int i_;
+
+    constexpr X(int i) : i_(i) {}
+};
+
+constexpr bool operator < ( const X &lhs, const X &rhs )
+    { return lhs.i_ < rhs.i_ ; }
+
+#endif
+
+int main()
+{
+#if _LIBCPP_STD_VER > 11
+    {
+    typedef optional<X> O;
+    
+    constexpr O o1;     // disengaged
+    constexpr O o2;     // disengaged
+    constexpr O o3{1};  // engaged
+    constexpr O o4{2};  // engaged
+    constexpr O o5{1};  // engaged
+    
+    static_assert (  (o1 <= o1), "" );
+    static_assert (  (o1 <= o2), "" );
+    static_assert (  (o1 <= o3), "" );
+    static_assert (  (o1 <= o4), "" );
+    static_assert (  (o1 <= o5), "" );
+
+    static_assert (  (o2 <= o1), "" );
+    static_assert (  (o2 <= o2), "" );
+    static_assert (  (o2 <= o3), "" );
+    static_assert (  (o2 <= o4), "" );
+    static_assert (  (o2 <= o5), "" );
+
+    static_assert ( !(o3 <= o1), "" );
+    static_assert ( !(o3 <= o2), "" );
+    static_assert (  (o3 <= o3), "" );
+    static_assert (  (o3 <= o4), "" );
+    static_assert (  (o3 <= o5), "" );
+
+    static_assert ( !(o4 <= o1), "" );
+    static_assert ( !(o4 <= o2), "" );
+    static_assert ( !(o4 <= o3), "" );
+    static_assert (  (o4 <= o4), "" );
+    static_assert ( !(o4 <= o5), "" );
+
+    static_assert ( !(o5 <= o1), "" );
+    static_assert ( !(o5 <= o2), "" );
+    static_assert (  (o5 <= o3), "" );
+    static_assert (  (o5 <= o4), "" );
+    static_assert (  (o5 <= o5), "" );
+    }
+#endif
+}
diff --git a/libcxx/test/utilities/optional/optional.relops/less_than.pass.cpp b/libcxx/test/utilities/optional/optional.relops/less_than.pass.cpp
index 8d70e92dda6..37f7e194298 100644
--- a/libcxx/test/utilities/optional/optional.relops/less_than.pass.cpp
+++ b/libcxx/test/utilities/optional/optional.relops/less_than.pass.cpp
@@ -43,20 +43,20 @@ int main()
     
     static_assert ( !(o1 < o1), "" );
     static_assert ( !(o1 < o2), "" );
-    static_assert (   o1 < o3 , "" );
-    static_assert (   o1 < o4 , "" );
-    static_assert (   o1 < o5 , "" );
+    static_assert (  (o1 < o3), "" );
+    static_assert (  (o1 < o4), "" );
+    static_assert (  (o1 < o5), "" );
 
     static_assert ( !(o2 < o1), "" );
     static_assert ( !(o2 < o2), "" );
-    static_assert (   o2 < o3 , "" );
-    static_assert (   o2 < o4 , "" );
-    static_assert (   o2 < o5 , "" );
+    static_assert (  (o2 < o3), "" );
+    static_assert (  (o2 < o4), "" );
+    static_assert (  (o2 < o5), "" );
 
     static_assert ( !(o3 < o1), "" );
     static_assert ( !(o3 < o2), "" );
     static_assert ( !(o3 < o3), "" );
-    static_assert (   o3 < o4 , "" );
+    static_assert (  (o3 < o4), "" );
     static_assert ( !(o3 < o5), "" );
 
     static_assert ( !(o4 < o1), "" );
@@ -68,7 +68,7 @@ int main()
     static_assert ( !(o5 < o1), "" );
     static_assert ( !(o5 < o2), "" );
     static_assert ( !(o5 < o3), "" );
-    static_assert (   o5 < o4 , "" );
+    static_assert (  (o5 < o4), "" );
     static_assert ( !(o5 < o5), "" );
     }
 #endif
diff --git a/libcxx/test/utilities/optional/optional.relops/not_equal.pass.cpp b/libcxx/test/utilities/optional/optional.relops/not_equal.pass.cpp
new file mode 100644
index 00000000000..f386c7e361e
--- /dev/null
+++ b/libcxx/test/utilities/optional/optional.relops/not_equal.pass.cpp
@@ -0,0 +1,79 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <optional>
+
+// template <class T> constexpr bool operator!=(const optional<T>& x, const optional<T>& y);
+
+#include <experimental/optional>
+#include <type_traits>
+#include <cassert>
+
+#if _LIBCPP_STD_VER > 11
+
+using std::experimental::optional;
+
+struct X
+{
+    int i_;
+
+    constexpr X(int i) : i_(i) {}
+};
+
+constexpr bool operator == ( const X &lhs, const X &rhs )
+    { return lhs.i_ == rhs.i_ ; }
+    
+#endif
+
+int main()
+{
+#if _LIBCPP_STD_VER > 11
+    {
+    typedef X T;
+    typedef optional<T> O;
+    
+    constexpr O o1;     // disengaged
+    constexpr O o2;     // disengaged
+    constexpr O o3{1};  // engaged
+    constexpr O o4{2};  // engaged
+    constexpr O o5{1};  // engaged
+
+    static_assert ( !(o1 != o1), "" );
+    static_assert ( !(o1 != o2), "" );
+    static_assert (  (o1 != o3), "" );
+    static_assert (  (o1 != o4), "" );
+    static_assert (  (o1 != o5), "" );
+
+    static_assert ( !(o2 != o1), "" );
+    static_assert ( !(o2 != o2), "" );
+    static_assert (  (o2 != o3), "" );
+    static_assert (  (o2 != o4), "" );
+    static_assert (  (o2 != o5), "" );
+
+    static_assert (  (o3 != o1), "" );
+    static_assert (  (o3 != o2), "" );
+    static_assert ( !(o3 != o3), "" );
+    static_assert (  (o3 != o4), "" );
+    static_assert ( !(o3 != o5), "" );
+
+    static_assert (  (o4 != o1), "" );
+    static_assert (  (o4 != o2), "" );
+    static_assert (  (o4 != o3), "" );
+    static_assert ( !(o4 != o4), "" );
+    static_assert (  (o4 != o5), "" );
+
+    static_assert (  (o5 != o1), "" );
+    static_assert (  (o5 != o2), "" );
+    static_assert ( !(o5 != o3), "" );
+    static_assert (  (o5 != o4), "" );
+    static_assert ( !(o5 != o5), "" );
+
+    }
+#endif
+}