diff options
Diffstat (limited to 'libcxx/test')
61 files changed, 3788 insertions, 0 deletions
diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/__has_operator_addressof.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/__has_operator_addressof.pass.cpp new file mode 100644 index 00000000000..de27b982022 --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/__has_operator_addressof.pass.cpp @@ -0,0 +1,53 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// extension + +// template <typename _Tp> struct __has_operator_addressof + + +#include <type_traits> + +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + +struct A +{ +}; + +struct B +{ + constexpr B* operator&() const; +}; + +struct D; + +struct C +{ + template <class U> + D operator,(U&&); +}; + +struct E +{ + constexpr C operator&() const; +}; + +#endif // _LIBCPP_HAS_NO_CONSTEXPR + +int main() +{ +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + static_assert(std::__has_operator_addressof<int>::value == false, ""); + static_assert(std::__has_operator_addressof<A>::value == false, ""); + static_assert(std::__has_operator_addressof<B>::value == true, ""); + static_assert(std::__has_operator_addressof<E>::value == true, ""); +#endif // _LIBCPP_HAS_NO_CONSTEXPR +} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp index 8c21c759fa1..e4af6de1c83 100644 --- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp @@ -34,6 +34,19 @@ void test_is_not_assignable() static_assert((!std::is_assignable<T, U>::value), ""); } +struct D; + +struct C +{ + template <class U> + D operator,(U&&); +}; + +struct E +{ + C operator=(int); +}; + int main() { test_is_assignable<int&, int&> (); @@ -41,6 +54,7 @@ int main() test_is_assignable<int&, double> (); test_is_assignable<B, A> (); test_is_assignable<void*&, void*> (); + test_is_assignable<E, int> (); #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES test_is_not_assignable<int, int&> (); 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 new file mode 100644 index 00000000000..f321da6c4c3 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.bad_optional_access/char_pointer.pass.cpp @@ -0,0 +1,31 @@ +//===----------------------------------------------------------------------===// +// +// 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 <optional> +#include <string> +#include <cstring> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + const char* s = "message"; + std::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 new file mode 100644 index 00000000000..353bbe438f8 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.bad_optional_access/copy_assign.pass.cpp @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// 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 <optional> +#include <string> +#include <cstring> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + static_assert(std::is_nothrow_copy_assignable<std::bad_optional_access>::value, ""); + const std::string s1("one message"); + const std::string s2("another message"); + std::bad_optional_access e1(s1); + std::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 new file mode 100644 index 00000000000..cab8aed4f51 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.bad_optional_access/copy_ctor.pass.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// 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 <optional> +#include <string> +#include <cstring> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + static_assert(std::is_nothrow_copy_constructible<std::bad_optional_access>::value, ""); + const std::string s("another message"); + std::bad_optional_access e1(s); + std::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 new file mode 100644 index 00000000000..96ff10449a3 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.bad_optional_access/default.pass.cpp @@ -0,0 +1,26 @@ +//===----------------------------------------------------------------------===// +// +// 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 is not default constructible + +#include <optional> +#include <type_traits> + +#if _LIBCPP_STD_VER > 11 + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + static_assert(!std::is_default_constructible<std::bad_optional_access>::value, ""); +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.bad_optional_access/derive.pass.cpp b/libcxx/test/utilities/optional/optional.bad_optional_access/derive.pass.cpp new file mode 100644 index 00000000000..87d5cb640b9 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.bad_optional_access/derive.pass.cpp @@ -0,0 +1,27 @@ +//===----------------------------------------------------------------------===// +// +// 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 : public logic_error + +#include <optional> +#include <type_traits> + +#if _LIBCPP_STD_VER > 11 + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + static_assert(std::is_base_of<std::logic_error, std::bad_optional_access>::value, ""); + static_assert(std::is_convertible<std::bad_optional_access*, std::logic_error*>::value, ""); +#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 new file mode 100644 index 00000000000..8658906498c --- /dev/null +++ b/libcxx/test/utilities/optional/optional.bad_optional_access/string.pass.cpp @@ -0,0 +1,31 @@ +//===----------------------------------------------------------------------===// +// +// 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 <optional> +#include <string> +#include <cstring> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + const std::string s("message"); + std::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 new file mode 100644 index 00000000000..b1865fafe74 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.comp_with_t/equal.pass.cpp @@ -0,0 +1,42 @@ +//===----------------------------------------------------------------------===// +// +// 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 <optional> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + typedef int T; + typedef std::optional<T> O; + + constexpr T val(2); + constexpr O o1; // disengaged + constexpr O o2{1}; // engaged + constexpr O o3{val}; // engaged + + static_assert ( !(o1 == 1), "" ); + static_assert ( o2 == 1, "" ); + static_assert ( !(o3 == 1), "" ); + static_assert ( o3 == 2 , "" ); + static_assert ( o3 == val, "" ); + + static_assert ( !(1 == o1), "" ); + static_assert ( 1 == o2, "" ); + static_assert ( !(1 == o3), "" ); + static_assert ( 2 == o3 , "" ); + static_assert ( val == 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 new file mode 100644 index 00000000000..ffc4441cee3 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.comp_with_t/less_than.pass.cpp @@ -0,0 +1,72 @@ +//===----------------------------------------------------------------------===// +// +// 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 <optional> + +#if _LIBCPP_STD_VER > 11 + +struct X +{ + int i_; + + constexpr X(int i) : i_(i) {} +}; + +namespace std +{ + +template <> +struct less<X> +{ + constexpr + bool + operator()(const X& x, const X& y) const + { + return x.i_ < y.i_; + } +}; + +} + +#endif + +int main() +{ +#if _LIBCPP_STD_VER > 11 + + { + typedef X T; + typedef std::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 ( o2 < T(2) , "" ); + static_assert ( o2 < T(val), "" ); + 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(3) < o3), "" ); + } +#endif +} diff --git a/libcxx/test/utilities/optional/optional.defs/tested_elsewhere.pass.cpp b/libcxx/test/utilities/optional/optional.defs/tested_elsewhere.pass.cpp new file mode 100644 index 00000000000..b58f5c55b64 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.defs/tested_elsewhere.pass.cpp @@ -0,0 +1,12 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +int main() +{ +} diff --git a/libcxx/test/utilities/optional/optional.general/nothing_to_do.pass.cpp b/libcxx/test/utilities/optional/optional.general/nothing_to_do.pass.cpp new file mode 100644 index 00000000000..b58f5c55b64 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.general/nothing_to_do.pass.cpp @@ -0,0 +1,12 @@ +//===----------------------------------------------------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +int main() +{ +} diff --git a/libcxx/test/utilities/optional/optional.hash/hash.pass.cpp b/libcxx/test/utilities/optional/optional.hash/hash.pass.cpp new file mode 100644 index 00000000000..406632ae1fc --- /dev/null +++ b/libcxx/test/utilities/optional/optional.hash/hash.pass.cpp @@ -0,0 +1,48 @@ +//===----------------------------------------------------------------------===// +// +// 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> struct hash<optional<T>>; + +#include <optional> +#include <string> +#include <memory> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + typedef int T; + std::optional<T> opt; + assert(std::hash<std::optional<T>>{}(opt) == 0); + opt = 2; + assert(std::hash<std::optional<T>>{}(opt) == std::hash<T>{}(*opt)); + } + { + typedef std::string T; + std::optional<T> opt; + assert(std::hash<std::optional<T>>{}(opt) == 0); + opt = std::string("123"); + assert(std::hash<std::optional<T>>{}(opt) == std::hash<T>{}(*opt)); + } + { + typedef std::unique_ptr<int> T; + std::optional<T> opt; + assert(std::hash<std::optional<T>>{}(opt) == 0); + opt = std::unique_ptr<int>(new int(3)); + assert(std::hash<std::optional<T>>{}(opt) == std::hash<T>{}(*opt)); + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.inplace/in_place_t.pass.cpp b/libcxx/test/utilities/optional/optional.inplace/in_place_t.pass.cpp new file mode 100644 index 00000000000..ef9ee49b8ad --- /dev/null +++ b/libcxx/test/utilities/optional/optional.inplace/in_place_t.pass.cpp @@ -0,0 +1,38 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// struct in_place_t{}; +// constexpr in_place_t in_place{}; + +#include <optional> +#include <type_traits> + +#if _LIBCPP_STD_VER > 11 + +constexpr +int +test(const std::in_place_t&) +{ + return 3; +} + +#endif + +int main() +{ +#if _LIBCPP_STD_VER > 11 + + static_assert((std::is_class<std::in_place_t>::value), ""); + static_assert((std::is_empty<std::in_place_t>::value), ""); + + static_assert(test(std::in_place) == 3, ""); +#endif +} diff --git a/libcxx/test/utilities/optional/optional.nullops/eqaul.pass.cpp b/libcxx/test/utilities/optional/optional.nullops/eqaul.pass.cpp new file mode 100644 index 00000000000..bfc8e16e36a --- /dev/null +++ b/libcxx/test/utilities/optional/optional.nullops/eqaul.pass.cpp @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// 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 <optional> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + typedef int T; + typedef std::optional<T> O; + + constexpr O o1; // disengaged + constexpr O o2{1}; // engaged + + static_assert ( std::nullopt == o1 , "" ); + static_assert ( !(std::nullopt == o2), "" ); + static_assert ( o1 == std::nullopt , "" ); + static_assert ( !(o2 == std::nullopt), "" ); + + static_assert (noexcept(std::nullopt == o1), ""); + static_assert (noexcept(o1 == std::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 new file mode 100644 index 00000000000..ea297ca7e7d --- /dev/null +++ b/libcxx/test/utilities/optional/optional.nullops/less_than.pass.cpp @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// 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 <optional> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + typedef int T; + typedef std::optional<T> O; + + constexpr O o1; // disengaged + constexpr O o2{1}; // engaged + + static_assert ( !(std::nullopt < o1), "" ); + static_assert ( std::nullopt < o2 , "" ); + static_assert ( !(o1 < std::nullopt), "" ); + static_assert ( !(o2 < std::nullopt), "" ); + + static_assert (noexcept(std::nullopt < o1), ""); + static_assert (noexcept(o1 < std::nullopt), ""); + } +#endif +} diff --git a/libcxx/test/utilities/optional/optional.nullopt/nullopt_t.pass.cpp b/libcxx/test/utilities/optional/optional.nullopt/nullopt_t.pass.cpp new file mode 100644 index 00000000000..22bf34b7caa --- /dev/null +++ b/libcxx/test/utilities/optional/optional.nullopt/nullopt_t.pass.cpp @@ -0,0 +1,39 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// struct nullopt_t{see below}; +// constexpr nullopt_t nullopt(unspecified); + +#include <optional> +#include <type_traits> + +#if _LIBCPP_STD_VER > 11 + +constexpr +int +test(const std::nullopt_t&) +{ + return 3; +} + +#endif + +int main() +{ +#if _LIBCPP_STD_VER > 11 + static_assert((std::is_class<std::nullopt_t>::value), ""); + static_assert((std::is_empty<std::nullopt_t>::value), ""); + static_assert((std::is_literal_type<std::nullopt_t>::value), ""); + static_assert((!std::is_default_constructible<std::nullopt_t>::value), ""); + + static_assert(test(std::nullopt) == 3, ""); +#endif +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.assign/assign_value.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.assign/assign_value.pass.cpp new file mode 100644 index 00000000000..ee3b1544400 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.assign/assign_value.pass.cpp @@ -0,0 +1,70 @@ +//===----------------------------------------------------------------------===// +// +// 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 U> optional<T>& operator=(U&& v); + +#include <optional> +#include <type_traits> +#include <cassert> +#include <memory> + +#if _LIBCPP_STD_VER > 11 + +struct X +{ +}; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + static_assert(std::is_assignable<std::optional<int>, int>::value, ""); + static_assert(std::is_assignable<std::optional<int>, int&>::value, ""); + static_assert(std::is_assignable<std::optional<int>&, int>::value, ""); + static_assert(std::is_assignable<std::optional<int>&, int&>::value, ""); + static_assert(std::is_assignable<std::optional<int>&, const int&>::value, ""); + static_assert(!std::is_assignable<const std::optional<int>&, const int&>::value, ""); + static_assert(!std::is_assignable<std::optional<int>, X>::value, ""); + { + std::optional<int> opt; + opt = 1; + assert(static_cast<bool>(opt) == true); + assert(*opt == 1); + } + { + std::optional<int> opt; + const int i = 2; + opt = i; + assert(static_cast<bool>(opt) == true); + assert(*opt == i); + } + { + std::optional<int> opt(3); + const int i = 2; + opt = i; + assert(static_cast<bool>(opt) == true); + assert(*opt == i); + } + { + std::optional<std::unique_ptr<int>> opt; + opt = std::unique_ptr<int>(new int(3)); + assert(static_cast<bool>(opt) == true); + assert(**opt == 3); + } + { + std::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); + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp new file mode 100644 index 00000000000..f6d365ae1de --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.assign/copy.pass.cpp @@ -0,0 +1,88 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// optional<T>& operator=(const optional<T>& rhs); + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +struct X +{ + static bool throw_now; + + X() = default; + X(const X&) + { + if (throw_now) + throw 6; + } +}; + +bool X::throw_now = false; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + std::optional<int> opt; + constexpr std::optional<int> opt2; + opt = opt2; + static_assert(static_cast<bool>(opt2) == false, ""); + assert(static_cast<bool>(opt) == static_cast<bool>(opt2)); + } + { + std::optional<int> opt; + constexpr std::optional<int> opt2(2); + opt = opt2; + static_assert(static_cast<bool>(opt2) == true, ""); + static_assert(*opt2 == 2, ""); + assert(static_cast<bool>(opt) == static_cast<bool>(opt2)); + assert(*opt == *opt2); + } + { + std::optional<int> opt(3); + constexpr std::optional<int> opt2; + opt = opt2; + static_assert(static_cast<bool>(opt2) == false, ""); + assert(static_cast<bool>(opt) == static_cast<bool>(opt2)); + } + { + std::optional<int> opt(3); + constexpr std::optional<int> opt2(2); + opt = opt2; + static_assert(static_cast<bool>(opt2) == true, ""); + static_assert(*opt2 == 2, ""); + assert(static_cast<bool>(opt) == static_cast<bool>(opt2)); + assert(*opt == *opt2); + } + { + std::optional<X> opt; + std::optional<X> opt2(X{}); + assert(static_cast<bool>(opt2) == true); + try + { + X::throw_now = true; + opt = opt2; + assert(false); + } + catch (int i) + { + assert(i == 6); + assert(static_cast<bool>(opt) == false); + } + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.assign/emplace.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.assign/emplace.pass.cpp new file mode 100644 index 00000000000..e43e8800639 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.assign/emplace.pass.cpp @@ -0,0 +1,146 @@ +//===----------------------------------------------------------------------===// +// +// 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... Args> void optional<T>::emplace(Args&&... args); + +#include <optional> +#include <type_traits> +#include <cassert> +#include <memory> + +#if _LIBCPP_STD_VER > 11 + +class X +{ + int i_; + int j_ = 0; +public: + X() : i_(0) {} + X(int i) : i_(i) {} + X(int i, int j) : i_(i), j_(j) {} + + friend bool operator==(const X& x, const X& y) + {return x.i_ == y.i_ && x.j_ == y.j_;} +}; + +class Y +{ +public: + static bool dtor_called; + Y() = default; + ~Y() {dtor_called = true;} +}; + +bool Y::dtor_called = false; + +class Z +{ +public: + static bool dtor_called; + Z() = default; + Z(int) {throw 6;} + ~Z() {dtor_called = true;} +}; + +bool Z::dtor_called = false; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + std::optional<int> opt; + opt.emplace(); + assert(static_cast<bool>(opt) == true); + assert(*opt == 0); + } + { + std::optional<int> opt; + opt.emplace(1); + assert(static_cast<bool>(opt) == true); + assert(*opt == 1); + } + { + std::optional<int> opt(2); + opt.emplace(); + assert(static_cast<bool>(opt) == true); + assert(*opt == 0); + } + { + std::optional<int> opt(2); + opt.emplace(1); + assert(static_cast<bool>(opt) == true); + assert(*opt == 1); + } + { + std::optional<X> opt; + opt.emplace(); + assert(static_cast<bool>(opt) == true); + assert(*opt == X()); + } + { + std::optional<X> opt; + opt.emplace(1); + assert(static_cast<bool>(opt) == true); + assert(*opt == X(1)); + } + { + std::optional<X> opt; + opt.emplace(1, 2); + assert(static_cast<bool>(opt) == true); + assert(*opt == X(1, 2)); + } + { + std::optional<X> opt(X{3}); + opt.emplace(); + assert(static_cast<bool>(opt) == true); + assert(*opt == X()); + } + { + std::optional<X> opt(X{3}); + opt.emplace(1); + assert(static_cast<bool>(opt) == true); + assert(*opt == X(1)); + } + { + std::optional<X> opt(X{3}); + opt.emplace(1, 2); + assert(static_cast<bool>(opt) == true); + assert(*opt == X(1, 2)); + } + { + Y y; + { + std::optional<Y> opt(y); + assert(Y::dtor_called == false); + opt.emplace(); + assert(Y::dtor_called == true); + } + } + { + Z z; + std::optional<Z> opt(z); + try + { + assert(static_cast<bool>(opt) == true); + assert(Z::dtor_called == false); + opt.emplace(1); + } + catch (int i) + { + assert(i == 6); + assert(static_cast<bool>(opt) == false); + assert(Z::dtor_called == true); + } + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp new file mode 100644 index 00000000000..db4fb4959cf --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp @@ -0,0 +1,114 @@ +//===----------------------------------------------------------------------===// +// +// 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 U, class... Args> +// void optional<T>::emplace(initializer_list<U> il, Args&&... args); + +#include <optional> +#include <type_traits> +#include <cassert> +#include <vector> + +#if _LIBCPP_STD_VER > 11 + +class X +{ + int i_; + int j_ = 0; +public: + static bool dtor_called; + constexpr X() : i_(0) {} + constexpr X(int i) : i_(i) {} + constexpr X(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1]) {} + ~X() {dtor_called = true;} + + friend constexpr bool operator==(const X& x, const X& y) + {return x.i_ == y.i_ && x.j_ == y.j_;} +}; + +bool X::dtor_called = false; + +class Y +{ + int i_; + int j_ = 0; +public: + constexpr Y() : i_(0) {} + constexpr Y(int i) : i_(i) {} + constexpr Y(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1]) {} + + friend constexpr bool operator==(const Y& x, const Y& y) + {return x.i_ == y.i_ && x.j_ == y.j_;} +}; + +class Z +{ + int i_; + int j_ = 0; +public: + static bool dtor_called; + constexpr Z() : i_(0) {} + constexpr Z(int i) : i_(i) {} + constexpr Z(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1]) + {throw 6;} + ~Z() {dtor_called = true;} + + friend constexpr bool operator==(const Z& x, const Z& y) + {return x.i_ == y.i_ && x.j_ == y.j_;} +}; + +bool Z::dtor_called = false; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + X x; + { + std::optional<X> opt(x); + assert(X::dtor_called == false); + opt.emplace({1, 2}); + assert(X::dtor_called == true); + assert(*opt == X({1, 2})); + } + } + { + std::optional<std::vector<int>> opt; + opt.emplace({1, 2, 3}, std::allocator<int>()); + assert(static_cast<bool>(opt) == true); + assert(*opt == std::vector<int>({1, 2, 3})); + } + { + std::optional<Y> opt; + opt.emplace({1, 2}); + assert(static_cast<bool>(opt) == true); + assert(*opt == Y({1, 2})); + } + { + Z z; + std::optional<Z> opt(z); + try + { + assert(static_cast<bool>(opt) == true); + assert(Z::dtor_called == false); + opt.emplace({1, 2}); + } + catch (int i) + { + assert(i == 6); + assert(static_cast<bool>(opt) == false); + assert(Z::dtor_called == true); + } + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.assign/move.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.assign/move.pass.cpp new file mode 100644 index 00000000000..a1574d6bb62 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.assign/move.pass.cpp @@ -0,0 +1,101 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// optional<T>& operator=(optional<T>&& rhs) +// noexcept(is_nothrow_move_assignable<T>::value && +// is_nothrow_move_constructible<T>::value); + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +struct X +{ + static bool throw_now; + + X() = default; + X(X&&) + { + if (throw_now) + throw 6; + } + X& operator=(X&&) noexcept + { + return *this; + } +}; + +struct Y {}; + +bool X::throw_now = false; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + static_assert(std::is_nothrow_move_assignable<std::optional<int>>::value, ""); + std::optional<int> opt; + constexpr std::optional<int> opt2; + opt = std::move(opt2); + static_assert(static_cast<bool>(opt2) == false, ""); + assert(static_cast<bool>(opt) == static_cast<bool>(opt2)); + } + { + std::optional<int> opt; + constexpr std::optional<int> opt2(2); + opt = std::move(opt2); + static_assert(static_cast<bool>(opt2) == true, ""); + static_assert(*opt2 == 2, ""); + assert(static_cast<bool>(opt) == static_cast<bool>(opt2)); + assert(*opt == *opt2); + } + { + std::optional<int> opt(3); + constexpr std::optional<int> opt2; + opt = std::move(opt2); + static_assert(static_cast<bool>(opt2) == false, ""); + assert(static_cast<bool>(opt) == static_cast<bool>(opt2)); + } + { + std::optional<int> opt(3); + constexpr std::optional<int> opt2(2); + opt = std::move(opt2); + static_assert(static_cast<bool>(opt2) == true, ""); + static_assert(*opt2 == 2, ""); + assert(static_cast<bool>(opt) == static_cast<bool>(opt2)); + assert(*opt == *opt2); + } + { + static_assert(!std::is_nothrow_move_assignable<std::optional<X>>::value, ""); + std::optional<X> opt; + std::optional<X> opt2(X{}); + assert(static_cast<bool>(opt2) == true); + try + { + X::throw_now = true; + opt = std::move(opt2); + assert(false); + } + catch (int i) + { + assert(i == 6); + assert(static_cast<bool>(opt) == false); + } + } + { + static_assert(std::is_nothrow_move_assignable<std::optional<Y>>::value, ""); + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp new file mode 100644 index 00000000000..2c87fe9b1ec --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.assign/nullopt_t.pass.cpp @@ -0,0 +1,63 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// optional<T>& operator=(nullopt_t) noexcept; + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +struct X +{ + static bool dtor_called; + ~X() {dtor_called = true;} +}; + +bool X::dtor_called = false; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + std::optional<int> opt; + static_assert(noexcept(opt = std::nullopt) == true, ""); + opt = std::nullopt; + assert(static_cast<bool>(opt) == false); + } + { + std::optional<int> opt(3); + opt = std::nullopt; + assert(static_cast<bool>(opt) == false); + } + { + std::optional<X> opt; + static_assert(noexcept(opt = std::nullopt) == true, ""); + assert(X::dtor_called == false); + opt = std::nullopt; + assert(X::dtor_called == false); + assert(static_cast<bool>(opt) == false); + } + { + X x; + { + std::optional<X> opt(x); + assert(X::dtor_called == false); + opt = std::nullopt; + assert(X::dtor_called == true); + assert(static_cast<bool>(opt) == false); + } + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp new file mode 100644 index 00000000000..2e69b30580a --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp @@ -0,0 +1,115 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// constexpr optional(const T& v); + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +class X +{ + int i_; +public: + X(int i) : i_(i) {} + + friend bool operator==(const X& x, const X& y) {return x.i_ == y.i_;} +}; + +class Y +{ + int i_; +public: + constexpr Y(int i) : i_(i) {} + + friend constexpr bool operator==(const Y& x, const Y& y) {return x.i_ == y.i_;} +}; + +class Z +{ + int i_; +public: + Z(int i) : i_(i) {} + Z(const Z&) {throw 6;} +}; + + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + typedef int T; + constexpr T t(5); + constexpr std::optional<T> opt(t); + static_assert(static_cast<bool>(opt) == true, ""); + static_assert(*opt == 5, ""); + + struct test_constexpr_ctor + : public std::optional<T> + { + constexpr test_constexpr_ctor(const T&) {} + }; + + } + { + typedef double T; + constexpr T t(3); + constexpr std::optional<T> opt(t); + static_assert(static_cast<bool>(opt) == true, ""); + static_assert(*opt == 3, ""); + + struct test_constexpr_ctor + : public std::optional<T> + { + constexpr test_constexpr_ctor(const T&) {} + }; + + } + { + typedef X T; + const T t(3); + std::optional<T> opt(t); + assert(static_cast<bool>(opt) == true); + assert(*opt == 3); + } + { + typedef Y T; + constexpr T t(3); + constexpr std::optional<T> opt(t); + static_assert(static_cast<bool>(opt) == true, ""); + static_assert(*opt == 3, ""); + + struct test_constexpr_ctor + : public std::optional<T> + { + constexpr test_constexpr_ctor(const T&) {} + }; + + } + { + typedef Z T; + try + { + const T t(3); + std::optional<T> opt(t); + assert(false); + } + catch (int i) + { + assert(i == 6); + } + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp new file mode 100644 index 00000000000..84319ad15ea --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp @@ -0,0 +1,122 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// optional(const optional<T>& rhs); + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +template <class T> +void +test(const std::optional<T>& rhs, bool is_going_to_throw = false) +{ + bool rhs_engaged = static_cast<bool>(rhs); + try + { + std::optional<T> lhs = rhs; + assert(is_going_to_throw == false); + assert(static_cast<bool>(lhs) == rhs_engaged); + if (rhs_engaged) + assert(*lhs == *rhs); + } + catch (int i) + { + assert(i == 6); + } +} + +class X +{ + int i_; +public: + X(int i) : i_(i) {} + X(const X& x) : i_(x.i_) {} + ~X() {i_ = 0;} + friend bool operator==(const X& x, const X& y) {return x.i_ == y.i_;} +}; + +class Y +{ + int i_; +public: + Y(int i) : i_(i) {} + Y(const Y& x) : i_(x.i_) {} + + friend constexpr bool operator==(const Y& x, const Y& y) {return x.i_ == y.i_;} +}; + +int count = 0; + +class Z +{ + int i_; +public: + Z(int i) : i_(i) {} + Z(const Z&) + { + if (++count == 2) + throw 6; + } + + friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;} +}; + + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + typedef int T; + std::optional<T> rhs; + test(rhs); + } + { + typedef int T; + std::optional<T> rhs(3); + test(rhs); + } + { + typedef X T; + std::optional<T> rhs; + test(rhs); + } + { + typedef X T; + std::optional<T> rhs(X(3)); + test(rhs); + } + { + typedef Y T; + std::optional<T> rhs; + test(rhs); + } + { + typedef Y T; + std::optional<T> rhs(Y(3)); + test(rhs); + } + { + typedef Z T; + std::optional<T> rhs; + test(rhs); + } + { + typedef Z T; + std::optional<T> rhs(Z(3)); + test(rhs, true); + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp new file mode 100644 index 00000000000..5f9c5af5a29 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp @@ -0,0 +1,65 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// constexpr optional() noexcept; + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +template <class Opt> +void +test_constexpr() +{ + static_assert(std::is_nothrow_default_constructible<Opt>::value, ""); + constexpr Opt opt; + static_assert(static_cast<bool>(opt) == false, ""); + + struct test_constexpr_ctor + : public Opt + { + constexpr test_constexpr_ctor() {} + }; + +} + +template <class Opt> +void +test() +{ + static_assert(std::is_nothrow_default_constructible<Opt>::value, ""); + Opt opt; + assert(static_cast<bool>(opt) == false); + + struct test_constexpr_ctor + : public Opt + { + constexpr test_constexpr_ctor() {} + }; +} + +struct X +{ + X(); +}; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + test_constexpr<std::optional<int>>(); + test_constexpr<std::optional<int*>>(); + test<std::optional<X>>(); +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp new file mode 100644 index 00000000000..db1b62970b2 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp @@ -0,0 +1,141 @@ +//===----------------------------------------------------------------------===// +// +// 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... Args> +// constexpr explicit optional(in_place_t, Args&&... args); + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +class X +{ + int i_; + int j_ = 0; +public: + X() : i_(0) {} + X(int i) : i_(i) {} + X(int i, int j) : i_(i), j_(j) {} + + ~X() {} + + friend bool operator==(const X& x, const X& y) + {return x.i_ == y.i_ && x.j_ == y.j_;} +}; + +class Y +{ + int i_; + int j_ = 0; +public: + constexpr Y() : i_(0) {} + constexpr Y(int i) : i_(i) {} + constexpr Y(int i, int j) : i_(i), j_(j) {} + + friend constexpr bool operator==(const Y& x, const Y& y) + {return x.i_ == y.i_ && x.j_ == y.j_;} +}; + +class Z +{ + int i_; +public: + Z(int i) : i_(i) {throw 6;} +}; + + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + constexpr std::optional<int> opt(std::in_place, 5); + static_assert(static_cast<bool>(opt) == true, ""); + static_assert(*opt == 5, ""); + + struct test_constexpr_ctor + : public std::optional<int> + { + constexpr test_constexpr_ctor(std::in_place_t, int i) + : std::optional<int>(std::in_place, i) {} + }; + + } + { + const std::optional<X> opt(std::in_place); + assert(static_cast<bool>(opt) == true); + assert(*opt == X()); + } + { + const std::optional<X> opt(std::in_place, 5); + assert(static_cast<bool>(opt) == true); + assert(*opt == X(5)); + } + { + const std::optional<X> opt(std::in_place, 5, 4); + assert(static_cast<bool>(opt) == true); + assert(*opt == X(5, 4)); + } + { + constexpr std::optional<Y> opt(std::in_place); + static_assert(static_cast<bool>(opt) == true, ""); + static_assert(*opt == Y(), ""); + + struct test_constexpr_ctor + : public std::optional<Y> + { + constexpr test_constexpr_ctor(std::in_place_t) + : std::optional<Y>(std::in_place) {} + }; + + } + { + constexpr std::optional<Y> opt(std::in_place, 5); + static_assert(static_cast<bool>(opt) == true, ""); + static_assert(*opt == Y(5), ""); + + struct test_constexpr_ctor + : public std::optional<Y> + { + constexpr test_constexpr_ctor(std::in_place_t, int i) + : std::optional<Y>(std::in_place, i) {} + }; + + } + { + constexpr std::optional<Y> opt(std::in_place, 5, 4); + static_assert(static_cast<bool>(opt) == true, ""); + static_assert(*opt == Y(5, 4), ""); + + struct test_constexpr_ctor + : public std::optional<Y> + { + constexpr test_constexpr_ctor(std::in_place_t, int i, int j) + : std::optional<Y>(std::in_place, i, j) {} + }; + + } + { + try + { + const std::optional<Z> opt(std::in_place, 1); + assert(false); + } + catch (int i) + { + assert(i == 6); + } + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp new file mode 100644 index 00000000000..076554a407d --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp @@ -0,0 +1,122 @@ +//===----------------------------------------------------------------------===// +// +// 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 U, class... Args> +// constexpr +// explicit optional(in_place_t, initializer_list<U> il, Args&&... args); + +#include <optional> +#include <type_traits> +#include <vector> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +class X +{ + int i_; + int j_ = 0; +public: + X() : i_(0) {} + X(int i) : i_(i) {} + X(int i, int j) : i_(i), j_(j) {} + + ~X() {} + + friend bool operator==(const X& x, const X& y) + {return x.i_ == y.i_ && x.j_ == y.j_;} +}; + +class Y +{ + int i_; + int j_ = 0; +public: + constexpr Y() : i_(0) {} + constexpr Y(int i) : i_(i) {} + constexpr Y(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1]) {} + + friend constexpr bool operator==(const Y& x, const Y& y) + {return x.i_ == y.i_ && x.j_ == y.j_;} +}; + +class Z +{ + int i_; + int j_ = 0; +public: + constexpr Z() : i_(0) {} + constexpr Z(int i) : i_(i) {} + constexpr Z(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1]) + {throw 6;} + + friend constexpr bool operator==(const Z& x, const Z& y) + {return x.i_ == y.i_ && x.j_ == y.j_;} +}; + + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + static_assert(!std::is_constructible<X, std::initializer_list<int>&>::value, ""); + static_assert(!std::is_constructible<std::optional<X>, std::initializer_list<int>&>::value, ""); + } + { + std::optional<std::vector<int>> opt(std::in_place, {3, 1}); + assert(static_cast<bool>(opt) == true); + assert((*opt == std::vector<int>{3, 1})); + assert(opt->size() == 2); + } + { + std::optional<std::vector<int>> opt(std::in_place, {3, 1}, std::allocator<int>()); + assert(static_cast<bool>(opt) == true); + assert((*opt == std::vector<int>{3, 1})); + assert(opt->size() == 2); + } + { + static_assert(std::is_constructible<std::optional<Y>, std::initializer_list<int>&>::value, ""); + constexpr std::optional<Y> opt(std::in_place, {3, 1}); + static_assert(static_cast<bool>(opt) == true, ""); + static_assert(*opt == Y{3, 1}, ""); + + struct test_constexpr_ctor + : public std::optional<Y> + { + constexpr test_constexpr_ctor(std::in_place_t, std::initializer_list<int> i) + : std::optional<Y>(std::in_place, i) {} + }; + + } + { + static_assert(std::is_constructible<std::optional<Z>, std::initializer_list<int>&>::value, ""); + try + { + std::optional<Z> opt(std::in_place, {3, 1}); + assert(false); + } + catch (int i) + { + assert(i == 6); + } + + struct test_constexpr_ctor + : public std::optional<Z> + { + constexpr test_constexpr_ctor(std::in_place_t, std::initializer_list<int> i) + : std::optional<Z>(std::in_place, i) {} + }; + + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp new file mode 100644 index 00000000000..70004fd8655 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp @@ -0,0 +1,122 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// optional(optional<T>&& rhs) noexcept(is_nothrow_move_constructible<T>::value); + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +template <class T> +void +test(std::optional<T>& rhs, bool is_going_to_throw = false) +{ + static_assert(std::is_nothrow_move_constructible<std::optional<T>>::value == + std::is_nothrow_move_constructible<T>::value, ""); + bool rhs_engaged = static_cast<bool>(rhs); + try + { + std::optional<T> lhs = std::move(rhs); + assert(is_going_to_throw == false); + assert(static_cast<bool>(lhs) == rhs_engaged); + } + catch (int i) + { + assert(i == 6); + } +} + +class X +{ + int i_; +public: + X(int i) : i_(i) {} + X(X&& x) : i_(x.i_) {x.i_ = 0;} + ~X() {i_ = 0;} + friend bool operator==(const X& x, const X& y) {return x.i_ == y.i_;} +}; + +class Y +{ + int i_; +public: + Y(int i) : i_(i) {} + Y(Y&& x) noexcept : i_(x.i_) {x.i_ = 0;} + + friend constexpr bool operator==(const Y& x, const Y& y) {return x.i_ == y.i_;} +}; + +int count = 0; + +class Z +{ + int i_; +public: + Z(int i) : i_(i) {} + Z(Z&&) + { + if (++count == 2) + throw 6; + } + + friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;} +}; + + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + typedef int T; + std::optional<T> rhs; + test(rhs); + } + { + typedef int T; + std::optional<T> rhs(3); + test(rhs); + } + { + typedef X T; + std::optional<T> rhs; + test(rhs); + } + { + typedef X T; + std::optional<T> rhs(X(3)); + test(rhs); + } + { + typedef Y T; + std::optional<T> rhs; + test(rhs); + } + { + typedef Y T; + std::optional<T> rhs(Y(3)); + test(rhs); + } + { + typedef Z T; + std::optional<T> rhs; + test(rhs); + } + { + typedef Z T; + std::optional<T> rhs(Z(3)); + test(rhs, true); + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp new file mode 100644 index 00000000000..0d0f1e9a216 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp @@ -0,0 +1,64 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// constexpr optional(nullopt_t) noexcept; + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +template <class Opt> +void +test_constexpr() +{ + static_assert(noexcept(Opt(std::nullopt)), ""); + constexpr Opt opt(std::nullopt); + static_assert(static_cast<bool>(opt) == false, ""); + + struct test_constexpr_ctor + : public Opt + { + constexpr test_constexpr_ctor() {} + }; +} + +template <class Opt> +void +test() +{ + static_assert(noexcept(Opt(std::nullopt)), ""); + Opt opt(std::nullopt); + assert(static_cast<bool>(opt) == false); + + struct test_constexpr_ctor + : public Opt + { + constexpr test_constexpr_ctor() {} + }; +} + +struct X +{ + X(); +}; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + test_constexpr<std::optional<int>>(); + test_constexpr<std::optional<int*>>(); + test<std::optional<X>>(); +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp new file mode 100644 index 00000000000..c07dd634398 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp @@ -0,0 +1,108 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// constexpr optional(T&& v); + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +class X +{ + int i_; +public: + X(int i) : i_(i) {} + X(X&& x) : i_(x.i_) {} + + friend bool operator==(const X& x, const X& y) {return x.i_ == y.i_;} +}; + +class Y +{ + int i_; +public: + constexpr Y(int i) : i_(i) {} + constexpr Y(Y&& x) : i_(x.i_) {} + + friend constexpr bool operator==(const Y& x, const Y& y) {return x.i_ == y.i_;} +}; + +class Z +{ + int i_; +public: + Z(int i) : i_(i) {} + Z(Z&&) {throw 6;} +}; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + typedef int T; + constexpr std::optional<T> opt(T(5)); + static_assert(static_cast<bool>(opt) == true, ""); + static_assert(*opt == 5, ""); + + struct test_constexpr_ctor + : public std::optional<T> + { + constexpr test_constexpr_ctor(T&&) {} + }; + } + { + typedef double T; + constexpr std::optional<T> opt(T(3)); + static_assert(static_cast<bool>(opt) == true, ""); + static_assert(*opt == 3, ""); + + struct test_constexpr_ctor + : public std::optional<T> + { + constexpr test_constexpr_ctor(T&&) {} + }; + } + { + typedef X T; + std::optional<T> opt(T(3)); + assert(static_cast<bool>(opt) == true); + assert(*opt == 3); + } + { + typedef Y T; + constexpr std::optional<T> opt(T(3)); + static_assert(static_cast<bool>(opt) == true, ""); + static_assert(*opt == 3, ""); + + struct test_constexpr_ctor + : public std::optional<T> + { + constexpr test_constexpr_ctor(T&&) {} + }; + } + { + typedef Z T; + try + { + std::optional<T> opt(T(3)); + assert(false); + } + catch (int i) + { + assert(i == 6); + } + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp new file mode 100644 index 00000000000..428e6743618 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp @@ -0,0 +1,57 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// ~optional(); + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +class X +{ +public: + static bool dtor_called; + X() = default; + ~X() {dtor_called = true;} +}; + +bool X::dtor_called = false; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + typedef int T; + static_assert(std::is_trivially_destructible<T>::value, ""); + static_assert(std::is_trivially_destructible<std::optional<T>>::value, ""); + } + { + typedef double T; + static_assert(std::is_trivially_destructible<T>::value, ""); + static_assert(std::is_trivially_destructible<std::optional<T>>::value, ""); + } + { + typedef X T; + static_assert(!std::is_trivially_destructible<T>::value, ""); + static_assert(!std::is_trivially_destructible<std::optional<T>>::value, ""); + { + X x; + std::optional<X> opt{x}; + assert(X::dtor_called == false); + } + assert(X::dtor_called == true); + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.observe/bool.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.observe/bool.pass.cpp new file mode 100644 index 00000000000..657af2c5dad --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.observe/bool.pass.cpp @@ -0,0 +1,30 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// constexpr explicit optional<T>::operator bool() const noexcept; + +#include <optional> +#include <type_traits> +#include <cassert> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + constexpr std::optional<int> opt; + static_assert(!opt, ""); + } + { + constexpr std::optional<int> opt(0); + static_assert(opt, ""); + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp new file mode 100644 index 00000000000..5ef4245feb9 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.observe/dereference.pass.cpp @@ -0,0 +1,47 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// T& optional<T>::operator*(); + +#ifdef _LIBCPP_DEBUG +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +struct X +{ + constexpr int test() const {return 3;} + int test() {return 4;} +}; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + std::optional<X> opt(X{}); + assert((*opt).test() == 4); + } +#ifdef _LIBCPP_DEBUG + { + std::optional<X> opt; + assert((*opt).test() == 3); + assert(false); + } +#endif // _LIBCPP_DEBUG +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp new file mode 100644 index 00000000000..6ea5e118857 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.observe/dereference_const.pass.cpp @@ -0,0 +1,55 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// constexpr const T& optional<T>::operator*() const; + +#ifdef _LIBCPP_DEBUG +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +struct X +{ + constexpr int test() const {return 3;} +}; + +struct Y +{ + int test() const {return 2;} +}; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + constexpr std::optional<X> opt(X{}); + static_assert((*opt).test() == 3, ""); + } + { + constexpr std::optional<Y> opt(Y{}); + assert((*opt).test() == 2); + } +#ifdef _LIBCPP_DEBUG + { + const std::optional<X> opt; + assert((*opt).test() == 3); + assert(false); + } +#endif // _LIBCPP_DEBUG +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.observe/op_arrow.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.observe/op_arrow.pass.cpp new file mode 100644 index 00000000000..54c19e716e9 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.observe/op_arrow.pass.cpp @@ -0,0 +1,47 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// T* optional<T>::operator->(); + +#ifdef _LIBCPP_DEBUG +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +struct X +{ + int test() const {return 2;} + int test() {return 3;} +}; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + std::optional<X> opt(X{}); + assert(opt->test() == 3); + } +#ifdef _LIBCPP_DEBUG + { + std::optional<X> opt; + assert(opt->test() == 3); + assert(false); + } +#endif // _LIBCPP_DEBUG +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp new file mode 100644 index 00000000000..94f62e29baa --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp @@ -0,0 +1,65 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// constexpr const T* optional<T>::operator->() const; + +#ifdef _LIBCPP_DEBUG +#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0)) +#endif + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +struct X +{ + constexpr int test() const {return 3;} +}; + +struct Y +{ + int test() const {return 2;} +}; + +struct Z +{ + const Z* operator&() const {return this;} + constexpr int test() const {return 1;} +}; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + constexpr std::optional<X> opt(X{}); + static_assert(opt->test() == 3, ""); + } + { + constexpr std::optional<Y> opt(Y{}); + assert(opt->test() == 2); + } + { + constexpr std::optional<Z> opt(Z{}); + assert(opt->test() == 1); + } +#ifdef _LIBCPP_DEBUG + { + const std::optional<X> opt; + assert(opt->test() == 3); + assert(false); + } +#endif // _LIBCPP_DEBUG +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.observe/value.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.observe/value.pass.cpp new file mode 100644 index 00000000000..245070c6c82 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.observe/value.pass.cpp @@ -0,0 +1,50 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// T& optional<T>::value(); + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +struct X +{ + X() = default; + X(const X&) = delete; + constexpr int test() const {return 3;} + int test() {return 4;} +}; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + std::optional<X> opt; + opt.emplace(); + assert(opt.value().test() == 4); + } + { + std::optional<X> opt; + try + { + opt.value(); + assert(false); + } + catch (const std::bad_optional_access&) + { + } + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.observe/value_const.fail.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.observe/value_const.fail.cpp new file mode 100644 index 00000000000..f22220c3e9d --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.observe/value_const.fail.cpp @@ -0,0 +1,38 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// constexpr const T& optional<T>::value() const; + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +struct X +{ + constexpr int test() const {return 3;} + int test() {return 4;} +}; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + constexpr std::optional<X> opt; + static_assert(opt.value().test() == 3, ""); + } +#else +#error +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp new file mode 100644 index 00000000000..1c6776524b4 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.observe/value_const.pass.cpp @@ -0,0 +1,53 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// constexpr const T& optional<T>::value() const; + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +struct X +{ + X() = default; + X(const X&) = delete; + constexpr int test() const {return 3;} + int test() {return 4;} +}; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + constexpr std::optional<X> opt(std::in_place); + static_assert(opt.value().test() == 3, ""); + } + { + const std::optional<X> opt(std::in_place); + assert(opt.value().test() == 3); + } + { + const std::optional<X> opt; + try + { + opt.value(); + assert(false); + } + catch (const std::bad_optional_access&) + { + } + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.observe/value_or.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.observe/value_or.pass.cpp new file mode 100644 index 00000000000..52a3f5d4dd6 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.observe/value_or.pass.cpp @@ -0,0 +1,67 @@ +//===----------------------------------------------------------------------===// +// +// 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 U> T optional<T>::value_or(U&& v) &&; + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +struct Y +{ + int i_; + + Y(int i) : i_(i) {} +}; + +struct X +{ + int i_; + + X(int i) : i_(i) {} + X(X&& x) : i_(x.i_) {x.i_ = 0;} + X(const Y& y) : i_(y.i_) {} + X(Y&& y) : i_(y.i_+1) {} + friend constexpr bool operator==(const X& x, const X& y) + {return x.i_ == y.i_;} +}; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + std::optional<X> opt(std::in_place, 2); + Y y(3); + assert(std::move(opt).value_or(y) == 2); + assert(*opt == 0); + } + { + std::optional<X> opt(std::in_place, 2); + assert(std::move(opt).value_or(Y(3)) == 2); + assert(*opt == 0); + } + { + std::optional<X> opt; + Y y(3); + assert(std::move(opt).value_or(y) == 3); + assert(!opt); + } + { + std::optional<X> opt; + assert(std::move(opt).value_or(Y(3)) == 4); + assert(!opt); + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.observe/value_or_const.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.observe/value_or_const.pass.cpp new file mode 100644 index 00000000000..e95ab2d25df --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.observe/value_or_const.pass.cpp @@ -0,0 +1,80 @@ +//===----------------------------------------------------------------------===// +// +// 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 U> constexpr T optional<T>::value_or(U&& v) const&; + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +struct Y +{ + int i_; + + constexpr Y(int i) : i_(i) {} +}; + +struct X +{ + int i_; + + constexpr X(int i) : i_(i) {} + constexpr X(const Y& y) : i_(y.i_) {} + constexpr X(Y&& y) : i_(y.i_+1) {} + friend constexpr bool operator==(const X& x, const X& y) + {return x.i_ == y.i_;} +}; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + constexpr std::optional<X> opt(2); + constexpr Y y(3); + static_assert(opt.value_or(y) == 2, ""); + } + { + constexpr std::optional<X> opt(2); + static_assert(opt.value_or(Y(3)) == 2, ""); + } + { + constexpr std::optional<X> opt; + constexpr Y y(3); + static_assert(opt.value_or(y) == 3, ""); + } + { + constexpr std::optional<X> opt; + static_assert(opt.value_or(Y(3)) == 4, ""); + } + { + const std::optional<X> opt(2); + const Y y(3); + assert(opt.value_or(y) == 2); + } + { + const std::optional<X> opt(2); + assert(opt.value_or(Y(3)) == 2); + } + { + const std::optional<X> opt; + const Y y(3); + assert(opt.value_or(y) == 3); + } + { + const std::optional<X> opt; + assert(opt.value_or(Y(3)) == 4); + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional.object.swap/swap.pass.cpp b/libcxx/test/utilities/optional/optional.object/optional.object.swap/swap.pass.cpp new file mode 100644 index 00000000000..5672332bb51 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional.object.swap/swap.pass.cpp @@ -0,0 +1,304 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// void swap(optional&) +// noexcept(is_nothrow_move_constructible<T>::value && +// noexcept(swap(declval<T&>(), declval<T&>()))); + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +class X +{ + int i_; +public: + static unsigned dtor_called; + X(int i) : i_(i) {} + X(X&& x) = default; + X& operator=(X&&) = default; + ~X() {++dtor_called;} + + friend bool operator==(const X& x, const X& y) {return x.i_ == y.i_;} +}; + +unsigned X::dtor_called = 0; + +class Y +{ + int i_; +public: + static unsigned dtor_called; + Y(int i) : i_(i) {} + Y(Y&&) = default; + ~Y() {++dtor_called;} + + friend constexpr bool operator==(const Y& x, const Y& y) {return x.i_ == y.i_;} + friend void swap(Y& x, Y& y) {std::swap(x.i_, y.i_);} +}; + +unsigned Y::dtor_called = 0; + +class Z +{ + int i_; +public: + Z(int i) : i_(i) {} + Z(Z&&) {throw 7;} + + friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;} + friend void swap(Z& x, Z& y) {throw 6;} +}; + + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + std::optional<int> opt1; + std::optional<int> opt2; + static_assert(noexcept(opt1.swap(opt2)) == true, ""); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == false); + opt1.swap(opt2); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == false); + } + { + std::optional<int> opt1(1); + std::optional<int> opt2; + static_assert(noexcept(opt1.swap(opt2)) == true, ""); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 1); + assert(static_cast<bool>(opt2) == false); + opt1.swap(opt2); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 1); + } + { + std::optional<int> opt1; + std::optional<int> opt2(2); + static_assert(noexcept(opt1.swap(opt2)) == true, ""); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 2); + opt1.swap(opt2); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 2); + assert(static_cast<bool>(opt2) == false); + } + { + std::optional<int> opt1(1); + std::optional<int> opt2(2); + static_assert(noexcept(opt1.swap(opt2)) == true, ""); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 1); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 2); + opt1.swap(opt2); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 2); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 1); + } + { + std::optional<X> opt1; + std::optional<X> opt2; + static_assert(noexcept(opt1.swap(opt2)) == true, ""); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == false); + opt1.swap(opt2); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == false); + assert(X::dtor_called == 0); + } + { + std::optional<X> opt1(1); + std::optional<X> opt2; + static_assert(noexcept(opt1.swap(opt2)) == true, ""); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 1); + assert(static_cast<bool>(opt2) == false); + X::dtor_called = 0; + opt1.swap(opt2); + assert(X::dtor_called == 1); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 1); + } + { + std::optional<X> opt1; + std::optional<X> opt2(2); + static_assert(noexcept(opt1.swap(opt2)) == true, ""); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 2); + X::dtor_called = 0; + opt1.swap(opt2); + assert(X::dtor_called == 1); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 2); + assert(static_cast<bool>(opt2) == false); + } + { + std::optional<X> opt1(1); + std::optional<X> opt2(2); + static_assert(noexcept(opt1.swap(opt2)) == true, ""); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 1); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 2); + X::dtor_called = 0; + opt1.swap(opt2); + assert(X::dtor_called == 1); // from inside std::swap + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 2); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 1); + } + { + std::optional<Y> opt1; + std::optional<Y> opt2; + static_assert(noexcept(opt1.swap(opt2)) == false, ""); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == false); + opt1.swap(opt2); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == false); + assert(Y::dtor_called == 0); + } + { + std::optional<Y> opt1(1); + std::optional<Y> opt2; + static_assert(noexcept(opt1.swap(opt2)) == false, ""); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 1); + assert(static_cast<bool>(opt2) == false); + Y::dtor_called = 0; + opt1.swap(opt2); + assert(Y::dtor_called == 1); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 1); + } + { + std::optional<Y> opt1; + std::optional<Y> opt2(2); + static_assert(noexcept(opt1.swap(opt2)) == false, ""); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 2); + Y::dtor_called = 0; + opt1.swap(opt2); + assert(Y::dtor_called == 1); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 2); + assert(static_cast<bool>(opt2) == false); + } + { + std::optional<Y> opt1(1); + std::optional<Y> opt2(2); + static_assert(noexcept(opt1.swap(opt2)) == false, ""); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 1); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 2); + Y::dtor_called = 0; + opt1.swap(opt2); + assert(Y::dtor_called == 0); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 2); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 1); + } + { + std::optional<Z> opt1; + std::optional<Z> opt2; + static_assert(noexcept(opt1.swap(opt2)) == false, ""); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == false); + opt1.swap(opt2); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == false); + } + { + std::optional<Z> opt1; + opt1.emplace(1); + std::optional<Z> opt2; + static_assert(noexcept(opt1.swap(opt2)) == false, ""); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 1); + assert(static_cast<bool>(opt2) == false); + try + { + opt1.swap(opt2); + assert(false); + } + catch (int i) + { + assert(i == 7); + } + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 1); + assert(static_cast<bool>(opt2) == false); + } + { + std::optional<Z> opt1; + std::optional<Z> opt2; + opt2.emplace(2); + static_assert(noexcept(opt1.swap(opt2)) == false, ""); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 2); + try + { + opt1.swap(opt2); + assert(false); + } + catch (int i) + { + assert(i == 7); + } + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 2); + } + { + std::optional<Z> opt1; + opt1.emplace(1); + std::optional<Z> opt2; + opt2.emplace(2); + static_assert(noexcept(opt1.swap(opt2)) == false, ""); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 1); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 2); + try + { + opt1.swap(opt2); + assert(false); + } + catch (int i) + { + assert(i == 6); + } + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 1); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 2); + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional_const_void.fail.cpp b/libcxx/test/utilities/optional/optional.object/optional_const_void.fail.cpp new file mode 100644 index 00000000000..a471fb55eb6 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional_const_void.fail.cpp @@ -0,0 +1,23 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// T shall be an object type and shall satisfy the requirements of Destructible + +#include <optional> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + std::optional<const void> opt; +#else +#error +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional_not_destructible.fail.cpp b/libcxx/test/utilities/optional/optional.object/optional_not_destructible.fail.cpp new file mode 100644 index 00000000000..19b037e1446 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional_not_destructible.fail.cpp @@ -0,0 +1,33 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// T shall be an object type and shall satisfy the requirements of Destructible + +#include <optional> + +#if _LIBCPP_STD_VER > 11 + +struct X +{ +private: + ~X() {} +}; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + std::optional<X> opt; +#else +#error +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional_not_noexcept_destructible.fail.cpp b/libcxx/test/utilities/optional/optional.object/optional_not_noexcept_destructible.fail.cpp new file mode 100644 index 00000000000..da4d8c1ed60 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional_not_noexcept_destructible.fail.cpp @@ -0,0 +1,32 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// T shall be an object type and shall satisfy the requirements of Destructible + +#include <optional> + +#if _LIBCPP_STD_VER > 11 + +struct X +{ + ~X() noexcept(false) {} +}; + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + std::optional<X> opt; +#else +#error +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/optional_void.fail.cpp b/libcxx/test/utilities/optional/optional.object/optional_void.fail.cpp new file mode 100644 index 00000000000..950043a26bb --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/optional_void.fail.cpp @@ -0,0 +1,23 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// T shall be an object type and shall satisfy the requirements of Destructible + +#include <optional> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + std::optional<void> opt; +#else +#error +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.object/types.pass.cpp b/libcxx/test/utilities/optional/optional.object/types.pass.cpp new file mode 100644 index 00000000000..ae3f7d7d3d9 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.object/types.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> +// class optional +// { +// public: +// typedef T value_type; +// ... + +#include <optional> +#include <type_traits> + +#if _LIBCPP_STD_VER > 11 + +template <class Opt, class T> +void +test() +{ + static_assert(std::is_same<typename Opt::value_type, T>::value, ""); +} + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + test<std::optional<int>, int>(); + test<std::optional<const int>, const int>(); + test<std::optional<double>, double>(); + test<std::optional<const double>, const double>(); +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.relops/equal.pass.cpp b/libcxx/test/utilities/optional/optional.relops/equal.pass.cpp new file mode 100644 index 00000000000..ec0503c39ba --- /dev/null +++ b/libcxx/test/utilities/optional/optional.relops/equal.pass.cpp @@ -0,0 +1,63 @@ +//===----------------------------------------------------------------------===// +// +// 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 <optional> +#include <type_traits> +#include <cassert> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + typedef int T; + typedef std::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 +} diff --git a/libcxx/test/utilities/optional/optional.relops/less_than.pass.cpp b/libcxx/test/utilities/optional/optional.relops/less_than.pass.cpp new file mode 100644 index 00000000000..a1f6021482b --- /dev/null +++ b/libcxx/test/utilities/optional/optional.relops/less_than.pass.cpp @@ -0,0 +1,86 @@ +//===----------------------------------------------------------------------===// +// +// 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 <optional> + +#if _LIBCPP_STD_VER > 11 + +struct X +{ + int i_; + + constexpr X(int i) : i_(i) {} +}; + +namespace std +{ + +template <> +struct less<X> +{ + constexpr + bool + operator()(const X& x, const X& y) const + { + return x.i_ < y.i_; + } +}; + +} + +#endif + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + typedef std::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.specalg/make_optional.pass.cpp b/libcxx/test/utilities/optional/optional.specalg/make_optional.pass.cpp new file mode 100644 index 00000000000..afd735a634b --- /dev/null +++ b/libcxx/test/utilities/optional/optional.specalg/make_optional.pass.cpp @@ -0,0 +1,51 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// optional<typename decay<T>::type> +// make_optional(T&& v); + +#include <optional> +#include <string> +#include <memory> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + std::optional<int> opt = std::make_optional(2); + assert(*opt == 2); + } + { + std::string s("123"); + std::optional<std::string> opt = std::make_optional(s); + assert(*opt == s); + } + { + std::string s("123"); + std::optional<std::string> opt = std::make_optional(std::move(s)); + assert(*opt == "123"); + assert(s.empty()); + } + { + std::unique_ptr<int> s(new int(3)); + std::optional<std::unique_ptr<int>> opt = std::make_optional(std::move(s)); + assert(**opt == 3); + assert(s == nullptr); + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.specalg/swap.pass.cpp b/libcxx/test/utilities/optional/optional.specalg/swap.pass.cpp new file mode 100644 index 00000000000..d98dd40ec6b --- /dev/null +++ b/libcxx/test/utilities/optional/optional.specalg/swap.pass.cpp @@ -0,0 +1,303 @@ +//===----------------------------------------------------------------------===// +// +// 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> void swap(optional<T>& x, optional<T>& y) +// noexcept(noexcept(x.swap(y))); + +#include <optional> +#include <type_traits> +#include <cassert> + +#if _LIBCPP_STD_VER > 11 + +class X +{ + int i_; +public: + static unsigned dtor_called; + X(int i) : i_(i) {} + X(X&& x) = default; + X& operator=(X&&) = default; + ~X() {++dtor_called;} + + friend bool operator==(const X& x, const X& y) {return x.i_ == y.i_;} +}; + +unsigned X::dtor_called = 0; + +class Y +{ + int i_; +public: + static unsigned dtor_called; + Y(int i) : i_(i) {} + Y(Y&&) = default; + ~Y() {++dtor_called;} + + friend constexpr bool operator==(const Y& x, const Y& y) {return x.i_ == y.i_;} + friend void swap(Y& x, Y& y) {std::swap(x.i_, y.i_);} +}; + +unsigned Y::dtor_called = 0; + +class Z +{ + int i_; +public: + Z(int i) : i_(i) {} + Z(Z&&) {throw 7;} + + friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;} + friend void swap(Z& x, Z& y) {throw 6;} +}; + + +#endif // _LIBCPP_STD_VER > 11 + +int main() +{ +#if _LIBCPP_STD_VER > 11 + { + std::optional<int> opt1; + std::optional<int> opt2; + static_assert(noexcept(swap(opt1, opt2)) == true, ""); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == false); + swap(opt1, opt2); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == false); + } + { + std::optional<int> opt1(1); + std::optional<int> opt2; + static_assert(noexcept(swap(opt1, opt2)) == true, ""); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 1); + assert(static_cast<bool>(opt2) == false); + swap(opt1, opt2); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 1); + } + { + std::optional<int> opt1; + std::optional<int> opt2(2); + static_assert(noexcept(swap(opt1, opt2)) == true, ""); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 2); + swap(opt1, opt2); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 2); + assert(static_cast<bool>(opt2) == false); + } + { + std::optional<int> opt1(1); + std::optional<int> opt2(2); + static_assert(noexcept(swap(opt1, opt2)) == true, ""); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 1); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 2); + swap(opt1, opt2); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 2); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 1); + } + { + std::optional<X> opt1; + std::optional<X> opt2; + static_assert(noexcept(swap(opt1, opt2)) == true, ""); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == false); + swap(opt1, opt2); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == false); + assert(X::dtor_called == 0); + } + { + std::optional<X> opt1(1); + std::optional<X> opt2; + static_assert(noexcept(swap(opt1, opt2)) == true, ""); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 1); + assert(static_cast<bool>(opt2) == false); + X::dtor_called = 0; + swap(opt1, opt2); + assert(X::dtor_called == 1); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 1); + } + { + std::optional<X> opt1; + std::optional<X> opt2(2); + static_assert(noexcept(swap(opt1, opt2)) == true, ""); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 2); + X::dtor_called = 0; + swap(opt1, opt2); + assert(X::dtor_called == 1); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 2); + assert(static_cast<bool>(opt2) == false); + } + { + std::optional<X> opt1(1); + std::optional<X> opt2(2); + static_assert(noexcept(swap(opt1, opt2)) == true, ""); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 1); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 2); + X::dtor_called = 0; + swap(opt1, opt2); + assert(X::dtor_called == 1); // from inside std::swap + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 2); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 1); + } + { + std::optional<Y> opt1; + std::optional<Y> opt2; + static_assert(noexcept(swap(opt1, opt2)) == false, ""); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == false); + swap(opt1, opt2); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == false); + assert(Y::dtor_called == 0); + } + { + std::optional<Y> opt1(1); + std::optional<Y> opt2; + static_assert(noexcept(swap(opt1, opt2)) == false, ""); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 1); + assert(static_cast<bool>(opt2) == false); + Y::dtor_called = 0; + swap(opt1, opt2); + assert(Y::dtor_called == 1); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 1); + } + { + std::optional<Y> opt1; + std::optional<Y> opt2(2); + static_assert(noexcept(swap(opt1, opt2)) == false, ""); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 2); + Y::dtor_called = 0; + swap(opt1, opt2); + assert(Y::dtor_called == 1); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 2); + assert(static_cast<bool>(opt2) == false); + } + { + std::optional<Y> opt1(1); + std::optional<Y> opt2(2); + static_assert(noexcept(swap(opt1, opt2)) == false, ""); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 1); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 2); + Y::dtor_called = 0; + swap(opt1, opt2); + assert(Y::dtor_called == 0); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 2); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 1); + } + { + std::optional<Z> opt1; + std::optional<Z> opt2; + static_assert(noexcept(swap(opt1, opt2)) == false, ""); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == false); + swap(opt1, opt2); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == false); + } + { + std::optional<Z> opt1; + opt1.emplace(1); + std::optional<Z> opt2; + static_assert(noexcept(swap(opt1, opt2)) == false, ""); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 1); + assert(static_cast<bool>(opt2) == false); + try + { + swap(opt1, opt2); + assert(false); + } + catch (int i) + { + assert(i == 7); + } + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 1); + assert(static_cast<bool>(opt2) == false); + } + { + std::optional<Z> opt1; + std::optional<Z> opt2; + opt2.emplace(2); + static_assert(noexcept(swap(opt1, opt2)) == false, ""); + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 2); + try + { + swap(opt1, opt2); + assert(false); + } + catch (int i) + { + assert(i == 7); + } + assert(static_cast<bool>(opt1) == false); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 2); + } + { + std::optional<Z> opt1; + opt1.emplace(1); + std::optional<Z> opt2; + opt2.emplace(2); + static_assert(noexcept(swap(opt1, opt2)) == false, ""); + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 1); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 2); + try + { + swap(opt1, opt2); + assert(false); + } + catch (int i) + { + assert(i == 6); + } + assert(static_cast<bool>(opt1) == true); + assert(*opt1 == 1); + assert(static_cast<bool>(opt2) == true); + assert(*opt2 == 2); + } +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.syn/optional_const_in_place_t.fail.cpp b/libcxx/test/utilities/optional/optional.syn/optional_const_in_place_t.fail.cpp new file mode 100644 index 00000000000..fc661f0eadc --- /dev/null +++ b/libcxx/test/utilities/optional/optional.syn/optional_const_in_place_t.fail.cpp @@ -0,0 +1,24 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// A program that necessitates the instantiation of template optional for +// (possibly cv-qualified) in_place_t is ill-formed. + +#include <optional> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + std::optional<const std::inplace_t> opt; +#else +#error +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.syn/optional_const_lvalue_ref.fail.cpp b/libcxx/test/utilities/optional/optional.syn/optional_const_lvalue_ref.fail.cpp new file mode 100644 index 00000000000..8836ee6716c --- /dev/null +++ b/libcxx/test/utilities/optional/optional.syn/optional_const_lvalue_ref.fail.cpp @@ -0,0 +1,24 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// A program that necessitates the instantiation of template optional for a +// reference type is ill-formed. + +#include <optional> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + std::optional<const int&> opt; +#else +#error +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.syn/optional_const_nullopt_t.fail.cpp b/libcxx/test/utilities/optional/optional.syn/optional_const_nullopt_t.fail.cpp new file mode 100644 index 00000000000..82aa4c1220c --- /dev/null +++ b/libcxx/test/utilities/optional/optional.syn/optional_const_nullopt_t.fail.cpp @@ -0,0 +1,24 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// A program that necessitates the instantiation of template optional for +// (possibly cv-qualified) null_opt_t is ill-formed. + +#include <optional> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + std::optional<const std::nullopt_t> opt; +#else +#error +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.syn/optional_in_place_t.fail.cpp b/libcxx/test/utilities/optional/optional.syn/optional_in_place_t.fail.cpp new file mode 100644 index 00000000000..eb11460157b --- /dev/null +++ b/libcxx/test/utilities/optional/optional.syn/optional_in_place_t.fail.cpp @@ -0,0 +1,24 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// A program that necessitates the instantiation of template optional for +// (possibly cv-qualified) in_place_t is ill-formed. + +#include <optional> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + std::optional<std::inplace_t> opt; +#else +#error +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp b/libcxx/test/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp new file mode 100644 index 00000000000..df5d246cef6 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.syn/optional_includes_initializer_list.pass.cpp @@ -0,0 +1,21 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// #include <initializer_list> + +#include <optional> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + std::initializer_list<int> list; +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.syn/optional_lvalue_ref.fail.cpp b/libcxx/test/utilities/optional/optional.syn/optional_lvalue_ref.fail.cpp new file mode 100644 index 00000000000..bc143fc6c13 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.syn/optional_lvalue_ref.fail.cpp @@ -0,0 +1,24 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// A program that necessitates the instantiation of template optional for a +// reference type is ill-formed. + +#include <optional> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + std::optional<int&> opt; +#else +#error +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.syn/optional_nullopt_t.fail.cpp b/libcxx/test/utilities/optional/optional.syn/optional_nullopt_t.fail.cpp new file mode 100644 index 00000000000..bcb152e553c --- /dev/null +++ b/libcxx/test/utilities/optional/optional.syn/optional_nullopt_t.fail.cpp @@ -0,0 +1,24 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// A program that necessitates the instantiation of template optional for +// (possibly cv-qualified) null_opt_t is ill-formed. + +#include <optional> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + std::optional<std::nullopt_t> opt; +#else +#error +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/optional.syn/optional_rvalue_ref.fail.cpp b/libcxx/test/utilities/optional/optional.syn/optional_rvalue_ref.fail.cpp new file mode 100644 index 00000000000..a0ba2f00699 --- /dev/null +++ b/libcxx/test/utilities/optional/optional.syn/optional_rvalue_ref.fail.cpp @@ -0,0 +1,24 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +// A program that necessitates the instantiation of template optional for a +// reference type is ill-formed. + +#include <optional> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + std::optional<int&&> opt; +#else +#error +#endif // _LIBCPP_STD_VER > 11 +} diff --git a/libcxx/test/utilities/optional/version.pass.cpp b/libcxx/test/utilities/optional/version.pass.cpp new file mode 100644 index 00000000000..e7581b5431b --- /dev/null +++ b/libcxx/test/utilities/optional/version.pass.cpp @@ -0,0 +1,20 @@ +//===----------------------------------------------------------------------===// +// +// 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> + +#include <optional> + +#ifndef _LIBCPP_VERSION +#error _LIBCPP_VERSION not defined +#endif + +int main() +{ +} |
