Revert Add <optional>. Will recommit with better commit message

llvm-svn: 283978

1 files changed, 0 insertions, 261 deletions

diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.assign/assign_value.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.assign/assign_value.pass.cpp
deleted file mode 100644
index 6abdd0db63c..00000000000
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.assign/assign_value.pass.cpp
+++ /dev/null
@@ -1,261 +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.
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++98, c++03, c++11, c++14
-// <optional>
-
-// template <class U> optional<T>& operator=(U&& v);
-
-#include <optional>
-#include <type_traits>
-#include <cassert>
-#include <memory>
-
-#include "test_macros.h"
-#include "archetypes.hpp"
-
-using std::optional;
-
-struct ThrowAssign {
-  static int dtor_called;
-  ThrowAssign() = default;
-  ThrowAssign(int) { TEST_THROW(42); }
-  ThrowAssign& operator=(int) {
-      TEST_THROW(42);
-  }
-  ~ThrowAssign() { ++dtor_called; }
-};
-int ThrowAssign::dtor_called = 0;
-
-template <class T, class Arg = T, bool Expect = true>
-void assert_assignable() {
-    static_assert(std::is_assignable<optional<T>&, Arg>::value == Expect, "");
-    static_assert(!std::is_assignable<const optional<T>&, Arg>::value, "");
-}
-
-struct MismatchType {
-  explicit MismatchType(int) {}
-  explicit MismatchType(char*) {}
-  explicit MismatchType(int*) = delete;
-  MismatchType& operator=(int) { return *this; }
-  MismatchType& operator=(int*) { return *this; }
-  MismatchType& operator=(char*) = delete;
-};
-
-void test_sfinae() {
-    using I = TestTypes::TestType;
-    using E = ExplicitTestTypes::TestType;
-    assert_assignable<int>();
-    assert_assignable<int, int&>();
-    assert_assignable<int, int const&>();
-    // Implicit test type
-    assert_assignable<I, I const&>();
-    assert_assignable<I, I&&>();
-    assert_assignable<I, int>();
-    assert_assignable<I, void*, false>();
-    // Explicit test type
-    assert_assignable<E, E const&>();
-    assert_assignable<E, E &&>();
-    assert_assignable<E, int>();
-    assert_assignable<E, void*, false>();
-    // Mismatch type
-    assert_assignable<MismatchType, int>();
-    assert_assignable<MismatchType, int*, false>();
-    assert_assignable<MismatchType, char*, false>();
-}
-
-void test_with_test_type()
-{
-    using T = TestTypes::TestType;
-    T::reset();
-    { // to empty
-        optional<T> opt;
-        opt = 3;
-        assert(T::alive == 1);
-        assert(T::constructed == 1);
-        assert(T::value_constructed == 1);
-        assert(T::assigned == 0);
-        assert(T::destroyed == 0);
-        assert(static_cast<bool>(opt) == true);
-        assert(*opt == T(3));
-    }
-    { // to existing
-        optional<T> opt(42);
-        T::reset_constructors();
-        opt = 3;
-        assert(T::alive == 1);
-        assert(T::constructed == 0);
-        assert(T::assigned == 1);
-        assert(T::value_assigned == 1);
-        assert(T::destroyed == 0);
-        assert(static_cast<bool>(opt) == true);
-        assert(*opt == T(3));
-    }
-    { // test default argument
-        optional<T> opt;
-        T::reset_constructors();
-        opt = {1, 2};
-        assert(T::alive == 1);
-        assert(T::constructed == 2);
-        assert(T::value_constructed == 1);
-        assert(T::move_constructed == 1);
-        assert(T::assigned == 0);
-        assert(T::destroyed == 1);
-        assert(static_cast<bool>(opt) == true);
-        assert(*opt == T(1, 2));
-    }
-    { // test default argument
-        optional<T> opt(42);
-        T::reset_constructors();
-        opt = {1, 2};
-        assert(T::alive == 1);
-        assert(T::constructed == 1);
-        assert(T::value_constructed == 1);
-        assert(T::assigned == 1);
-        assert(T::move_assigned == 1);
-        assert(T::destroyed == 1);
-        assert(static_cast<bool>(opt) == true);
-        assert(*opt == T(1, 2));
-    }
-    { // test default argument
-        optional<T> opt;
-        T::reset_constructors();
-        opt = {1};
-        assert(T::alive == 1);
-        assert(T::constructed == 2);
-        assert(T::value_constructed == 1);
-        assert(T::move_constructed == 1);
-        assert(T::assigned == 0);
-        assert(T::destroyed == 1);
-        assert(static_cast<bool>(opt) == true);
-        assert(*opt == T(1));
-    }
-    { // test default argument
-        optional<T> opt(42);
-        T::reset_constructors();
-        opt = {};
-        assert(static_cast<bool>(opt) == false);
-        assert(T::alive == 0);
-        assert(T::constructed == 0);
-        assert(T::assigned == 0);
-        assert(T::destroyed == 1);
-    }
-}
-
-template <class T, class Value = int>
-void test_with_type() {
-    { // to empty
-        optional<T> opt;
-        opt = Value(3);
-        assert(static_cast<bool>(opt) == true);
-        assert(*opt == T(3));
-    }
-    { // to existing
-        optional<T> opt(Value(42));
-        opt = Value(3);
-        assert(static_cast<bool>(opt) == true);
-        assert(*opt == T(3));
-    }
-    { // test const
-        optional<T> opt(Value(42));
-        const T t(Value(3));
-        opt = t;
-        assert(static_cast<bool>(opt) == true);
-        assert(*opt == T(3));
-    }
-    { // test default argument
-        optional<T> opt;
-        opt = {Value(1)};
-        assert(static_cast<bool>(opt) == true);
-        assert(*opt == T(1));
-    }
-    { // test default argument
-        optional<T> opt(Value(42));
-        opt = {};
-        assert(static_cast<bool>(opt) == false);
-    }
-}
-
-template <class T>
-void test_with_type_multi() {
-    test_with_type<T>();
-    { // test default argument
-        optional<T> opt;
-        opt = {1, 2};
-        assert(static_cast<bool>(opt) == true);
-        assert(*opt == T(1, 2));
-    }
-    { // test default argument
-        optional<T> opt(42);
-        opt = {1, 2};
-        assert(static_cast<bool>(opt) == true);
-        assert(*opt == T(1, 2));
-    }
-}
-
-void test_throws()
-{
-#ifndef TEST_HAS_NO_EXCEPTIONS
-    using T = ThrowAssign;
-    {
-        using T = ThrowAssign;
-        optional<T> opt;
-        try {
-            opt = 42;
-            assert(false);
-        } catch (int) {}
-        assert(static_cast<bool>(opt) == false);
-    }
-    assert(T::dtor_called == 0);
-    {
-        T::dtor_called = 0;
-        optional<T> opt(std::in_place);
-        try {
-            opt = 42;
-            assert(false);
-        } catch (int) {}
-        assert(static_cast<bool>(opt) == true);
-        assert(T::dtor_called == 0);
-    }
-    assert(T::dtor_called == 1);
-#endif
-}
-
-enum MyEnum { Zero, One, Two, Three, FortyTwo = 42 };
-
-using Fn = void(*)();
-
-int main()
-{
-    test_sfinae();
-    // Test with instrumented type
-    test_with_test_type();
-    // Test with various scalar types
-    test_with_type<int>();
-    test_with_type<MyEnum, MyEnum>();
-    test_with_type<int, MyEnum>();
-    test_with_type<Fn, Fn>();
-    // Test types with multi argument constructors
-    test_with_type_multi<ConstexprTestTypes::TestType>();
-    test_with_type_multi<TrivialTestTypes::TestType>();
-    // Test move only types
-    {
-        optional<std::unique_ptr<int>> opt;
-        opt = std::unique_ptr<int>(new int(3));
-        assert(static_cast<bool>(opt) == true);
-        assert(**opt == 3);
-    }
-    {
-        optional<std::unique_ptr<int>> opt(std::unique_ptr<int>(new int(2)));
-        opt = std::unique_ptr<int>(new int(3));
-        assert(static_cast<bool>(opt) == true);
-        assert(**opt == 3);
-    }
-    test_throws();
-}